In this puzzle solution of 8 puzzle problem is discussed. 1. DFS (Brute-Force)<\/strong> state space tree for 8 puzzle<\/p>\n <\/p>\n In this solution, successive moves can take us away from the goal rather than bringing closer. The search of state space tree follows leftmost path from the root regardless of initial state. An answer node may never be found in this approach.<\/p>\n[ad type=”banner”]\n 2. BFS (Brute-Force)<\/strong> 3. Branch and Bound<\/strong> There are basically three types of nodes involved in Branch and Bound Cost function: Ideal Cost function for 8-puzzle Algorithm : <\/strong> An algorithm is available for getting an approximation of h(x) which is a unknown value.<\/p>\n Complete Algorithm:<\/strong><\/p>\n Below diagram shows the path followed by above algorithm to reach final configuration from given initial configuration of 8-Puzzle. Note that only nodes having least value of cost function are expanded.<\/p>\n
\nGiven a 3\u00d73 board with 8 tiles (every tile has one number from 1 to 8) and one empty space. The objective is to place the numbers on tiles to match final configuration using the empty space. We can slide four adjacent (left, right, above and below) tiles into the empty space.
\n<\/em>
\nFor example,<\/p>\n![\"Branch](\"https:\/\/www.wikitechy.com\/technology\/wp-content\/uploads\/2017\/06\/8puzzle2-300x119.png\")
<\/p>\n
\nWe can perform depth-first search on state space (Set of all configurations of a given problem i.e. all states that can be reached from initial state) tree.<\/p>\n![\"Branch](\"https:\/\/www.wikitechy.com\/technology\/wp-content\/uploads\/2017\/06\/image6.png\")
<\/p>\n
\nWe can perform a Breadth-first search on state space tree. This always finds a goal state nearest to the root. But no matter what the initial state is, the algorithm attempts the same sequence of moves like DFS.<\/p>\n
\nThe search for an answer node can often be speeded by using an \u201cintelligent\u201d ranking function, also called an approximate cost function to avoid searching in sub-trees that do not contain an answer node. It is similar to backtracking technique but uses BFS-like search.<\/p>\n
\n1. Live node<\/strong> is a node that has been generated but whose children have not yet been generated.
\n2. E-node<\/strong> is a live node whose children are currently being explored. In other words, an E-node is a node currently being expanded.
\n3. Dead node <\/strong>is a generated node that is not to be expanded or explored any further. All children of a dead node have already been expanded.<\/p>\n
\nEach node X in the search tree is associated with a cost. The cost function is useful for determining the next E-node. The next E-node is the one with least cost. The cost function is defined as,<\/p>\n C(X) = g(X) + h(X) where\r\n g(X) = cost of reaching the current node \r\n from the root\r\n h(X) = cost of reaching an answer node from X.<\/pre>\n[ad type=”banner”]\n
\nWe assume that moving one tile in any direction will have 1 unit cost. Keeping that in mind, we define cost function for 8-puzzle algorithm as below :<\/p>\n c(x) = f(x) + h(x) where\r\n f(x) is the length of the path from root to x \r\n (the number of moves so far) and\r\n h(x) is the number of non-blank tiles not in \r\n their goal position (the number of mis-\r\n -placed tiles). There are at least h(x) \r\n moves to transform state x to a goal state<\/pre>\n
\/* Algorithm LCSearch uses c(x) to find an answer node\r\n * LCSearch uses Least() and Add() to maintain the list \r\n of live nodes\r\n * Least() finds a live node with least c(x), deletes\r\n it from the list and returns it\r\n * Add(x) adds x to the list of live nodes\r\n * Implement list of live nodes as a min heap *\/\r\n\r\nstruct list_node\r\n{\r\n list_node *next;\r\n\r\n \/\/ Helps in tracing path when answer is found\r\n list_node *parent; \r\n float cost;\r\n} \r\n\r\nalgorithm LCSearch(list_node *t)\r\n{\r\n \/\/ Search t for an answer node\r\n \/\/ Input: Root node of tree t\r\n \/\/ Output: Path from answer node to root\r\n if (*t is an answer node)\r\n {\r\n print(*t);\r\n return;\r\n }\r\n \r\n E = t; \/\/ E-node\r\n\r\n Initialize the list of live nodes to be empty;\r\n while (true)\r\n {\r\n for each child x of E\r\n {\r\n if x is an answer node\r\n {\r\n print the path from x to t;\r\n return;\r\n }\r\n Add (x); \/\/ Add x to list of live nodes;\r\n x->parent = E; \/\/ Pointer for path to root\r\n }\r\n\r\n if there are no more live nodes\r\n {\r\n print (\"No answer node\");\r\n return;\r\n }\r\n \r\n \/\/ Find a live node with least estimated cost\r\n E = Least(); \r\n\r\n \/\/ The found node is deleted from the list of \r\n \/\/ live nodes\r\n }\r\n}\r\n<\/pre>\n![\"Branch](\"https:\/\/www.wikitechy.com\/technology\/wp-content\/uploads\/2017\/06\/15-Puzzle.png\")
<\/p>\n