|
|
| Line 1: |
Line 1: |
| {{graph search algorithm}}
| | <br><br>There is in fact a way about this and that would engage the rummage around for a cheap web hosting corporation that is able to supply your business with what it actually desires. The subsequent desktop software, which is a fragment more exclusive nevertheless way more commanding is the admired SeNukeX. When you begin blogging, you must look at the focus of your blog - this is often called a niche. These days, with the focus turning toward other paradigms, I recommend to new authors to take these steps toward building a readership and a successful writing. Control Panel Deluxe as offered inside the Hostgator BabyCroc account has something to be said for itself. Believe it or not, you may be searching for Hostgator tutorials soon enough. This usually means employing wind and solar powered energy sources. You will be able to produce tons of websites under your own brand name, with your own packages , features and prices. Most recently the Host Gator went green to support the environment. In the end, a little bit of time spent researching the market will definitely help you a lot in ensuring that you're getting the best deal that's available out there - especially when you're on a tight budget.<br><br><br><br>With a WordPress site by means of your HostGator cPanel as they'd say, this would be yours and nobody can stir it.HostGator is really affordable, at less than a sheer $50 you can get yourself one whole [https://Www.Youtube.com/results?search_query=year%27s+blog,creativecommons year's blog] hosting which you might handle as you like. Next we have your own business. HostGator techs after some conversation with a very large accounts support the fact that they not only escape was adamant about, but if I had to manage all of the backup process, etc., myself, that I really was asking for a problem that would set me back years in the business since the sites were responsible for my income. What's great about HostGator, which will most definitely be included in any [http://www.gorod-nadym.ru/small-orange-hostgator HostGator review], is the fact that the expertise they use is simple. However with the variety of decisions accessible, it is often tough to determine which one to [http://Www.Dict.cc/?s=utilize utilize]. Are you going to use the first coupon you can find or are you willing to search high and low for the best? HostGator is one of the most popular web hosting companies and it has received a lot of positive feedback from their clients from over 200 countries internationally. While getting a domain name is less demanding, sometimes choosing the correct hosting provider can be a little more complicated. |
| '''Backtracking''' is a general [[algorithm]] for finding all (or some) solutions to some [[computational problem]], that incrementally builds candidates to the solutions, and abandons each partial candidate ''c'' ("backtracks") as soon as it determines that ''c'' cannot possibly be completed to a valid solution.<ref>{{cite book | title = [[The Art of Computer Programming]] | author = Donald E. Knuth | publisher = Addison-Wesley | year = 1968}}</ref><ref>{{cite book | title = Introduction to Algorithms | author = Thomas H. Cormen | coauthors = Charles E. Leiserson, Ronald R. Rivest, Cliff Stein | publisher = McGraw-Hill | year = 1990}}</ref><ref>{{cite web | url=http://www.cse.ohio-state.edu/~gurari/course/cis680/cis680Ch19.html#QQ1-51-128 Backtracking algorithms | title=CIS 680: DATA STRUCTURES: Chapter 19: Backtracking Algorithms | year=1999 | author=Gurari, Eitan}}</ref>
| |
| | |
| The classic textbook example of the use of backtracking is the [[eight queens puzzle]], that asks for all arrangements of eight [[chess]] [[queen (chess)|queens]] on a standard [[chessboard]] so that no queen attacks any other. In the common backtracking approach, the partial candidates are arrangements of ''k'' queens in the first ''k'' rows of the board, all in different rows and columns. Any partial solution that contains two mutually attacking queens can be abandoned, since it cannot possibly be completed to a valid solution.
| |
| | |
| Backtracking can be applied only for problems which admit the concept of a "partial candidate solution" and a relatively quick test of whether it can possibly be completed to a valid solution. It is useless, for example, for locating a given value in an unordered table. When it is applicable, however, backtracking is often much faster than [[brute force search|brute force enumeration]] of all complete candidates, since it can eliminate a large number of candidates with a single test.
| |
| | |
| Backtracking is an important tool for solving [[constraint satisfaction problem]]s, such as [[crosswords]], [[verbal arithmetic]], [[Algorithmics of sudoku|Sudoku]], and many other puzzles. It is often the most convenient (if not the most efficient{{citation needed|date=January 2011}}) technique for [[parsing]], for the [[knapsack problem]] and other [[combinatorial optimization]] problems. It is also the basis of the so-called [[logic programming]] languages such as [[Icon programming language|Icon]], [[Planner programming language|Planner]] and [[Prolog]]. Backtracking is also utilized in the (diff) difference engine for the [[MediaWiki]] software{{citation needed|date=October 2012}}.
| |
| | |
| Backtracking depends on user-given "[[procedural parameter|black box procedure]]s" that define the problem to be solved, the nature of the partial candidates, and how they are extended into complete candidates. It is therefore a [[metaheuristic]] rather than a specific algorithm – although, unlike many other meta-heuristics, it is guaranteed to find all solutions to a finite problem in a bounded amount of time.
| |
| | |
| The term "backtrack" was coined by American mathematician [[Derrick Henry Lehmer|D. H. Lehmer]] in the 1950s.<ref>{{cite book
| |
| | title= Handbook of Constraint Programming
| |
| | url= http://books.google.com/books?id=Kjap9ZWcKOoC
| |
| | series= [http://www.elsevier.com/wps/find/bookdescription.cws_home/BS_FAI/description#description Foundations of Artificial Intelligence]
| |
| | last= Rossi
| |
| | first= Francesca
| |
| | coauthors= Beek, Peter Van; Walsh, Toby
| |
| | date= August 2006
| |
| | page= 14
| |
| | chapter= Constraint Satisfaction: An Emerging Paradigm
| |
| | chapterurl= http://books.google.com/books?id=Kjap9ZWcKOoC&pg=PA14
| |
| | publisher= [[Elsevier]]
| |
| | location= [[Amsterdam]]
| |
| | quote= Bitner and Reingold credit Lehmer with first using the term 'backtrack' in the 1950s.
| |
| | isbn= 978-0-444-52726-4
| |
| | accessdate= 2008-12-30
| |
| }}</ref> The pioneer string-processing language [[SNOBOL]] (1962) may have been the first to provide a built-in general backtracking facility.
| |
| | |
| ==Description of the method==
| |
| | |
| The backtracking algorithm enumerates a set of ''partial candidates'' that, in principle, could be ''completed'' in various ways to give all the possible solutions to the given problem. The completion is done incrementally, by a sequence of ''candidate extension steps.''
| |
| | |
| Conceptually, the partial candidates are the nodes of a [[tree structure]], the ''potential search tree.'' Each partial candidate is the parent of the candidates that differ from it by a single extension step; the leaves of the tree are the partial candidates that cannot be extended any further.
| |
| | |
| The backtracking algorithm traverses this search tree [[recursion (computer science)|recursively]], from the root down, in [[depth-first search|depth-first order]]. At each node ''c'', the algorithm checks whether ''c'' can be completed to a valid solution. If it cannot, the whole sub-tree rooted at ''c'' is skipped (''pruned''). Otherwise, the algorithm (1) checks whether ''c'' itself is a valid solution, and if so reports it to the user; and (2) recursively enumerates all sub-trees of ''c''. The two tests and the children of each node are defined by user-given procedures.
| |
| | |
| Therefore, the ''actual search tree'' that is traversed by the algorithm is only a part of the potential tree. The total cost of the algorithm is the number of nodes of the actual tree times the cost of obtaining and processing each node. This fact should be considered when choosing the potential search tree and implementing the pruning test.
| |
| | |
| ===Pseudocode===
| |
| In order to apply backtracking to a specific class of problems, one must provide the data ''P'' for the particular instance of the problem that is to be solved, and six [[procedural parameter]]s, ''root'', ''reject'', ''accept'', ''first'', ''next'', and ''output''. These procedures should take the instance data ''P'' as a parameter and should do the following:
| |
| # '''''root''(''P'')'': return the partial candidate at the root of the search tree.
| |
| # ''reject''(''P'',''c''): return ''true'' only if the partial candidate ''c'' is not worth completing.
| |
| # ''accept''(''P'',''c''): return ''true'' if ''c'' is a solution of ''P'', and ''false'' otherwise.
| |
| # ''first''(''P'',''c''): generate the first extension of candidate ''c''.
| |
| # ''next''(''P'',''s''): generate the next alternative extension of a candidate, after the extension ''s''.
| |
| # ''output''(''P'',''c''): use the solution ''c'' of ''P'', as appropriate to the application.
| |
| | |
| The backtracking algorithm reduces then to the call ''bt''(''root''(''P'')), where ''bt'' is the following recursive procedure:
| |
| | |
| '''procedure''' ''bt''(''c'')
| |
| '''if''' ''reject''(''P'',''c'') '''then''' '''return'''
| |
| '''if''' ''accept''(''P'',''c'') '''then''' ''output''(''P'',''c'')
| |
| ''s'' ← ''first''(''P'',''c'')
| |
| '''while''' ''s'' ≠ Λ '''do'''
| |
| ''bt''(''s'')
| |
| ''s'' ← ''next''(''P'',''s'')
| |
| | |
| ===Usage considerations===
| |
| The ''reject'' procedure should be a [[boolean-valued function]] that returns ''true'' only if it is certain that no possible extension of ''c'' is a valid solution for ''P''. If the procedure cannot reach a definite conclusion, it should return ''false''. An incorrect ''true'' result may cause the ''bt'' procedure to miss some valid solutions. The procedure may assume that ''reject''(''P'',''t'') returned ''false'' for every ancestor ''t'' of ''c'' in the search tree.
| |
| | |
| On the other hand, the efficiency of the backtracking algorithm depends on ''reject'' returning ''true'' for candidates that are as close to the root as possible. If ''reject'' always returns ''false'', the algorithm will still find all solutions, but it will be equivalent to a brute-force search.
| |
| | |
| The ''accept'' procedure should return ''true'' if ''c'' is a complete and valid solution for the problem instance ''P'', and ''false'' otherwise. It may assume that the partial candidate ''c'' and all its ancestors in the tree have passed the ''reject'' test.
| |
| | |
| Note that the general pseudo-code above does not assume that the valid solutions are always leaves of the potential search tree. In other words, it admits the possibility that a valid solution for ''P'' can be further extended to yield other valid solutions.
| |
| | |
| The ''first'' and ''next'' procedures are used by the backtracking algorithm to enumerate the children of a node ''c'' of the tree, that is, the candidates that differ from ''c'' by a single extension step. The call ''first''(''P'',''c'') should yield the first child of ''c'', in some order; and the call ''next''(''P'',''s'') should return the next sibling of node ''s'', in that order. Both functions should return a distinctive "null" candidate, denoted here by 'Λ', if the requested child does not exist.
| |
| | |
| Together, the ''root'', ''first'', and ''next'' functions define the set of partial candidates and the potential search tree. They should be chosen so that every solution of ''P'' occurs somewhere in the tree, and no partial candidate occurs more than once. Moreover, they should admit an efficient and effective ''reject'' predicate.
| |
| | |
| ===Early stopping variants===
| |
| The pseudo-code above will call ''output'' for all candidates that are a solution to the given instance ''P''. The algorithm is easily modified to stop after finding the first solution, or a specified number of solutions; or after testing a specified number of partial candidates, or after spending a given amount of [[central processing unit|CPU]] time.
| |
| | |
| ==Examples==
| |
| [[File:Sudoku solved by bactracking.gif|thumb|Sudoku puzzle solved by backtracking.]]
| |
| | |
| Typical examples are
| |
| * [[Puzzle]]s such as [[eight queens puzzle]], [[crosswords]], [[verbal arithmetic]], [[Algorithmics of sudoku|Sudoku]], [[Peg_solitaire|Peg Solitaire]].
| |
| * [[Combinatorial optimization]] problems such as [[parsing]] and the [[knapsack problem]].
| |
| * [[Logic programming]] languages such as [[Icon programming language|Icon]], [[Planner programming language|Planner]] and [[Prolog]], which use backtracking internally to generate answers.
| |
| * Backtracking is also utilized in the "[[diff]]" ([[Revision control|version comparing]]) engine for the [[MediaWiki]] software.
| |
| * Parsing
| |
| * [[Knapsack problem]]
| |
| | |
| Below is an example for the [[constraint satisfaction problem]]:
| |
| | |
| ===Constraint satisfaction===
| |
| The general [[constraint satisfaction problem]] consists in finding a list of integers ''x'' = (''x''[1],''x''[2], ..., ''x''[''n'']), each in some range {1, 2, ..., ''m''}, that satisfies some arbitrary constraint (boolean function) ''F''.
| |
| | |
| For this class of problems, the instance data ''P'' would be the integers ''m'' and ''n'', and the predicate ''F''. In a typical backtracking solution to this problem, one could define a partial candidate as a list of integers ''c'' = (''c''[1],''c''[2], ... ''c''[k]), for any ''k'' between 0 and ''n'', that are to be assigned to the first ''k'' variables ''x''[1],''x''[2], ..., ''x''[''k'']). The root candidate would then be the empty list (). The ''first'' and ''next'' procedures would then be
| |
| '''function''' ''first''(''P'',''c'')
| |
| ''k'' ← '''length'''(''c'')
| |
| '''if''' ''k'' = ''n''
| |
| '''then''' '''return''' Λ
| |
| '''else''' '''return''' (''c''[1], ''c''[2], ..., ''c''[''k''], 1)
| |
| | |
| '''function''' ''next''(''P'',''s'')
| |
| ''k'' ← '''length'''(''s'')
| |
| '''if''' ''s''[''k''] = ''m''
| |
| '''then''' '''return''' Λ
| |
| '''else''' '''return''' (''s''[1], ''s''[2], ..., ''s''[''k''-1], 1 + ''s''[''k''])
| |
| Here "'''length'''(''c'')" is the number of elements in the list ''c''.
| |
| | |
| The call ''reject''(''P'',''c'') should return ''true'' if the constraint ''F'' cannot be satisfied by any list of ''n'' integers that begins with the ''k'' elements of ''c''. For backtracking to be effective, there must be a way to detect this situation, at least for some candidates ''c'', without enumerating all those ''m''<sup>''n''-''k''</sup> ''n''-tuples.
| |
| | |
| For example, if ''F'' is the [[Logical conjunction|conjunction]] of several boolean predicates, ''F'' = ''F''[1] <math>\wedge</math> ''F''[2] <math>\wedge</math> <math>\cdots</math> <math>\wedge</math> ''F''[p], and each ''F''[i] depends only on a small subset of the variables ''x''[1], ..., ''x''[''n''], then the ''reject'' procedure could simply check the terms ''F''[i] that depend only on variables ''x''[1], ..., ''x''[''k''], and return ''true'' if any of those terms returns ''false''. In fact, ''reject'' needs only check those terms that do depend on ''x''[''k''], since the terms that depend only on ''x''[1], ..., ''x''[''k''-1] will have been tested further up in the search tree.
| |
| | |
| Assuming that ''reject'' is implemented as above, then ''accept''(''P'',''c'') needs only check whether ''c'' is complete, that is, whether it has ''n'' elements.
| |
| | |
| It is generally better to order the list of variables so that it begins with the most critical ones (i.e. the ones with fewest value options, or which have a greater impact on subsequent choices).
| |
| | |
| One could also allow the ''next'' function to choose which variable should be assigned when extending a partial candidate, based on the values of the variables already assigned by it. Further improvements can be obtained by the technique of [[constraint propagation]].
| |
| | |
| In addition to retaining minimal recovery values used in backing up, backtracking implementations commonly keep a [[variable trail]], to record value change history. An efficient implementation will avoid creating a variable trail entry between two successive changes when there is no choice point, as the backtracking will erase all of the changes as a single operation.
| |
| | |
| An alternative to the variable trail is to keep a [[timestamp]] of when the last change was made to the variable. The timestamp is compared to the timestamp of a choice point. If the choice point has an associated time later than that of the variable, it is unnecessary to revert the variable when the choice point is backtracked, as it was changed before the choice point occurred.
| |
| | |
| ==See also==
| |
| *[[Ariadne's thread (logic)]]
| |
| *[[Backjumping]]
| |
| *[[Recursion (computer science)]]
| |
| | |
| ==Notes==
| |
| {{Reflist}}
| |
| | |
| ==References==
| |
| {{Refbegin}}
| |
| * {{cite book
| |
| | author = Gilles Brassard, Paul Bratley
| |
| | title = Fundamentals of Algorithmics
| |
| | publisher = Prentice-Hall
| |
| | year = 1995
| |
| }}
| |
| {{Refend}}
| |
| | |
| ==External links==
| |
| *[http://www.hbmeyer.de/backtrack/backtren.htm HBmeyer.de], Interactive animation of a backtracking algorithm
| |
| *[http://www.drdobbs.com/cpp/solving-combinatorial-problems-with-stl/184401194 Solving Combinatorial Problems with STL and Backtracking], Article and C++ source code for a generic implementation of backtracking
| |
| *[http://github.com/kapild/Permutations Sample Java Code], Sample code for backtracking of 8 Queens problem.
| |
| | |
| [[Category:Operations research]]
| |
| [[Category:Search algorithms]]
| |
| [[Category:Pattern matching]]
| |
There is in fact a way about this and that would engage the rummage around for a cheap web hosting corporation that is able to supply your business with what it actually desires. The subsequent desktop software, which is a fragment more exclusive nevertheless way more commanding is the admired SeNukeX. When you begin blogging, you must look at the focus of your blog - this is often called a niche. These days, with the focus turning toward other paradigms, I recommend to new authors to take these steps toward building a readership and a successful writing. Control Panel Deluxe as offered inside the Hostgator BabyCroc account has something to be said for itself. Believe it or not, you may be searching for Hostgator tutorials soon enough. This usually means employing wind and solar powered energy sources. You will be able to produce tons of websites under your own brand name, with your own packages , features and prices. Most recently the Host Gator went green to support the environment. In the end, a little bit of time spent researching the market will definitely help you a lot in ensuring that you're getting the best deal that's available out there - especially when you're on a tight budget.
With a WordPress site by means of your HostGator cPanel as they'd say, this would be yours and nobody can stir it.HostGator is really affordable, at less than a sheer $50 you can get yourself one whole year's blog hosting which you might handle as you like. Next we have your own business. HostGator techs after some conversation with a very large accounts support the fact that they not only escape was adamant about, but if I had to manage all of the backup process, etc., myself, that I really was asking for a problem that would set me back years in the business since the sites were responsible for my income. What's great about HostGator, which will most definitely be included in any HostGator review, is the fact that the expertise they use is simple. However with the variety of decisions accessible, it is often tough to determine which one to utilize. Are you going to use the first coupon you can find or are you willing to search high and low for the best? HostGator is one of the most popular web hosting companies and it has received a lot of positive feedback from their clients from over 200 countries internationally. While getting a domain name is less demanding, sometimes choosing the correct hosting provider can be a little more complicated.