Charles Lin Charles Lin

(1)

Charles Lin

(2)

•• Graph Representation Graph Representation

•• DFS DFS

•• B BFS FS

•• Dijkstra Dijkstra

•• **A* Search A* Search**

•• Bellman Bellman--Ford Ford

•• Floyd Floyd--Warshall Warshall

•• Iterative? Non Iterative? Non--iterative? iterative?

•• MST MST

•• Flow Flow –– Edmond Edmond--Karp Karp

(3)

•• Adjacency Matrix Adjacency Matrix

–– bool bool way[100][100]; way[100][100];

–– cin cin >> i >> j; >> i >> j;

–– way[i][j] = true; way[i][j] = true;

(4)

•• Adjacency Linked List Adjacency Linked List

–– vector< vector<int int> v[100]; > v[100];

–– cin cin >> i >> j; >> i >> j;

–– v[i]. v[i].push_back push_back(j); (j);

(5)

•• Edge List Edge List struct

struct Edge { Edge {

int int Start_Vertex Start_Vertex, , End_Vertex End_Vertex;;

} edge[10000];

cin

cin >> edge[i]. >> edge[i].Start_Vertex Start_Vertex >> >>

edge[i].

edge[i].End_Vertex End_Vertex;;

(6)

(7)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(8)

•• Mission: To go from Point A to Point E Mission: To go from Point A to Point E

•• How? How?

(9)

•• Structure to use: Structure to use: Stack Stack

•• See See “The House of Santa Claus” “The House of Santa Claus”

(10)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(11)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(12)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(13)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(14)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(15)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

B is visited already

(16)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(17)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(18)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(19)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

(20)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

We find a path from Point A to Point E, We find a path from Point A to Point E, but ……

but ……

(21)

stack<int> s;

bool Visited[MAX];

void DFS(int u) { s.push(u);

if (u == GOAL) {

for (int x = 0; x < s.size(); x++) printf(“%d “, s[x]);

return ; }

for (int x = 0; x < MAX; x++) if (!Visited[x]) {

Visited[x] = true;

DFS(x);

Visited[x] = false;

}

s.pop();

}

int main() {

memset(Visited, 0, sizeof(Visited));

// Input Handling (GOAL = ?) DFS(0);

}

Very Important Very Important

It needs to be restored for other It needs to be restored for other points to traverse, or the path points to traverse, or the path may not be found

may not be found

(22)

•• Usage: Usage:

–– Finding a path from start to destination Finding a path from start to destination

(NOT RECOMMENDED (NOT RECOMMENDED –– TLE) TLE) –– Topological Topological Sort (T Sort (T--Sort) Sort)

–– Strongly Strongly--Connected Connected Component (SCC) Component (SCC)

(23)

•• Topological Sort Topological Sort

–– Directed Acyclic Graph (DAG) Directed Acyclic Graph (DAG)

–– Find the order of nodes such that Find the order of nodes such that for each node, for each node, every parent is before that node on the list

every parent is before that node on the list

–– Dump Method: Check for root of residual graph Dump Method: Check for root of residual graph (Do it n times)

(Do it n times)

–– Better Method: Reverse of finishing time Better Method: Reverse of finishing time

(24)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

Cycle Exists !!!

TT--Sort: Sort:

(25)

A

B

C

D

E

OK OK

TT--Sort: Sort:

(26)

A

B

C

D

E

Things in output stack: NONE Things in output stack: NONE

TT--Sort: Sort:

(27)

A

B

C

D

E

Things in output stack: NONE Things in output stack: NONE

TT--Sort: Sort:

(28)

A

B

C

D

E

Things in output stack: NONE Things in output stack: NONE

TT--Sort: Sort:

(29)

A

B

C

D

E

Things in output stack: NONE Things in output stack: NONE

TT--Sort: Sort:

(30)

A

B

C

D

E

Things in output stack: NONE Things in output stack: NONE

TT--Sort: Sort:

(31)

A

B

C

D

E

Things in output stack: E Things in output stack: E

TT--Sort: Sort:

(32)

A

B

C

D

E

Things in output stack: E, D Things in output stack: E, D

TT--Sort: Sort:

(33)

A

B

C

D

E

Things in output stack: E, D, B Things in output stack: E, D, B

TT--Sort: Sort:

(34)

A

B

C

D

E

Things in output stack: E, D, B Things in output stack: E, D, B

TT--Sort: Sort:

(35)

A

B

C

D

E

Things in output stack: E, D, B Things in output stack: E, D, B

TT--Sort: Sort:

(36)

A

B

C

D

E

Things in output stack: E, D, B Things in output stack: E, D, B

TT--Sort: Sort:

(37)

A

B

C

D

E

Things in output stack: E, D, B Things in output stack: E, D, B

TT--Sort: Sort:

(38)

A

B

C

D

E

Things in output stack: E, D, B, C Things in output stack: E, D, B, C

TT--Sort: Sort:

(39)

A

B

C

D

E

Things in output stack: E, D, B, C, A Things in output stack: E, D, B, C, A

TT--Sort Output: A, C, B, D, E Sort Output: A, C, B, D, E

TT--Sort: Sort:

(40)

•• Strongly Connected Components Strongly Connected Components

–– Directed Graph Directed Graph

–– Find Find groups of groups of nodes such that nodes such that in each group, in each group,

every node has an edge to every other node

(41)

•• Strongly Connected Components Strongly Connected Components

–– Method: DFS twice Method: DFS twice

–– Do DFS on Graph G, record finishing time of node Do DFS on Graph G, record finishing time of node –– Do DFS on Graph G Do DFS on Graph G

^TT

, by decreasing finish time , by decreasing finish time

–– Output the Output the vertices vertices

(42)

•• Strongly Connected Components Strongly Connected Components

•• Note: After grouping the vertices, the new Note: After grouping the vertices, the new nodes form a Directed Acyclic Graph

nodes form a Directed Acyclic Graph

•• Problem: Where’s the back button Problem: Where’s the back button

(43)

•• Structure to use: Structure to use: Queue Queue

(44)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

Things in queue:

A, C 3 A, B 10

(45)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

A, B 10 A, C, E 5 A, C, B 7 A, C, D 8

(46)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

A, C, E 5 A, C, B 7 A, C, D 8 A, B, C 11 A, B, D 12

(47)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

A, C, B 7 A, C, D 8 A, B, C 11 A, B, D 12

We are done !!!

(48)

•• Application: Application:

–– Finding shortest path Finding shortest path –– Flood Flood--Fill Fill

(49)

•• Structure to use: Structure to use: Priority Priority Queue Queue

•• Consider the past Consider the past

–– The length of path visited so The length of path visited so far far

•• No negative edges allowed No negative edges allowed

(50)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

Things in priority queue:

A, C 3 A, B 10

Current Route:

A

(51)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

A, C, E 5 A, C, B 7 A, B 10 A, C, D 11 Current Route:

Current Route:

A, C

(52)

A

B

C

D

E 10

3

1 4

2 2

8 7 9

A, C, B 7 A, B 10 A, C, D 11

We find the shortest path already !!!

Current Route:

A, C, E

(53)

•• Structure to use: Structure to use: Priority Priority Queue Queue

•• Consider the past + future Consider the past + future

•• How to consider the future? How to consider the future?

–– Admissible Heuristic (Best Admissible Heuristic (Best--Case Prediction) Case Prediction)

–– How to predict? How to predict?

(54)

•• Prediction 1: Prediction 1: Displacement Displacement

–– Given coordinates, calculate the displacement of Given coordinates, calculate the displacement of current node to destination

current node to destination –– sqrt sqrt((x2 ((x2 –– x1) x1)

²²

+ (y2 + (y2 –– y1) y1)

²²

))

•• Prediction 2: Prediction 2: Manhattan Distance Manhattan Distance

–– Given grid, calculate the horizontal and Given grid, calculate the horizontal and vertical movement

vertical movement –– (x2 (x2 –– x1) + (y2 x1) + (y2 –– y1 y1))

(55)

•• Prediction 3: Hamming Distance Prediction 3: Hamming Distance

–– Given pieces and location, find out the number Given pieces and location, find out the number of misplaced pieces

of misplaced pieces

(56)

Dest

Start

- Manhattan Distance is used

- If there is a tie, consider the one with lowest heuristic first - If there is still a tie, consider in Up, Down, Left, Right order

(57)

Dest

1 + 5 = 6

Start (0 + 6 = 6) 1 + 5 = 6

(58)

Dest 2 + 4 = 6

1 + 5 = 6

Start (0 + 6 = 6) 1 + 5 = 6

(59)

3 + 3 = 6 Dest 2 + 4 = 6

1 + 5 = 6

Start (0 + 6 = 6) 1 + 5 = 6

(60)

4 + 4 = 8

3 + 3 = 6 4 + 2 = 6 Dest

2 + 4 = 6 1 + 5 = 6

Start (0 + 6 = 6) 1 + 5 = 6

(61)

4 + 4 = 8 5 + 3 = 8

3 + 3 = 6 4 + 2 = 6 Dest

2 + 4 = 6 1 + 5 = 6

Start (0 + 6 = 6) 1 + 5 = 6

(62)

4 + 4 = 8 5 + 3 = 8

3 + 3 = 6 4 + 2 = 6 Dest

2 + 4 = 6 1 + 5 = 6

Start (0 + 6 = 6) 1 + 5 = 6 2 + 4 = 6

(63)

4 + 4 = 8 5 + 3 = 8

3 + 3 = 6 4 + 2 = 6 Dest

2 + 4 = 6

1 + 5 = 6 3 + 3 = 6

Start (0 + 6 = 6) 1 + 5 = 6 2 + 4 = 6 3 + 3 = 6

(64)

4 + 4 = 8 5 + 3 = 8

3 + 3 = 6 4 + 2 = 6 Dest

2 + 4 = 6

1 + 5 = 6 3 + 3 = 6

Start (0 + 6 = 6) 1 + 5 = 6 2 + 4 = 6 3 + 3 = 6

(65)

4 + 4 = 8 5 + 3 = 8

3 + 3 = 6 4 + 2 = 6 Dest

2 + 4 = 6

1 + 5 = 6 3 + 3 = 6