INF 4130 Exercise set 4

Transcription

1 INF 4130 Exercise set 4 Exercise 1 List the order in which we extrct the nodes from the Live Set queue when we do redth first serch of the following grph (tree) with the Live Set implemented s LIFO queue. l c f m r i d g h j n p s u e k o q t v l r u v s t m p q n o i j k f h g c d e Exercise 2 Solve exercise 23.6 from the text ook (B&P). (See the course we pge for scn of the ook.) Note tht it is importnt tht we do not count the empty squre when we sum up wht is in the wrong spot. If we do, we won t e le to show wht we re supposed to. See, for instnce, this 2x2-ord: Here we cn get everything in plce with three moves (U,R,D), ut if we lso count the empty squre we get h(v) = 4. Thus, counting lso the empty squre, the shortest distnce would e smller thn the heuristic, which cn never e true for monotone heuristic. For monotonicity we must show: 1. h(gol) = 0 2. If there is n edge from v to w with cost c(v,w), we must hve: h(v) c(v,w) + h(w). 1. is ovious 1

2 2. For ny simple move (v,w) we know tht c(v,w) =1 (s we simply count the numer of moves long pth). Thus, if h(v) nd h(w) do not differ y more thn 1, the ove inequlity must e true. This is ovious s only one tile is moved. Exercise 3 Solve exercise 23.7 from the text ook. If we understood the point of the previous exercise, this one should lso e esy. Monotonicity: 1. h(gol) = 0 2. If there is n edge from v to w with cost c(v,w), we must hve: h(v) c(v,w) + h(w). 1. is ovious 2. Agin c(v,w) is 1. Thus, if h(v) nd h(w) do not differ y more thn 1, the ove inequlity must e true. This is ovious s only one tile is moved one step. Exercise 4 Solve exercise 23.8 from the text ook. The numers under (some of) the nodes shows the order in which these nodes re tken from the queue to the tree. In the fourth move we hve two nodes with f = 7, ut we ssume FIFO order for nodes with equl priority. In the next step the other node with f = 7 gets expnded further. Exercise 5 Is your nswer regrding monotonicity in 23.7 lso vlid if we llow moving the hole digonlly? 2

3 Monotonicity: h(gol) = 0 If there is n edge from v to w with cost c(v,w), we must hve: h(v) c(v,w) + h(w). The sum of the Mnhttn-distnces will not e monotone heuristic if we llow digonl moves, ecuse it cn get lrger thn the numer of moves necessry. Look t: Here we get solution in one move (DR moving the hole into the squre with 5), ut the Mnhttn-distnce gives us h = 2. It is, however, esy to see tht if squre is in (x1, y1) nd its correct position is (x2, y2), the fewest numer of moves to (x2,y2) (if it is lone on the ord) is: mx( x2-x1, y2-y1 ). We therefore try with the sum (over ll tiles) of this vlue s our heuristic. For this heuristic we hve h(finl stte) = 0. To show monotonicity we gin hve to show tht the h-vlue does not chnge more thn 1 when we mke move. Since only one tile is moved, the question is relly whether mx(,) cn chnge more thn 1 when cn increse or decrese y 1, nd the sme for (t the sme time). It should e cler tht it cnnot (since mx-function is kind of OR). So the modified heuristic is monotone. Exercise 6 Is it possile to use the ctul cost s our heuristic (it is fter ll 100% exct nd should e good)? Will the ctul cost lwys e monotone? Will we expnd smller tree? Wht would the prolem e, if ny? To clrify it, h(s) is now the cost of the moves long n optiml pth from s to gol stte. It is of course it strnge to imgine tht we hve this s our heuristic: If we only wnt the length of the shortest pth, we lredy hve wht we re looking for. However, if we know the length of the shortest pths to the gol, it cn e used to find the pth itself (ut this cn then proly then e done in simpler wy). This exercise cn of course tell us something out the ehviour of A* with very good heuristics. If h is s descried ove, we see tht the vlue f(s) = g(s) + h(s) when stte s is tken out of the priority queue nd plced in the tree, is equl to the shortest pth from the strt stte to finl stte, through s. It should therefore e cler tht the A*-lgorithm will go stright for the est solution nd not wste time on su optiml solutions. Mny sttes my, of course, hve the the sme f-vlue, nd in these cses the lgorithm will follow them in 3

4 prllel, the order will depend on how nodes with equl priority re removed from the priority queue. Another point to oserve is of course tht clculting the heuristics here usully mounts to solving the originlly prolem itself (unless you hve got these distnces from other sources). Exercise 7 Show tht the stright line (ctully the circumference of gret circle, ut let s not get into detils) etween point nd the gol point is monotone heuristic for finding the shortest pth the wy it is done in chpter (pge 728). Monotonicity: h(gol) = 0 If there is n edge from v to w with cost c(v,w), we must hve: h(v) c(v,w) + h(w). Let g e our gol. We first oserve tht we hve h(g) = 0. Now let v nd w e two plces tht there is rod with distnce c(v,w) etween, nd let the stright line etween them e (v,w). We hve to show tht h(v) c(v,w) + h(w). We hve h(v) (v,w) + h(w) y the tringle inequlity, nd since c(v,w) ³ (v,w), we get h(v) (v,w) + h(w) c(v,w) + h(w). It is therefore cler tht the stright line is monotone heuristic. v (v,g) = h(v) c(v,w) (v,w) Gol w (w,g) = h(w) Exercise 8 Assign g-, h- nd f-vlues to the sttes in figure 23.7 (pge 727) nd check tht we ctully void expnding the full redth-first-tree in figure 23.3 (pge 719). Left to the individul student. 4

5 Exercise 9 Adjust the DFS procedure elow to insted do itertive deepening with one extr level t time. You should only check once for ech node whether it is gol node, nd you need n extr prmeter to the procedure DFS. Show how the procedure should e clled from min progrm/procedure for the whole thing to work properly proc DFS(v) { if <v is gol node> then return v.visited = TRUE for <ech neighor w of v> do if not w.visited then DFS(w) od Things get little complicted when we serch in grph (s indicted y the vrile "visited" in the ssignment text). We therefore first ssume tht we serch in tree, so tht we never come to n erlier visited node. The progrm elow only test for gols in the new nodes, nd the outer loop increses the depth of the serch y 10 (inclev). The tree (Stte) nodes hve procedure to test whether it is gol node. clss Stte { <vriles to keep trck of its children in the tree> Bool proc isgol(stte node){ checks whether this node is gol clss IDDFS{ // clss for itertive deepening DFS int inclev = 10; // s n exmple int prevlev = 0; int mxlev = prevlev + inclev; Stte foundgol = null; // Is set when gol is found Stte proc min(stte root){ // Is the root of the tree to e serched repet { IDSerch(root, 1); // The recursive cll for the root. prevlev = mxlev; mxlev = prevlev + inclev; until foundgol!= null; return foundgol; proc IDSerch(Stte node, int lev){ // the recursive procedure if (lev > mxlev) return; if (lev > prevlev){ if (node.isgol) {foundgol = node; return for ech child of node do { IDSerch( child, lev + 1); // End of clss IDDFS We should here lso hve dded vrile holding e.g. the numer itertions we should perform efore we totlly give up serching. The use nd dministrtion of such vrile should e stright-forwrd. Without such mechnism, the progrm will esily enter n infinite loop. 5

6 If we wnt to do serch in grph, we, in the progrm given in the exercise text, is using Boolen vrile visited in ech node to void looking t the sme node twice. However, if we will use iterted deepening (ID) for the grph cse we will hve to set this vrile ck to flse etween the itertions, which will tke lot of time. We will therefore use n interger vrile visitno insted of the Boolen one. We will use this vrile s follows: - At the strt, visitno should e 0 in ll nodes. - We will hve glol (= locl to the clss IDDFS) interger vrile iterno, which holds the numer of the current itertion. This is incremented etween itertions. - We cn then test whether we hve seen this node in this itertion y node.visitno < iterno. - If this is true we should immeditely do node.visitno = iterno to mrk it s seen in this itertion. Note tht this will lso work for nodes tht hve not een seen in the erlier itertions, s they will hve node.visitno == 0 (nd thus the first itertion should hve iterno == 1. We leve the djustment of the ove progrm to ccommodte these ides to the interested student. 6

7 Exercise 10 Study the exmple on slide 20 from Septemer 9 (pge 723 on the textook) to confirm tht when h(v) is not monotone, then nodes sometimes will hve to e tken ck from tree to the priority queue, thus incresing execution time. The evolution of the tree nd the priority queue looks like this: r r c r c r c d d d d 6 :34(11+23), d:35(6+29), :40(20+20) c:33( ),d:35(6+29), :39( ) d:35(6+29), :39( ) :39( ) Drk red indictes vlue hd to e updted. Both (priority in queue) nd c (distnce) now hve incorrect vlues, ecuse of the shorter pth to. 7

8 Exercise 11 Study the A*-lgorithm descried (textully) on slide 26 from the lecture. Is left to the prticipnts in the group, or to self study. [end] 8