Agenda. Graph Representation DFS BFS Dijkstra A* Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp

Size: px

Start display at page:

Download "Agenda. Graph Representation DFS BFS Dijkstra A* Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp"

Camron Barton
6 years ago
Views:

1 Graph Charles Lin

2 genda Graph Representation FS BFS ijkstra * Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp

3 Graph Representation djacency Matrix bool way[100][100]; cin >> i >> j; way[i][j] = true;

4 Graph Representation djacency Linked List vector<int> v[100]; cin >> i >> j; v[i].push_back(j);

5 Graph Representation Edge List struct Edge { int Start_Vertex, End_Vertex; } edge[10000]; cin >> edge[i].start_vertex >> edge[i].end_vertex;

6 Graph Representation

7 Graph Theory 10 B C E

8 Graph Theory Mission: To go from Point to Point E How?

9 epth First Search (FS) Structure to use: Stack

10 epth First Search (FS) 10 B C E

11 epth First Search (FS) 10 B C E

12 epth First Search (FS) 10 B C E

13 epth First Search (FS) 10 B C E

14 epth First Search (FS) 10 B C E

15 epth First Search (FS) 10 B B is visited already 3 C E

16 epth First Search (FS) 10 B C E

17 epth First Search (FS) 10 B C E

18 epth First Search (FS) 10 B C E

19 epth First Search (FS) 10 B C E

20 epth First Search (FS) 10 B C E We find a path from Point to Point E, but

21 epth First Search (FS) stack<int> s; bool Visited[MX]; void FS(int u) { } s.push(u); if (u == GOL) { } for (int x = 0; x < s.size(); x++) return ; printf( %d, s[x]); for (int x = 0; x < MX; x++) if (!Visited[x]) { } s.pop(); Visited[x] = true; FS(x); Visited[x] = false; int main() { memset(visited, 0, sizeof(visited)); // Input Handling (GOL =?) FS(0); } Very Important It needs to be restored for other points to traverse, or the path may not be found

22 epth First Search (FS) Usage: Finding a path from start to destination (NOT RECOMMENE TLE) Topological Sort (T-Sort) Strongly-Connected Components (SCC) etect cycles

23 epth First Search (FS) Topological Sort irected cyclic Graph (G) Find the order of nodes such that for each node, every parent is before that node on the list umb method: Check for root of residual graph (o it n times) Better Method: Reverse of finishing time Start from all vertices!

24 epth First Search (FS) T-Sort: 10 B C E Cycle Exists!!!

25 epth First Search (FS) T-Sort: B C E OK

26 epth First Search (FS) T-Sort: B C E Things in output stack: NONE

27 epth First Search (FS) T-Sort: B C E Things in output stack: NONE

28 epth First Search (FS) T-Sort: B C E Things in output stack: NONE

29 epth First Search (FS) T-Sort: B C E Things in output stack: NONE

30 epth First Search (FS) T-Sort: B C E Things in output stack: E

31 epth First Search (FS) T-Sort: B C E Things in output stack: E,

32 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B

33 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B

34 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B

35 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B

36 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B

37 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B, C

38 epth First Search (FS) T-Sort: B C E Things in output stack: E,, B, C, T-Sort Output:, C, B,, E

39 epth First Search (FS) Strongly Connected Components irected Graph Find groups of nodes such that in each group, every node has a path to every other node

40 epth First Search (FS) Strongly Connected Components Method: FS twice (Kosaraju) o FS on graph G from all vertices, record finishing time of node Reverse direction of edges o FS on Graph G from all vertices sorted by decreasing finishing time Each FS tree is an SCC

41 epth First Search (FS) Strongly Connected Components Note: fter grouping the vertices, the new nodes form a irected cyclic Graph

42 Breadth First Search (BFS) Structure to use: Queue

43 10 B Breadth First Search (BFS) Things in queue:, C 3, B C E

44 10 B Breadth First Search (BFS) Things in queue:, B 10, C, E 5, C, B 7, C, C E

45 10 B Breadth First Search (BFS) Things in queue:, C, E 5, C, B 7, C, 8, B, C 11, B, C E

46 10 B Breadth First Search (BFS) Things in queue:, C, B 7, C, 8, B, C 11, B, C E We are done!!!

47 Breadth First Search (BFS) pplication: Finding shortest path Flood-Fill

48 ijkstra Structure to use: Priority Queue Consider the past The length of path visited so far No negative edges allowed Maintain known vertices t each step: Take the unknown vertex with smallest overall estimate

49 10 ijkstra B Things in priority queue:, C 3, B Current Route: 3 C E

50 10 ijkstra B Things in priority queue:, C, E 5, C, B 7, B 10, C, Current Route:, C 3 C E

51 10 ijkstra B Things in priority queue:, C, B 7, B 10, C, Current Route:, C, E 3 C E We find the shortest path already!!!

52 * Search Structure to use: Priority Queue Consider the past + future How to consider the future? dmissible Heuristic (Best-Case Prediction: must never overestimate) How to predict?

53 * Search Prediction 1: isplacement Given coordinates, calculate the displacement of current node to destination sqrt((x x1) + (y y1) ) Prediction : Manhattan istance Given grid, calculate the horizontal and vertical movement (x x1) + (y y1)

54 * Search est Start - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

55 * Search est = 6 Start (0 + 6 = 6) = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

56 * Search est + 4 = = 6 Start (0 + 6 = 6) = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

57 * Search = 6 est + 4 = = 6 Start (0 + 6 = 6) = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

58 * Search = = = 6 est + 4 = = 6 Start (0 + 6 = 6) = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

59 * Search = = = = 6 est + 4 = = 6 Start (0 + 6 = 6) = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

60 * Search = = = = 6 est + 4 = = 6 Start (0 + 6 = 6) = = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

61 * Search = = = = 6 est + 4 = = = 6 Start (0 + 6 = 6) = = = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

62 * Search = = = = 6 est + 4 = = = 6 Start (0 + 6 = 6) = = = 6 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

63 * Search = = = = 6 est + 4 = = = 6 Start (0 + 6 = 6) = = = = 8 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

64 * Search = = = = = 6 est + 4 = = = 6 Start (0 + 6 = 6) = = = = 8 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

65 * Search = = = = = = 6 est + 4 = = = 6 Start (0 + 6 = 6) = = = = 8 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

66 * Search = = = = = = = 6 est (8 + 0 = 8) + 4 = = = 6 Start (0 + 6 = 6) = = = = 8 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

67 * Search = = = = = = = 6 est (8 + 0 = 8) + 4 = = = 6 Start (0 + 6 = 6) = = = = 8 - Manhattan istance is used - If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, own, Left, Right order

68 * Search * Search = Past + Future * Search Future =? ijkstra * Search Past =? Greedy

69 Graph Theory How about graph with negative edges? Bellman-Ford

70 Bellman-Ford lgorithm Consider the source as weight 0, others as infinity Count = 0, Improve = true While (Count < n and Improve) { Improve = false Count++ For each edge uv If u.weight + uv distance < v.weight { } Improve = true v.weight = u.weight + uv.distance } If (Count == n) print Negative weight cycle detected Else print shortest path distance

71 Bellman-Ford lgorithm Time Compleity: O(VE)

72 Graph Theory ll we have just dealt with is single source How about multiple sources (all sources)? Floyd-Warshall lgorithm

73 Floyd-Warshall lgorithm 1. Compute on subgraph {1}. Compute on subgraph {1,} 3. Compute on subgraph {1,..., 3} N. Compute on entire graph one!

74 Floyd-Warshall lgorithm For (int k = 0; k < MX; k++) { For (int i = 0; i < MX; i++) { For (int j = 0; j < MX; j++) { Path[i][j] = min(path[i][j], Path[i][k] + Path[k][j]); } } }

75 Iterative? Non-iterative? What is iterative-deepening? Given limited time, f nd the current most optimal solution ijkstra (Shortest 1-step Solution) ijkstra (Shortest -steps Solution) ijkstra (Shortest 3-steps Solution) ijkstra (Shortest n-steps Solution) Suitable in bi-directional search (Faster than 1-way search): only for FS, tricky otherwise

76 s t

77 s t

78 Minimum Spanning Tree (MST) Given an undirected graph, find the minimum cost so that every node has path to other nodes Kruskal s lgorithm Prim s lgorithm

79 Kruskal s lgorithm Continue Finding Shortest Edge If no cycle is formed add it into the list Construct a parent-child relationship If all nodes have the same root, we are done (path compression) General idea: union-find, may be useful in other situations

80 Kruskal s lgorithm 4 B C 10 E Node B C E Parent B C E

81 Kruskal s lgorithm Edge List: BC 1 4 B C 10 E Node B C E Parent B B E

82 Kruskal s lgorithm Edge List: BC 1 4 B C 10 E Node B C E Parent B B B E

83 Kruskal s lgorithm Edge List: BC 1 4 B C 10 E Node B C E Parent E

84 Cycle formed 4 B Kruskal s lgorithm Edge List: BC C 10 E Node B C E Parent E

85 Kruskal s lgorithm Edge List: BC 1 4 B C 10 E Node B C E Parent E

86 Cycle formed 4 B Kruskal s lgorithm Edge List: BC C 10 E Node B C E Parent E

87 Kruskal s lgorithm Edge List: BC 1 4 B C 10 E Node B C E Parent

88 Kruskal s lgorithm Path Compression can be done when we find root int find_root(int x) { return (parent[x] == x)? x: return (parent[x] = find_root(parent[x])); }

89 Prim s lgorithm While not all nodes are visited While the list is not empty and the minimum edge connects to visited node Pop out the edge If the list is empty, print Impossible and return Else Consider popped edge Mark its endpoint as visited dd all its unvisited edges to the list Print the tree

90 4 B Prim s lgorithm Edge List: C 3 B C 10 E

91 4 B Prim s lgorithm Edge List: CB 1 B 4 C 7 CE C 10 E

92 4 B Prim s lgorithm Edge List: B B 4 C 7 CE C 10 E

93 4 B Prim s lgorithm Edge List: B 4 C 7 E 8 CE C 10 E

94 Cycle formed Prim s lgorithm 4 B Edge List: C 7 E 8 CE C 10 E

95 Cycle formed Prim s lgorithm 4 B Edge List: E 8 CE C 10 E

96 Prim s lgorithm Edge List: CE 10 4 B C 10 E We are done

97 irected Minimum Spanning Tree We have just dealt with undirected MST. How about directed? Using Kruskal s or Prim s cannot solve directed MST problem How? Chu-Liu/Edmonds lgorithm

98 Chu-Liu/Edmonds lgorithm For each vertex, find the smallest incoming edge While there is cycle Find an edge entering the cycle with smallest increase Remove the edge pointing to the same node and replace by new edge Print out the tree

99 Chu-Liu/Edmonds lgorithm 10 B C 8 E

100 Chu-Liu/Edmonds lgorithm 10 B C 8 E Cycle formed (B, C, ) => B, C, = 10 = 8 => B, C, = 3 = 1 E => B, C, = 9 4 = 5

101 Chu-Liu/Edmonds lgorithm 10 B C 8 E No cycle formed, we terminate

102 Chu-Liu/Edmonds lgorithm Using this algorithm may unloop a cycle and create another cycle But since the length of tree is increasing, there will have an end eventually Worst Case is doing n-1 times Time Complexity is O(EV)

103 Flow graph with weight (capacity) Mission: Find out the maximum flow from source to destination How?

104 Edmond-Karp o { o BFS on the graph to find maximum flow in the graph dd it to the total flow For each edge in the maximum flow educt the flow just passed } While the flow is not zero;

105 The End

Graph Representation DFS BFS Dijkstra A* Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp

Charles Lin Graph Representation DFS BFS Dijkstra A* Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp Adjacency Matrix bool way[100][100]; cin >> i >> j; way[i][j] = true;