**A is an initial node, which is expand to B,C and D. A heuristic function, say cost of reaching the goal , is applied to each of these nodes, since D is most promising, it is expanded next, producing two successor nodes E and F. Heuristic function is applied to them. Now out of the four remaining ( B,C and F) B looks more promising and hence it is expand generating nodes G and H . Again when evaluated E appears to be the next stop J has to be expanded giving rise to nodes I and J. In the next step J has to be expanded, since it is more promising . this process continues until a solution is found.**

**Above figure shows the best - first search tree. Since a search tree may generate duplicate nodes, usually a search graph is preferred.**

**The best - first search is implemented by an algorithm known as A* algorithm. The algorithm searches a directed graph in which each node represents a point in the problem space. Each node will contain a description of the problem state it represents and it will have links to its parent nodes and successor nodes. In addition it will also indicate how best it is for the search process. A* algorithm uses have been generated, heuristic functions applied to them, but successors not generated. The list CLOSED contains nodes which have been examined, i.e., their successors generated.**

**A heuristic function f estimates the merits of each generated node. This function f has two components g and h. the function g gives the cost of getting from the initial state to the current node. The function h is an estimate of the addition cost of getting from current node to a goal state. The function f (=g+h) gives the cost of getting from the initial state to a goal state via the current node.**

**THE A* ALGORITHM:-**

**1. Start with OPEN containing the initial node. Its g=0 and f ' = h '**

**Set CLOSED to empty list.**

**2. Repeat**

**If OPEN is empty , stop and return failure**

**Else pick the BESTNODE on OPEN with lowest f ' value and place it on CLOSED**

**If BESTNODE is goal state return success and stop**

**Else**

**Generate the successors of BESTNODE.**

**For each SUCCESSOR do the following:**

**1. Set SUCCESSOR to point back to BESTNODE. (back links will help to**

**recover the path)**

**2. compute g(SUCCESSOR) = g(BESTNODE) cost of getting from BESTNODE to SUCCESSOR.**

**3. If SUCCESSOR is the same as any node on OPEN, call that node OLS and add OLD to BESTNODE 's successors. Check g(OLD) and g(SUCCESSOR). It g(SUCCESSOR) is cheaper then reset OLD 's parent link to point to BESTNODE. Update g(OLD) and f '(OLD).**

**4. If SUCCESSOR was not on OPEN , see if it is on CLOSED . if so call the node CLOSED OLD , and better as earlier and set the parent link and g and f ' values appropriately.**

**5. If SUCCESSOR was not already on earlier OPEN or CLOSED, then put it on OPEN and add it to the list of BESTNODE 's successors.**

**Compute f ' (SUCCESSOR) = g(SUCCESSOR) + h ' (SUCCESSOR)**

**Best first searches will always find good paths to a goal after exploring the entire state space. All that is required is that a good measure of goal distance be used.**

This is nice blog. contents over here are so informative. For more on this topic, visit here. A* Search : A Better Best-First Strategy

ReplyDelete