1. EMIS 8374 Search Algorithms Updated 9 February 2004

2. Generic Search Algorithm (pg 74)
Find all nodes reachable via a directed path from source node s
All nodes are either marked or unmarked
Arc (i,j) is admissible if i is marked and j is not marked; and inadmissible, otherwise.

3. Initialization unmark all nodes in N; mark source node s; pred(s):= 0;
next := 1;
order(s) := 1
LIST :={s};

4. Main Loop while LIST is not empty do begin select a node i from LIST;
if there is an admissible arc (i, j) then
mark node j; pred(j) := i, next := next + 1,
order(j) := next; add node j to LIST;
end
else delete node i from LIST;

5. Search Example 1: s = 4 2 4 1 6 3 5

6. Search Example 1: Initialization2 4 1 6 3 5
next = 1
LIST ={4}
pred[4] = 0
order[4] = 1

7. Search Example 1: While Loop2 4 1 6 3 5
next = 1
LIST ={4}
pred[4] = 0
order[4] = 1
i = 4.
Find an admissible arc.
j = 6.

8. Search Example 1: Mark Node 62 4 1 6 3 5
next = 2
LIST ={4, 6}
pred[6] = 4
order[6] = 2

9. Search Example 1: While Loop2 4 1 6 3 5
LIST ={4, 6}.
i = 6.
Find an admissible arc.
LIST = {4}.

10. Search Example 1: While Loop2 4 1 6 3 5
LIST ={4}
i = 4.
Find an admissible arc.
j = 3.

11. Search Example 1: Mark Node 32 4 1 6 3 5
next = 3
LIST ={4, 3}
pred[3] = 4
order[3] = 3

12. Search Example 1: While Loop2 4 1 6 3 5
LIST ={4, 3}.
i = 4.
Find an admissible arc.
LIST = {3}.

13. Search Example 1: While Loop2 4 1 6 3 5
LIST ={3}.
i = 3.
Find an admissible arc.
j = 5.

14. Search Example 1: Mark Node 52 4 1 6 3 5
next = 4
LIST ={5, 3}
pred[5] = 3
order[5] = 4

15. Search Example 1: While Loop2 4 1 6 3 5
LIST ={5, 3}.
i = 3.
Find an admissible arc.
LIST = {5}.

16. Search Example 1: While Loop2 4 1 6 3 5
LIST ={5}.
i = 5.
Find an admissible arc.
LIST = {}.

17. Search Example 1: Search Tree2 4 2 1 6 4 3 3 5
order[3] = 3, order[4] = 1, order[5] = 4,
order [6] = 2
Pred[4] = 0,
Pred[6] = 1,
Pred[5] = 3.
Pred[3] =4

18. Trees
An undirected graph is connected if there is a path between an pair of nodes
A tree T=(N,A) is a connected graph with with n-1 arcs (edges)
A graph with n nodes must have at least n-1 arcs to be connected

19. A Connected Graph 2 4 1 6 3 5

20. A Tree 2 4 1 3 5 6

21. Complexity of Generic Search
Each iteration of the While loop either adds a new node to LIST or removes a node from LIST.
A given node can be added at most once and removed at most once.
Thus, the loop runs at most 2n times.

22. Complexity of Generic Search: Work per iteration of the While Loop
Selecting a node in LIST is O(1).
Deleting a node from LIST is O(1).
Marking a node (updating pred, next, and order, etc) is O(1).
Therefore, the work per iteration is O(1) + work required finding an admissible arc.

23. Finding an Admissible Arc Incident to Node i: Naïve Approach
found := 0;
for { (i, j) in A(i) }
if j is unmarked then
begin
found := 1;
break;
end
if found = 1 then
mark node j; pred(j) := i; etc …
else delete node i from LIST

24. Finding an Admissible Arc Incident to Node i: Naïve Approach
Worst-Case:
when there are no admissible arcs incident to node i this approach will check all of node i’s neighbors to see if they are marked.
O(n)
Overall complexity of generic search: 2n x n = O(n2)

25. Finding an Admissible Arc Incident to Node i: Efficient Approach
Use an adjacency list representation of the network
Maintain a current arc data structure for each node.
Indicates the next candidate arc in the adjacency list for node i.
The next time node i is selected from LIST check the current arc first.
If the current arc points to a marked node we move to the next arc in the adjacency list.
If the we reach the end of the adjacency list for a given node we remove it from LIST.

26. Adjacency List Implementation1 2 3 2 5 4 3 5 5 6 4 6 3 6

27. Search from Node 4: LIST = {4}1 2 3 2 5 4 3 5 5 6 4 6 3 6

28. Mark Node 6 1 2 3 2 5 4 3 5 5 6 4 6 3 6

29. Advance Current Arc for Node 41 2 3 2 5 4 3 5 5 6 4 6 3 6

30. LIST = {4, 6}, i = 6 1 2 3 2 5 4 3 5 5 6 4 6 3 6

31. LIST = {4}, i = 4, mark 3 1 2 3 2 5 4 3 5 5 6 4 6 3 6

32. LIST = {4,3}, i = 4 1 2 3 2 5 4 3 5 5 6 4 6 3 6

33. LIST = {3}, i = 3, mark 5 1 2 3 2 5 4 3 5 5 6 4 6 3 6

34. LIST = {3, 5}, i = 3 1 2 3 2 5 4 3 5 5 6 4 6 3 6

35. LIST = {5}, i = 5 1 2 3 2 5 4 3 5 5 6 4 6 3 6

36. LIST = {} 1 2 3 2 5 4 3 5 5 6 4 6 3 6

37. Complexity with Adjacency List
For each node i marked by the search, we check update/test the current arc parameter exactly once for each arc in A(i).
The total number of operations required by the search algorithm to find admissible arcs is proportional to the sum of |A(i)| for all the nodes it marks.
Overall complexity is O(n) for marking nodes, updating pred vector etc, plus O(m) for finding admissible arcs = O(n + m) = O(m)

38. Breadth-First Search Implement LIST as an ordered list
Always pick the first node in the list
Always add newly marked nodes to the end of the list
Level parameter
Initialize level(s) := 0
Set level(i) := level(pred[i]) + 1
Level(i) = number of arcs in path from s to i

39. Breadth-First Search: s = 12 4 1 6 1 3 5

40. Breadth-First Search: s = 12 2 4 1 6 1 3 5
LIST = {1, 2}

41. Breadth-First Search: s = 12 2 4 1 6 1 3 5 3
LIST = {1, 2, 3}

42. Breadth-First Search: s = 12 2 4 1 6 1 3 5 3
LIST = {2, 3}

43. Breadth-First Search: s = 12 2 4 1 6 1 3 5 3
LIST = {2, 3}

44. Breadth-First Search: s = 12 4 2 4 1 6 1 3 5 3
LIST = {2, 3, 4}

45. Breadth-First Search: s = 12 4 2 4 1 6 1 3 5 3 5
LIST = {2, 3, 4, 5}

46. Breadth-First Search: s = 12 4 2 4 1 6 1 3 5 3 5
LIST = {3, 4, 5}

47. Breadth-First Search: s = 12 4 2 4 1 6 1 3 5 3 5
LIST = {4, 5}

48. Breadth-First Search: s = 12 4 2 4 6 1 6 1 3 5 3 5
LIST = {4, 5, 6}

49. Breadth-First Search: s = 12 4 2 4 6 1 6 1 3 5 3 5
LIST = {5, 6}

50. Breadth-First Search: s = 12 4 2 4 6 1 6 1 3 5 3 5
LIST = {6}

51. Breadth-First Search: s = 12 4 2 4 6 1 6 1 3 5 3 5
LIST = {}

52. Problems Solved by BFS
Shortest Path problem when all arcs have the same cost.
s-t shortest path
all-pairs shortest path problem
Determining strong connectivity
Is there a directed path between all pairs of nodes?

53. Levels of a BFS Tree Root node is at level 0
Descendants of the root are at level 1
IF node i is at level k Then
the children of i are at level k+1

54. BFS Solves s-t Shortest Path2 4 1 6 3 5
Level 0
Level 1
Level 2
Level 3

55. Unweighted Shortest Path Problems
cij = 1 for all (i,j)
BFS solves s-t shortest path problem in O(m) time.
BFS solves all-pairs shortest path problem in O(nm) time.
BFS determines strong connectivity in O(nm) time.

56. Depth-First Search
Always pick the last (most recently added) node in the LIST
Pick marked nodes in a last-in, first-out order (LIFO)
Breadth-First Search uses a FIFO order
Makes a “deep” probe, creating as long a path as possible
Backs up when it can’t mark a new node

57. Depth-First Search 1 2 4 3 5 6

58. Depth-First Search 5 2 1 2 4 3 5 6 4 6 3 List = {} List = {1}

59. Depth-First Search Tree5 2 2 4 1 6 1 4 3 5 6 3

60. Properties of a DFS Tree
If node j is a descendant of node i, then order(j) > order(i)
All descendants of any node are ordered consecutively