EE266 Homework 8 Solutions

Transcription

1 EE266, Spring Professor S. Lall EE266 Homework 8 Solutions 1. Dijkstra s Algorithm. In this problem, you will write an implementation of Dijkstra s algorithm, and use it to find the shortest path in a social network. Consider a weighted, directed graph with vertex set V = {1,..., n}, and edge set E. We can describe such a graph using a matrix W R n n, where W ij is the weight of the edge (i, j) if the graph contains the edge (i, j), and W ij = 0 otherwise (we assume that there are no zero-weight edges). (a) A key step in Dijkstra s algorithm is computing the neighbors of a vertex x: N (x) = {y (x, y) E}. Implement the following MATLAB function. [Nx, WNx] = get_neighbors(x,w) % x : a vertex % W : the matrix of edges weights (0 if there is no edge) % Nx : cell array containing the neighbors of x % WNx : vector containing the weights % of edges between x and its neighbors Report the output of get_neighbors(246,w) for the matrix W defined in facebook_data.m. The function get_neighbors is called a successor oracle. (b) Implement the version of Dijkstra s algorithm given on page 23 of the Shortest Paths lecture. Use the following function header. [dist, path] = dijkstra(neighbors, s, t) % neighbors : function handle [Nx,WNx] = neighbors(x) % where Nx is a cell array of the neighbors of x % and WNx is a vector of weights % s : the source vertex % t : the destination vertex % dist : the distance from s to t % path : cell array containing a shortest path from s to t % path{i} is the i-th vertex of the path (c) The file facebook_data.m define a matrix W that describes part of the Facebook social network. Report the shortest path between nodes s = 800 and t = Choose five random source/destination pairs, and compute the distance from each source to the corresponding destination. Report the maximum distance among the five pairs. 1

2 Implementation hints. You need to figure out how to store the sets F and E, and the value function v. Since MATLAB does not offer data structures such as priority queues and hashtables, you need to use arrays. This is not the most efficient approach, and is not something you would do in most programming languages. However, it is the best solution we have found in MATLAB. In order to recover the optimal path, you need to keep track of the index P(i) that was last used to update the distance v(i). You can use P(i) (which is called the predecessor of i), to trace the optimal path backwards from the target to the source. However, note that your algorithm should output the vertices in a path from s to t. Note that the get_neighbors function you wrote in (a) is slightly different from the neighbors function that you must pass to dijkstra. You can address this discrepancy using an anonymous function. If you have a function f(x, y), you can define a function g(x) = f(x, y 0 ) for some fixed value of y 0 using the expression g f(x,y0). The right side of this expression is called an anonymous function because it is not defined in a named function file. When searching for the state in F with minimum distance, break ties by always selecting the state that was inserted last in the frontier. This will reduce the number of states extracted from F before a solution is found. Solution: (a) The neighbors of 246 are: [1] [9] [24] [92] [260] and all the edges have unit cost. (b) The part of the implementation that was left to figure out is how to store and index the frontier F, closed set E and value function v. Our approach is to keep a cell array ID such that ID{i} contains the i-th state that was inserted in the frontier F for the first time. Then, we use this index i to refer to the actual state ID{i}. This allows us to store F,E,v as simple arrays. The only overhead induced is that, when we explore the neighbors of a state, we need for each neighboring state y to search the whole cell array ID to either find the index j that was assigned to the state ID{j}=y, or assign a new index by expanding the cell array. Another valid approach is to use functions sub2ind, ind2sub to encode an n- dimensional vector of integers in a single integer (index) that will be used to represent the state internally. This simplifies the implementation a bit, since one only has to deal with indices and arrays and not cell arrays. Nevertheless, such an implementation has its own problems. For instance, if one adds a large number to every element of the state, then using an internal representation (indexing the array v) through sub2ind, might not be possible. (c) The length of the shortest path between nodes 800 and 3000 is 5 and is given by: [800] [687] [699] [861] [1685] [3000] 2

3 The maximum value that we observed was 6. Aside. In general, it is a well established fact, both theoretically and experimentally, that most real world networks have a diameter (maximum distance between vertices) that scales logarithmically with the number n of nodes in the network, i.e. diam(n) C log n for some C. For instance take C = 1/3 and n = , then log n 6. The fact that you can connect any two people in the world with a short chain of personal acquaintances is known as the Small World Phenomenon or as Six Degrees of Separation. 2. Navigating a maze. In this problem, you will reproduce and extend the maze example from the lecture slides. You are given a two-dimensional maze (Figure 1) as a matrix A {0, 1} 81 81, where A ij = 1 means that the position (i, j) is free, and A ij = 0 that it is blocked. You are allowed to move horizontally or vertically between adjacent free positions. Figure 1: The maze along with the way-points graph. The cost of moving horizontally is p, and the cost of moving vertically is q. Furthermore, this maze has a special structure in that it is partitioned into smaller mazes by vertical and horizontal lines in positions X=[ ], and Y=[ ] respectively. One can move between smaller mazes only through some way-points, that are marked in blue in Figure 1. The data are available in the maze.dat file. You will use Dijkstra s algorithm to investigate the impact of different heuristics for finding shortest paths in this maze. (a) Implement the function maze_succ that plays the role of the successor oracle for the maze problem. Use the prototype [Nbors,costs]=maze_succ(x,A,h,p,q), where A is an matrix indicating whether locations are free or blocked x is a vector of length 2 given the current position in the maze, p and q are the costs of moving horizontally and vertically, respectively h is a function handle that defines a heuristic. 3

4 Recall that the heuristic function affects the costs through the formula ĝ ij = g ij + h j h i. (b) Uninformed Search. Find the shortest path between s = (1, 19) and t = (81, 61). Report the total cost of the path, the number of states extracted from the frontier F, and the 100-th state along the optimal path, i.e., path{100}, where path{1} is considered to be the source. (c) Manhattan Heuristic. Define the Manhattan heuristic for this problem, and implement it in the function manh(x,t,p,q). Show that it is a consistent heuristic. Report manh(s,t,p,q). (d) A* with Manhattan heuristic. Repeat (b) using the function manh. (e) Finding Close Way-points. Implement the following helper function, which will be useful later in the problem. wpind = waypts(x,x,y,w) % x : the current location % X : locations of the horizontal lines % Y : locations of the vertical lines % W : a matrix with two columns; % each row is the location of a waypoint % wpind : the indices of waypoints that can be accessed from x % without going through any other waypoints For states that are way-points. your function should simply return the index of the way-point. Report waypts(s,x,y,w). (f) Waypoint Distance heuristic. Implement the following helper function. hx = heurmap(x,t,x,y,w,d) % x : the current state % t : the target state % X : the locations of the horizontal lines % Y : the locations of the vertical lines % W : the locations of the waypoints % D : a matrix of estimates of the distances between way-points % hx : an estimate of the distance from x to t (see below) The function should output the following number: { } manh(x, W(i,:)) + D(i, j) + manh(w(j,:), t), h D (x) = min for i waypts(x), j waypts(t) when waypts(x) waypts(t) and h D (x) = manh(x,t) 4

5 when the sets of way-points of the states x,t are identical (x is near the goal). (g) Way-point Manhattan Distance. There is a graph associated with the way-points (also shown in blue in Figure 1). The data file defines the matrix W, which gives the locations of the way-points, and the adjacency matrix G of the graph associated with the way-points. Use this information to compute the weighted adjacency matrix Gw of the way-points graph, where we take the Manhattan distance between two way-points to be the weight of an edge. We have provided the following function for your convenience. D = allpairssp(a) % A : weighted adjacency matrix % D : matrix of distances between vertices of A Use this function to compute Dmanh = allpairssp(gw). (h) A* with way-point Manhattan heuristic. Repeat (b) using the heuristic heurmap with the matrix Dmanh of estimated distances. (i) A* with actual way-point Distance. Construct the matrix of actual distances between waypoints Dtrue by running dijkstra for each adjacent pair of way-points. Report Dtrue and repeat steps (g) and (h) using Dtrue. Remark. The function showpath.m can be used to plot a path given in a cell array. Solution: (b) The total cost of the path found is 652 using 218 edges. The number of states extracted from the frontier were The 100-th state along the optimal path is [55 36]. Figure 2: Uninformed search and solution found by Dijkstra. 5

6 (c) The Manhattan heuristic is given by: h(x) = p x 1 t 1 + q x 2 t 2 To prove consistency consider without loss of generality a horizontal edge with cost p between states x and y = x ± e 1, where e 1 = (1, 0). We have: g xy + h(y) = p + p y 1 t 1 + q y 2 t 2 = p + p x 1 ± 1 t 1 + q x 2 t 2 p p + p x 1 t 1 + q x 2 t 2 = h(x) The same proof can be applied for vertical edges and thus we get that our heuristic is consistent. The value of manh(s,t,p,q) is 404. (d) The total cost of the path found is 652 using 218 edges. The number of states extracted from the frontier were The 100-th state along the optimal path is [55 36]. Figure 3: Informed search by Manhattan heuristic and solution found by A*. (e) One way to implement the function waypts is to first use the positions of the separators X,Y to find the sub-maze where the state x belongs and then find the way-points on or inside the boundary of the sub-maze by using the information in W. The way-points for the starting state are: [1 4] (h) (i) The total cost of the path found is 652 using 218 edges. The number of states extracted from the frontier were The 100-th state along the optimal path is [55 36]. The total cost of the path found is 652 using 218 edges. The number of states extracted from the frontier were The 100-th state along the optimal path is [55 36]. The first 14 columns of the matrix Dtrue are: 6

7 Figure 4: Informed search by Way-point Manhattan heuristic and solution found by A*. Figure 5: Informed search by Way-point Distance heuristic and solution found by A*. 7

8 3. Convoy on a graph. You are a rich merchant, and you want to move some valuable cargo from city s to city t. Unfortunately, the road is full of bands of thieves aiming to steal your cargo. Your network of informants has given you an accurate map of the routes between different cities, and the number of bandits along each road. You can hire mercenaries to guard you on your journey You know that if the number of bandits along any road in your itinerary is at most half the number of mercenaries guarding your cargo, then you will not be attacked. Once you hire the mercenaries, you also need to plan your route. Each mercenary you hire costs 10 gold coins, and you want to find the minimum number of coins you need to spend in order to safely transport your cargo. (a) Explain how to modify Dijkstra s algorithm to solve this problem. (b) The file convoy.mat defines an instance of this problem. Report the minimum number of coins that you need to spend to hire mercenaries, and a corresponding path from s = 1 to t = 23. Solution: (a) Our goal is to find the minimum number of coins that we will have to spend. This amount is: ( ) C = 2 10 min max w ij p P (s,t) (i,j) p where P (s, t) is the set of paths going from s to t, p P (s, t) is a simple path from s to t and w ij is the estimated number of thieves being active between cities i and j. We are going to modify Dijkstra s algorithm to calculate the quantity in the parenthesis. Define the cost c(p) of a path p as: and the distance of two vertices as: c(p) = max (i,j) p w ij d(x, y) = min c(p) p P (x,y) Our problem essentially boils down to finding d(s, t). This notion of distance satisfies the ultrametric inequality (stricter than triangular): d(x, y) max{d(x, z), w zy }, z : y N(z) as well as the following principle of optimality: d(x, y) = min z:y N(z) max{d(x, z), w zy} where N(z) is the set of neighbors of z. Thus, when expanding the neighbors of node i, just extracted from the frontier, we can perform label relaxation in Dijkstra by using the following update: v(j) = min {v(j), max{v(i), w ij }}, j N(i) 8

9 Figure 6: Goal state of the 8-Tile puzzle. starting again from F = {s} and v(s) = 0. That is, instead of performing the check v(i) + w ij < v(j), we check whether max{v(i), w ij } < v(j) and if so we set v(j) max{v(i), w ij }. (b) We will have to spend C = 520 coins and follow the route: [1] [5] [10] [13] [20] [23] 4. The 8-tile puzzle. The 8-tile puzzle is a sliding puzzle in which 8 tiles, labeled 1,..., 8, are placed in a 3 3 box. Note that there is always one empty space in the puzzle. The rules are that you can change the the configuration of the puzzle by sliding any tile adjacent to the empty space into the empty space. The goal is to reach the configuration shown in Figure 2. In this problem, you will solve the 8-tile puzzle using Dijkstra algorithm and heuristics. (a) We can think of the 8-tile puzzle in terms of a graph. Let each configuration of the puzzle be a vertex, and let there be an edge between two vertices if the corresponding configurations can be reached from one another in one move. We assume that each edge has weight one. Given a starting configuration s, we can we can solve the 8-tile puzzle by finding a shortest path from s to the configuration t shown in Figure 2. Give a consistent heuristic h for this problem, and prove that your heuristic is consistent. (b) We can represent a configuration of the puzzle using a vector of length 9; for example, the goal configuration is x = (1, 8, 7, 2, 0, 6, 3, 4, 5). Implement the following function. [Nx, WNx] = tile8_neighbors(x,h) % x : a configuration of the 8-tile puzzle % h : a heuristic % Nx : the neighbors of x (that is, the configurations % that can be reached from x in one move) % WNx : the cost of moving to each neighbor using the heuristic 9

10 (c) Solve the 8-tile puzzle from the starting state s = (7, 8, 1, 5, 4, 0, 3, 2, 6). Report your sequence of moves, as well as the number of states that you extracted from the frontier. Use can use the function solution8tile(path) to animate your solution of the puzzle. This function assumes that path is a cell array, where path{i} is the ith state in the path. Solution: (a) Since, we can move one tile at a time, and we want each tile to be in a particular final position in the goal state, we can relax the problem and assume that we can freely move each tile independently of other tiles. In order to get a tile l from position (x (l) 1, x (l) 2 ) {1, 2, 3} 2 to its final position (t (l) 1, t (l) 2 ), a lower bound for the number of moves required is given by the Manhattan distance for the coordinates. The heuristic function is simply the sum of this quantity for all tiles {1,..., 8}: h(x) = l {1,...,8} x (l) 1 t (l) 1 + x (l) 2 t (l) 2 To prove consistency, consider that to get from state x to sate y = x ± e (l 0) 1 we move a particular tile l 0 (adjacent to the empty space) horizontally. Then we have: g xy + h(y) = 1 + y (l) 1 t (l) 1 + y (l) 2 t (l) 2 l {1,...,8} = 1 + x (l 0) 1 ± 1 t (l 0) 1 + x (l 0) 2 t (l 0) x (l 0) 1 t (l 0) 1 + x (l 0) 2 t (l = h(x) l {1,...,8}\{l 0 } l {1,...,8}\{l 0 } x (l) 1 t (l) 1 + x (l) 2 t (l) 2 x (l) 1 t (l) 1 + x (l) 2 t (l) 2 The same holds also for vertical moves and since tile l 0 was arbitrary it holds also for all tiles. Hence, we have proved consistency of the heuristic. A different consistent heuristic is given by the number of misplaced tiles and one can essentially follow the same line of proof. (c) Using A* with the Manhattan heuristic, we extracted 3802 states from the frontier and found the following sequence of moves: The number of states extracted can differ both depending on the heuristic as well as various implementation details. For instance, you might get different results depending on how you break ties when extracting the state with the minimum distance v(i) from F, or how you choose to store (index) you states. 10