|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{multiple issues|
| | Greetings! I am Myrtle Shroyer. Her family lives in Minnesota. Hiring is her working day occupation now but she's always needed her personal company. To do aerobics is a thing that I'm totally addicted to.<br><br>Also visit my web site [https://pinkmulesl.zendesk.com/entries/30417152-Valuable-Guidance-For-Successfully-Treating-Candidiasis at home std testing] |
| {{Refimprove|date=December 2013}}
| |
| {{Confusing|date=December 2011}}
| |
| }}
| |
| | |
| In [[computational complexity theory]] and [[computability theory]], a '''search problem''' is a type of [[computational problem]] represented by a [[binary relation]]. If ''R'' is a binary relation such that field(''R'') ⊆ Γ<sup>+</sup> and ''T'' is a [[Turing machine]], then ''T'' calculates ''R'' if:
| |
| | |
| * If ''x'' is such that there is some ''y'' such that ''R''(''x'', ''y'') then ''T'' accepts ''x'' with output ''z'' such that ''R''(''x'', ''z'') (there may be multiple ''y'', and ''T'' need only find one of them)
| |
| * If ''x'' is such that there is no ''y'' such that ''R''(''x'', ''y'') then ''T'' rejects ''x''
| |
| | |
| Intuitively, the problem consists in finding structure "y" in object "x". An [[algorithm]] is said to solve the problem if at least one corresponding structure exists, and then one occurrence of this structure is outputted; otherwise, the algorithm stops with an appropriate output ("Item not found" or any message of the like).
| |
| | |
| Such problems occur very frequently in [[graph theory]], for example, where searching graphs for structures such as particular [[Matching (graph theory)|matching]], [[clique (graph theory)|cliques]], [[Independent set (graph theory)|independent set]], etc. are subjects of interest.
| |
| | |
| Note that the graph of a partial function is a binary relation, and if ''T'' calculates a partial function then there is at most one possible output.
| |
| | |
| A relation ''R'' can be viewed as a search problem, and a Turing machine which calculates ''R'' is also said to solve it. Every search problem has a corresponding [[decision problem]], namely
| |
| | |
| :<math>L(R)=\{x\mid \exists y R(x,y)\}. \, </math>
| |
| | |
| This definition may be generalized to ''n''-ary relations using any suitable encoding which allows multiple strings to be compressed into one string (for instance by listing them consecutively with a delimiter).
| |
| | |
| ==Definition==
| |
| A search problem is defined by:<ref>{{cite web|last=Leyton-Brown|first=Kevin|title=Graph Search|url=http://www.cs.ubc.ca/~kevinlb/teaching/cs322%20-%202009-10/Lectures/Search2.pdf|publisher=ubc|accessdate=7 February 2013}}</ref>
| |
| * A set of [[State (computer science)|states]]
| |
| * A [[start state]]
| |
| * A [[goal state]] or goal test
| |
| :a boolean function which tells us whether a given state is a goal state
| |
| * A [[successor function]]
| |
| :line a mapping from a state to a set of new states
| |
| | |
| ==Objective==
| |
| Find a solution when not given an algorithm to solve a problem, but only a specification of what a solution looks like.<ref>{{cite web|last=Leyton-Brown|first=Kevin|title=Graph Search|url=http://www.cs.ubc.ca/~kevinlb/teaching/cs322%20-%202009-10/Lectures/Search2.pdf|publisher=ubc|accessdate=7 February 2013}}</ref>
| |
| | |
| ==Search method==
| |
| * Generic search algorithm: given a graph, start nodes, and goal nodes, incrementally explore paths from the start nodes.
| |
| * Maintain a frontier of paths from the start node that have been explored.
| |
| * As search proceeds, the frontier expands into the unexplored nodes until a goal node is encountered.
| |
| * The way in which the frontier is expanded defines the search strategy.<ref>{{cite web|last=Leyton-Brown|first=Kevin|title=Graph Search|url=http://www.cs.ubc.ca/~kevinlb/teaching/cs322%20-%202009-10/Lectures/Search2.pdf|publisher=ubc|accessdate=7 February 2013}}</ref>
| |
| Input: a graph,
| |
| a set of start nodes,
| |
| Boolean procedure goal(n) that tests if n is a goal node.
| |
| frontier := {s : s is a start node};
| |
| while frontier is not empty:
| |
| select and remove path <n0, ..., nk> from frontier;
| |
| if goal(nk)
| |
| return <n0, ..., nk>;
| |
| for every neighbor n of nk
| |
| add <n0, ..., nk, n> to frontier;
| |
| end while
| |
| | |
| ==References==
| |
| {{reflist}}
| |
| | |
| ==See also==
| |
| *[[Decision problem]]
| |
| *[[Optimization problem]]
| |
| *[[Counting problem (complexity)]]
| |
| *[[Function problem]]
| |
| *[[Search games]]
| |
| | |
| {{PlanetMath attribution|id=3425|title=search problem}}
| |
| | |
| [[Category:Computational problems]]
| |
Greetings! I am Myrtle Shroyer. Her family lives in Minnesota. Hiring is her working day occupation now but she's always needed her personal company. To do aerobics is a thing that I'm totally addicted to.
Also visit my web site at home std testing