en>Widefox: fix sect order

2013-06-29T02:16:00Z

fix sect order

← Older revision		Revision as of 04:16, 29 June 2013
Line 1:		Line 1:
	~~Hi there~~, ~~I am Alyson Pomerleau~~ and ~~I think~~ it ~~sounds quite good when you say~~ it. The ~~favorite hobby for him~~ and ~~his kids~~ is ~~style and he'll be starting some thing else alongside~~ with it. ~~Kentucky~~ is ~~exactly where I've usually been residing~~. ~~Distributing production has been his occupation for some~~ time.<br><br>~~My page~~: ~~[http~~://~~aerosol~~.yu.ac.kr/~~?document_srl~~=~~1806497 psychics online~~]		{{Tree search algorithm}}
			'''Iterative deepening depth-first search'''<ref>{{cite journal\|last=Korf\|first=Richard\|title=Depth-first Iterative-Deepening: An Optimal Admissible Tree Search\|journal=Artificial Intelligence\|year=1985\|volume=27\|pages=97–109}}</ref> (IDDFS) is a [[state space search]] strategy in which a [[depth-limited search]] is run repeatedly, increasing the depth limit with each iteration until it reaches <math>d</math>, the depth of the shallowest goal state. IDDFS is equivalent to [[breadth-first search]], but uses much less memory; on each iteration, it visits the [[node (computer science)\|node]]s in the [[search tree]] in the same order as [[depth-first search]], but the cumulative order in which nodes are first visited is effectively breadth-first.

			== Properties ==
			IDDFS combines [[depth-first search]]'s space-efficiency and [[breadth-first search]]'s completeness (when the [[branching factor]] is finite). It is optimal when the path cost is a non-decreasing function of the depth of the node.

			The [[space complexity]] of IDDFS is <math>O(bd)</math>, where <math>b</math> is the branching factor and <math>d</math> is the depth of shallowest goal. Since iterative deepening visits states multiple times, it may seem wasteful, but it turns out to be not so costly, since in a tree most of the nodes are in the bottom level, so it does not matter much if the upper levels are visited multiple times.<ref name="rn3">{{Russell Norvig 2003}}</ref>

			The main advantage of IDDFS in [[game tree]] searching is that the earlier searches tend to improve the commonly used heuristics, such as the [[killer heuristic]] and [[alpha-beta pruning]], so that a more accurate estimate of the score of various nodes at the final depth search can occur, and the search completes more quickly since it is done in a better order. For example, alpha-beta pruning is most efficient if it searches the best moves first.<ref name="rn3"/>

			A second advantage is the responsiveness of the algorithm. Because early iterations use small values for <math>d</math>, they execute extremely quickly. This allows the algorithm to supply early indications of the result almost immediately, followed by refinements as <math>d</math> increases. When used in an interactive setting, such as in a [[chess]]-playing program, this facility allows the program to play at any time with the current best move found in the search it has completed so far. This can be phrased as each depth of the search [[corecursive\|''co''recursively]] producing a better approximation of the solution, though the work done at each step is recursive. This is not possible with a traditional depth-first search, which does not produce intermediate results.

			The [[time complexity]] of IDDFS in well-balanced trees works out to be the same as Depth-first search: <math>O(b^{d})</math>.

			In an iterative deepening search, the nodes on the bottom level are expanded once, those on the
			next to bottom level are expanded twice, and so on, up to the root of the search tree, which is
			expanded <math>d+1</math> times.<ref name="rn3"/> So the total number of expansions in an iterative deepening search is

			:<math>(d)b + (d-1)b^{2} + \cdots + 3b^{d-2} + 2b^{d-1} + b^{d}</math>

			:<math>\sum_{i=1}^d (d+1-i)b^i</math>

			For <math>b=10</math> and <math>d=5</math> the number is

			: 50 + 400 + 3,000 + 20,000 + 100,000 = 123,450

			All together, an iterative deepening search from depth 1 to depth <math>d</math> expands only about 11% more nodes than a single breadth-first or depth-limited search to depth <math>d</math>, when <math>b=10</math>. The higher the branching factor, the lower the overhead of repeatedly expanded states, but even when the branching factor is 2, iterative deepening search only takes about twice as long as a complete breadth-first search. This means that the time complexity of iterative deepening is still <math>O(b^d)</math>, and the space complexity is <math>O(d)</math> like a regular depth-first search. In general, iterative deepening is the preferred search method when there is a large search space and the depth of the solution is not known.<ref name="rn3"/>

			==Example==
			For the following graph:

			[[Image:graph.traversal.example.svg\|200px]]

			a depth-first search starting at A, assuming that the left edges in the shown graph are chosen before right edges, and assuming the search remembers previously-visited nodes and will not repeat them (since this is a small graph), will visit the nodes in the following order: A, B, D, F, E, C, G. The edges traversed in this search form a [[Trémaux tree]], a structure with important applications in [[graph theory]].

			Performing the same search without remembering previously visited nodes results in visiting nodes in the order A, B, D, F, E, A, B, D, F, E, etc. forever, caught in the A, B, D, F, E cycle and never reaching C or G.

			Iterative deepening prevents this loop and will reach the following nodes on the following depths, assuming it proceeds left-to-right as above:

			*0: A
			*1: A (repeated), B, C, E
			(Note that iterative deepening has now seen C, when a conventional depth-first search did not.)
			*2: A, B, D, F, C, G, E, F
			(Note that it still sees C, but that it came later. Also note that it sees E via a different path, and loops back to F twice.)
			*3: A, B, D, F, E, C, G, E, F, B

			For this graph, as more depth is added, the two cycles "ABFE" and "AEFB" will simply get longer before the algorithm gives up and tries another branch.

			-

			== Algorithm ==

			The following pseudocode shows IDDFS implemented in terms of a recursive depth-limited DFS (called DLS).

			'''IDDFS'''(root, goal)
			{
			depth = 0
			for(i=1, i<10, i++)
			{
			DFS(limit=i)
			}
			}

			== Related algorithms ==

			Similar to iterative deepening is a search strategy called [[iterative lengthening search]] that works with increasing path-cost limits instead of depth-limits. It expands nodes in the order of increasing path cost; therefore the first goal it encounters is the one with the cheapest path cost. But iterative lengthening incurs substantial overhead that makes it less useful than iterative deepening.<ref name="rn3">{{Russell Norvig 2003}}</ref>

			==Notes==
			{{reflist}}

			{{DEFAULTSORT:Iterative Deepening Depth-First Search}}
			[[Category:Graph algorithms]]
			[[Category:Search algorithms]]

en>Helpful Pixie Bot: ISBNs (Build KH)

2012-05-12T05:01:10Z

ISBNs (Build KH)

New page

Hi there, I am Alyson Pomerleau and I think it sounds quite good when you say it. The favorite hobby for him and his kids is style and he'll be starting some thing else alongside with it. Kentucky is exactly where I've usually been residing. Distributing production has been his occupation for some time.<br><br>My page: [http://aerosol.yu.ac.kr/?document_srl=1806497 psychics online]

Wide Mouth Frog protocol - Revision history

en>Widefox: fix sect order

en>Helpful Pixie Bot: ISBNs (Build KH)