Unit 3 - Basic Search and Traversal Techniques

Unit 3Basic search and Traversal

Techniques

Topics to be covered…• Binary Tree Traversal

– Inorder

– Preorder

• Search and traversal techniques for Graphs– BFS

– BFT

– DFS

– DFT

• Code optimization,

• AND/OR graphs,

• Game trees

• Biconnected Components and depth first search

Binary Tree Traversal

• It is a way in which each node in the tree is visited exactly once in systematic manner.

• Popular ways of Binary tree traversal1. Preorder Traversal

2. Postorder Traversal

3. Inorder Traversal

Preorder Traversal

The preorder of a non-empty binary tree is

defined as

1. Visit the root node.

2. Traverse the left sub tree in preorder.

3. Traverse the right sub tree in preorder.

4

Preorder traversal of the above binary tree

A B D E I C F G JRoot

5

A

B C

D E F G

J

Root

I

left Right

Algorithm

preorder(BTNODE *tree)

{

if(tree != NULL)

{

printf(“%c”,tree->data); /* step 1*/

preorder(tree->lchild); /*step 2*/

preorder(tree->rchild); /*step 3*/

}

return;

}6

Inorder Traversal

The Inorder of a non-empty binary tree is

defined as

1. Traverse the left sub tree in inorder.


3. Traverse the right sub tree in inorder.

7

8

A

B C

D E F G

J

Root

I

left Right

Inorder traversal of the above binary tree

D B I E A F C G J

Algorithm

inorder(BTNODE *tree)

{

if(tree != NULL)

{

inorder(tree->lchild); /*step 1*/


inorder(tree->rchild); /*step 3*/

}

return;

}9

Postorder Traversal

The postorder of a non-empty binary tree is

defined as

1. Traverse the left sub tree in postorder.

2. Traverse the right sub tree in postorder.


10

• Post order traversal of the above binary tree

D I E B F J G C A11

A

B C

D E F G

J

Root

I

left Right

Algorithm

postorder(BTNODE *tree)

{

if(tree != NULL)

{

postorder(tree->lchild); /*step 1*/

postorder(tree->rchild); /*step 2*/


}

return;

}12

Binary Search Tree (BST)

• Tree in which each node has left and right child.

• If traversed in inorder, we get a file in ascending order.

13

• Traverse the tree in inorder, we get

9 122125424348

14

25

12 43

9 21 42 48

SEARCHING

• Start with the root.

• Eg; search 21 in the given tree– Compare 21<25, true. Take left branch.

– At left child second comparison is made. Here 21>12. so take right branch.

– On third comparison, since 21=21, the search is announced successful.

15

Algorithm for SearchingSearch(int key_val, int &found, BTNODE *(&parent)){ BTNODE *p;found=0;parent=NULL;if(tree==NULL){ return;}p=tree; 16

while(p!=null)

{

if(p->data==key_val)

{found=1;

return;

}

if(p->data > key_val)

{parent=p;

p=p->lchild;

}

else

if(p->data < key_val)

{parent=p;

p=p->rchild;

}

}}

Advantages

• Advantage over an array is that all the insertion and deletions and searching are performed efficiently.

18

Insertion in a BST

• To insert an element 23 in an tree shown below

• Search for element 23 in that tree.

• Search causes to reach at the node 21 with no where to go.

• Since 23>21, we simply insert node 23 as right child to node 21.

19

25

12 43

9 21 42 48

25

12 43

9 21 42 48

23

23>21

Algorithm for insertioninsert BST(int num)

{

int found;

BTNODE *temp,*parent;

search_node(num,found,parent);

if(found==1)

printf(“Node already exists”);

else

20

{

temp=(BTNODE*)malloc(sizeof(BTNODE));

temp->data=num;

temp->lchild=temp->rchild=NULL;

if(parent==NULL)

tree=temp;

else

{ if(parent->data > num)

parent->lchild=temp;

else

parent-> rchild=temp;

}}}

Deletion in a BST

Three cases:

1. Node to be deleted has no children.

2. Node to be deleted has exactly one subtree.

3. Node to be deleted has two subtrees.

22

In first situation ,

As there is no children for the node, so that node is deleted with out any further adjustments to the tree.

23

In second case,

The node to be deleted has exactly one child, so this child is moved up the tree to occupy its place.

24

25

12 43

9 21 42 48

23Node to be

deleted

25

12 43

9 23 42 48

After Deletion of the node 21

Before Deletion of the node 21

Third case,

The node to be deleted has two sub trees. The in order successor of the node should be moved up to occupy its

place.

25

25

12 43

9 21 42 48

23

Node to be

deleted42

12 43

9 21 48

23

After Deletion of

the Root node 25Before Deletion of

the Root node 25

C code for deletiondelete_BST(int number, BTNODE *tree)

{

int found;

BTNODE *temp, *parent, *temp_succ;

if(tree==NULL)

{

printf(“ Tree is empty”);

return;

}26

parent=temp=Null;

search_BST(number,parent,temp,tree,found)

if(found==0)

{ printf(“ node to be deleted is not found”);

return;

}

/* first case : The node to be deleted has no children*/

If((temp->lchild == NULL) && (temp->rchild ==NULL))

{

if(parent-.rchild == temp)

{

parent->rchild = NULL;

}

else

{

parent->lchild= NULL;

}

free(temp);

return;

}

28

/* second case: if node to be deleted has only left child */

If(temp->lchild != NULL)&&(temp->rchild == NULL)

{

if(parent->lchild ==temp)

{

parent->lchild =temp->lchild;

}

else

{

parent->rchild = temp->lchild;

}

free(temp);

return;

}

29

/* Third case: if node to be deleted has two children */

If((temp->lchild != NULL) && (temp->rchild != NULL))

{

parent = temp;

temp_succ = temp->rchild;

while(temp_succ != NULL)

{

parent=temp_succ;

temp_succ=temp_succ->lchild;

}

temp->data = temp_succ->data;

temp=temp_succ;

}

}

30

Efficiency of Binary Search Tree Operations

• The timing analysis of searching a binary search

tree, for randomly inserted records is O(log n).

• Worst case behavior of a binary search tree

would occur when records are inserted in sorted

order. In this case the search time is O(n), as the

resulting tree consists all NULL left children.

31

Search and traversal techniques for graphs

• Many graph algorithms require one to systematically examine the nodes and edges of a graph G.

• There are two standard ways that this is done.

– Breadth- first search .

– Depth- first search.

• Breadth first search will use a queue as an auxiliary structure to hold nodes for future processing.

• Depth first search will use a stack.

Breadth-first Search• Expands the frontier between discovered and

undiscovered vertices uniformly across the breadth of the frontier.

– A vertex is “discovered” the first time it is encountered during the search.

– A vertex is “finished” if all vertices adjacent to it have been discovered.

• Colors the vertices to keep track of progress.– White – Undiscovered.

– Gray – Discovered but not finished.

– Black – Finished.

• Colors are required only to reason about the algorithm. Can be implemented without colors.

Example (BFS)

0

r s t u

v w x y

Q: s 0

(Courtesy of Prof. Jim Anderson)

Example (BFS)

1 0

1

r s t u

v w x y

Q: w r 1 1

Example (BFS)

1 0

1 2

2

r s t u

v w x y

Q: r t x 1 2 2

Example (BFS)

1 0

1 2

2

2

r s t u

v w x y

Q: t x v 2 2 2

Example (BFS)

1 0

1 2

2 3

2

r s t u

v w x y

Q: x v u 2 2 3

Example (BFS)

1 0

1 2 3

2 3

2

r s t u

v w x y

Q: v u y 2 3 3

Example (BFS)

1 0

1 2 3

2 3

2

r s t u

v w x y

Q: u y 3 3

Example (BFS)

1 0

1 2 3

2 3

2

r s t u

v w x y

Q: y 3

Example (BFS)

1 0

1 2 3

2 3

2

r s t u

v w x y

Q:

Example (BFS)

1 0

1 2 3

2 3

2

r s t u

v w x y

BF Tree

BFS(G,s)

1. for each vertex u in V[G] – {s}

2 do color[u] white

3 d[u]

4 [u] nil

5 color[s] gray

6 d[s] 0

7 [s] nil

8 Q

9 enqueue(Q,s)

10 while Q

11 do u dequeue(Q)

12 for each v in Adj[u]

13 do if color[v] = white

14 then color[v] gray

15 d[v] d[u] + 1

16 [v] u

17 enqueue(Q,v)

18 color[u] black

white: undiscoveredgray: discoveredblack: finished

Q: a queue of discovered verticescolor[v]: color of vd[v]: distance from s to v[u]: predecessor of v

Applications of BFS

• Used to solve following problems– Testing whether graph is connected.

– Computing the spanning forest of the graph.

– Computing a cycle in graph or reporting that no such cycle exists.

Depth-first Search (DFS)• Explore edges out of the most recently discovered

vertex v.

• When all edges of v have been explored, backtrack to explore other edges leaving the vertex from which v was discovered (its predecessor).

• “Search as deep as possible first.”

• Continue until all vertices reachable from the original source are discovered.

• If any undiscovered vertices remain, then one of them is chosen as a new source and search is repeated from that source.

Comp 122, Fall 2004

Depth-first Search• Input: G = (V, E), directed or undirected. No source

vertex given!

• Output:– 2 timestamps on each vertex. Integers between 1 and 2|

V|.

• d[v] = discovery time (v turns from white to gray)

• f [v] = finishing time (v turns from gray to black)

– [v] : predecessor of v = u, such that v was discovered during the scan of u’s adjacency list.

• Uses the same coloring scheme for vertices as BFS.

Comp 122, Fall 2004

Pseudo-codeDFS(G)

1. for each vertex u V[G]

2. do color[u] white

3. [u] NIL

4. time 0

5. for each vertex u V[G]

6. do if color[u] = white

7. then DFS-Visit(u)Uses a global timestamp time.

DFS-Visit(u)1. color[u] GRAY White vertex u

has been discovered2. time time + 13. d[u] time4. for each v Adj[u]5. do if color[v] = WHITE6. then [v] u7. DFS-Visit(v)8. color[u] BLACK Blacken u;

it is finished.9. f[u] time time + 1

Example (DFS)

1/

u v w

x y z

u1 Push u

Stack

Step 1: DFS(G) If suppose G is a given graph

Line 1: For each vertex uE V[G]

do color[u]= white

parent[u]= NIL

That is any vertex from the given graph and assign color white. Time=0;

For each vertex uEv[G] if color[u]= white(true)

Then DFS- VISIT[u]

since above condition checked by if statement is correct therefore now we apply DES VISIT algo for u

Step 2: Apply DFS-VISIT algorithm for u.

Line 1: color[u]=gray

Line 2: discover[u]= time= discover[u]=0

Line 3: time=time+1

time=0+1=1

Line 4: for each vEadj[u]={v,x}

Line 5: if color[v]=white [true]

Line 6: then [v] u [ make u as the parent of u]

Line 7: DFS-Visit(v)

Example (DFS)

1/ 2/

u v w

x y z

u1Push [v]

Stack

v2

Line 1: color[v]= gray

Line 2: discover[v]= time= 1

Line 3: time= time+1= 1+1=2 assign time =2 to vertex v

Line 4: now, find adjacent of vertex v.

for each v E adj[u]

adj[v]={y}

Line 5: now, check color of y

if color[y]=white (true)

line 6: make vertex v as a parent of vertex y.

parent[y]=v.

Example (DFS)

1/

3/

2/

u v w

x y z

u1

Push [y]

Stack

v2y3

Now find the adjacent vertex for y as

Adj[y]= [x]

Now check the color[x]= white (true)

Make the y as the parent of vertex x.

Again apply DFS_VISIT for vertex x

Set the color[x]= gray

Set discover time as discover time[x]= time= 3

time=time+1=4 assign time = 4 to vertex x

Example (DFS)

1/

4/ 3/

2/

u v w

x y z

u1

Push [x]

Stack

v2y3x4

Now again find the adjacent of vertex x.

Adj[x]= v

If the color[v]= white (false)

Then

Color[x]= black.

Finish x= time=time+1

Finish[x]= 4+1=5

Pop the top element from stack i.e, x as we have finished it.

Example (DFS)

1/

4/ 3/

2/

u v w

x y z

B

u1

Pop [x]Stack after

v2y3

Example (DFS)

1/

4/5 3/

2/

u v w

x y z

B

Example (DFS)

1/

4/5 3/6

2/

u v w

x y z

B

Example (DFS)

1/

4/5 3/6

2/7

u v w

x y z

B

Example (DFS)

1/

4/5 3/6

2/7

u v w

x y z

BF

Example (DFS)

1/8

4/5 3/6

2/7

u v w

x y z

BF

Example (DFS)

1/8

4/5 3/6

2/7 9/

u v w

x y z

BF

Example (DFS)

1/8

4/5 3/6

2/7 9/

u v w

x y z

BF C

Example (DFS)

1/8

4/5 3/6 10/

2/7 9/

u v w

x y z

BF C

Example (DFS)

1/8

4/5 3/6 10/

2/7 9/

u v w

x y z

BF C

B

Example (DFS)

1/8

4/5 3/6 10/11

2/7 9/

u v w

x y z

BF C

B

Example (DFS)

Comp 122, Fall 2004

1/8

4/5 3/6 10/11

2/7 9/12

u v w

x y z

BF C

B

Each vertex has two time stamps•The first stamp records when vertex is first recorded and •The second time stamp records when the search finishes examines adjacency list of vertex.

The order in which the nodes are visited in DFS

Application of DFS

• Testing whether graph is connected.

• Computing a spanning forest of graph.

• Computing a path between two vertices of graph or equivalently reporting that no such path exist.

• Computing a cycle in graph or equivalently reporting that no such cycle exists.

Code Optimization

Introduction

• Criteria for Code-Improving Transformation:

– Meaning must be preserved (correctness)

– Speedup must occur on average.

– Work done must be worth the effort.

• Opportunities:– Programmer (algorithm, directives)

– Intermediate code

– Target code

Peephole Optimizations 1. A Simple but effective technique for locally improving

the target code is peephole optimization,

2. A method for trying to improve the performance of the target program by examining a short sequence of target instructions and replacing these instructions by a shorter or faster sequence whenever possible.

Characteristics of peephole optimization

1. Redundant instruction elimination

2. Flow of control information

3. Algebraic Simplification

4. Use of machine Idioms

Peephole Optimizations

• Constant Folding

x := 32 becomes x := 64

x := x + 32

• Unreachable Code

goto L2

x := x + 1 No need• Flow of control optimizations

goto L1 becomes goto L2

…

L1: goto L2 No needed if no other L1 branch

Peephole Optimizations

• Algebraic Simplification

x := x + 0 No needed • Dead code

x := 32 where x not used after statement

y := x + y y := y + 32 • Reduction in strength

x := x * 2 x := x + x

x := x << 2

Basic Block Level

1. Common Sub expression elimination

2. Constant Propagation

3. Copy Propagation

4. Dead code elimination

5. …

Simple example: a[i+1] = b[i+1]

•t1 = i+1

•t2 = b[t1]

•t3 = i + 1

•a[t3] = t2

•t1 = i + 1

•t2 = b[t1]

•t3 = i + 1 no longer live

•a[t1] = t2

Common expression can be eliminated

•i = 4

•t1 = i+1

•t2 = b[t1]

•a[t1] = t2

•i = 4

•t1 = 5

•t2 = b[t1]

•a[t1] = t2

Now, suppose i is a constant:

i = 4

t1 = 5

t2 = b[5]

a[5] = t2

i = 4

t2 = b[5]

a[5] = t2

Final Code:

Optimizations on CFG

• Must take control flow into account – Common Sub-expression Elimination

– Constant Propagation

– Dead Code Elimination

– Partial redundancy Elimination

– …

• Applying one optimization may raise opportunities for other optimizations.

Simple Loop Optimizations

• Code Motion

Move invariants out of the loop.

Example:

while (i <= limit - 2)

becomes

t := limit - 2

while (i <= t)

Three Address Code of Quick Sorti = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto (5)

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto (9)

if i >= j goto (23)

t6 = 4 * i

x = a[t6]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

t7 = 4 * I

t8 = 4 * j

t9 = a[t8]

a[t7] = t9

t10 = 4 * j

a[t10] = x

goto (5)

t11 = 4 * I

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

Find The Basic Blocki = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto (5)

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto (9)

if i >= j goto (23)

t6 = 4 * i

x = a[t6]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

t7 = 4 * I

t8 = 4 * j

t9 = a[t8]

a[t7] = t9

t10 = 4 * j

a[t10] = x

goto (5)

t11 = 4 * i

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

Flow Graphi = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t7 = 4 * i

t8 = 4 * j

t9 = a[t8]

a[t7] = t9

t10 = 4 * j

a[t10] = x

goto B2

t11 = 4 * i

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

B1

B2

B3

B4

B5 B6

Common Subexpression Elimination

i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t7 = 4 * i

t8 = 4 * j

t9 = a[t8]

a[t7] = t9

t10 = 4 * j

a[t10] = x

goto B2

t11 = 4 * i

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t8 = 4 * j

t9 = a[t8]

a[t6] = t9

t10 = 4 * j

a[t10] = x

goto B2

t11 = 4 * i

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t8 = 4 * j

t9 = a[t8]

a[t6] = t9

a[t8] = x

goto B2

t11 = 4 *i

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t8 = 4 * j

t9 = a[t8]

a[t6] = t9

a[t8] = x

goto B2

t11 = 4 * i

x = a[t11]

t12 = 4 * i

t13 = 4 * n

t14 = a[t13]

a[t12] = t14

t15 = 4 * n

a[t15] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t8 = 4 * j

t9 = a[t8]

a[t6] = t9

a[t8] = x

goto B2

t11 = 4 * i

x = a[t11]

t13 = 4 * n

t14 = a[t13]

a[t11] = t14

t15 = 4 * n

a[t15] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

t6 = 4 * i

x = a[t6]

t8 = 4 * j

t9 = a[t8]

a[t6] = t9

a[t8] = x

goto B2

t11 = 4 * i

x = a[t11]

t13 = 4 * n

t14 = a[t13]

a[t11] = t14

a[t13] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

x = a[t2]

t8 = 4 * j

t9 = a[t8]

a[t2] = t9

a[t8] = x

goto B2

t11 = 4 * i

x = a[t11]

t13 = 4 * n

t14 = a[t13]

a[t11] = t14

a[t13] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

x = t3

t8 = 4 * j

t9 = a[t8]

a[t2] = t9

a[t8] = x

goto B2

t11 = 4 * i

x = a[t11]

t13 = 4 * n

t14 = a[t13]

a[t11] = t14

a[t13] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

x = t3

t9 = a[t4]

a[t2] = t9

a[t4] = x

goto B2

t11 = 4 * i

x = a[t11]

t13 = 4 * n

t14 = a[t13]

a[t11] = t14

a[t13] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

x = t3

a[t2] = t5

a[t4] = x

goto B2

t11 = 4 * i

x = a[t11]

t13 = 4 * n

t14 = a[t13]

a[t11] = t14

a[t13] = x

B1

B2

B3

B4

B5 B6


i = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

x = t3

a[t2] = t5

a[t4] = x

goto B2

x = t3

t14 = a[t1]

a[t2] = t14

a[t1] = x

B1

B2

B3

B4

B5 B6

Similarly for B6

Dead Code Eliminationi = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

x = t3

a[t2] = t5

a[t4] = x

goto B2

x = t3

t14 = a[t1]

a[t2] = t14

a[t1] = x

B1

B2

B3

B4

B5 B6

Dead Code Eliminationi = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

a[t2] = t5

a[t4] = t3

goto B2

t14 = a[t1]

a[t2] = t14

a[t1] = t3

B1

B2

B3

B4

B5 B6

Reduction in Strengthi = m - 1

j = n

t1 =4 * n

v = a[t1]

i = i + 1

t2 = 4 * i

t3 = a[t2]

if t3 < v goto B2

j = j – 1

t4 = 4 * j

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

a[t2] = t5

a[t4] = t3

goto B2

t14 = a[t1]

a[t2] = t14

a[t1] = t3

B1

B2

B3

B4

B5 B6

Reduction in Strengthi = m - 1

j = n

t1 =4 * n

v = a[t1]

t2 = 4 * i

t4 = 4 * j

t2 = t2 + 4

t3 = a[t2]

if t3 < v goto B2

t4 = t4 - 4

t5 = a[t4]

if t5 > v goto B3

if i >= j goto B6

a[t2] = t5

a[t4] = t3

goto B2

t14 = a[t1]

a[t2] = t14

a[t1] = t3

B1

B2

B3

B4

B5 B6

And-Or Graphs

• Technique for solving problems that can be decomposed into sub problems

• Links between nodes indicates relations between problems

• Or node: one of its successor node has to be solved

• And node: all of its successor node has to be solved

• Problem can be specified by two thinks: start node, goal nodes.

• Goal nodes: trivial (or primitive) problems

• Cost can be attached to arcs or nodes

And-Or Graphs

• Difference between state-state representation and and or representation.

solution: path vs. tree

Search in and-or graphs

a

b c

e

h i

d gf

Game tree

• A game tree is a directed graph whose nodes are positions in a game and whose edges are moves.

• The complete game tree for a game is the game tree starting at the initial position and containing all possible moves from each position; the complete tree is the same tree as that obtained from the extensive form game representation.

Game tree for tic-tac-toe game

• The diagram shows the first two levels, or plies, in the game tree for tic-tac-toe.

• We consider all the rotations and reflections of positions as being equivalent, so the first player has three choices of move: in the center, at the edge, or in the corner.

• The second player has two choices for the reply if the first player played in the center, otherwise five choices. And so on.

• The number of leaf nodes in the complete game tree is the number of possible different ways the game can be played. For example, the game tree for tic-tac-toe has 26,830 leaf nodes.

Biconnected component• In graph theory, a bi-connected

component (or 2-connected component) is a maximal bi connected subgraph.

• Any connected graph decomposes into a tree of biconnected components called the block tree of the graph.

• The blocks are attached to each other at shared vertices called cut vertices or articulation points. Specifically, a cut vertex is any vertex that when removed increases the number of connected components.

• Each color corresponds to a biconnected component.

• Multi-colored vertices are cut vertices, and thus belong to multiple biconnected components.

Biconnected Components

• G is Biconnected iff either

(1) G is a single edge, or

(2) for each triple of vertices u,v,w

w-avoiding path from u to v

(equivalently: two disjoint paths from u to v)

∃∃

Example of Biconnected Components of Graph G

• Maximal subgraphs of G which are biconnected.

5

1

8

1

6

2

4

35

7

8

1

2

2

3

4

6

5

7

G

Biconnected Components Meet at Articulation Points• The intersection of two biconnected

components consists of at most one vertex called an Articulation Point.

• Example: 1,2,5 are articulation points1

6

2

4

3

5

7

8

G

Discovery of Biconnected Components via Articulation

Points– find articulation points

then can compute biconnected components:

Algorithm: • During DFS, use auxiliary stack to store visited edges. • Each time we complete the DFS of a tree child of an articulation point, pop all stacked edges• currently in stack • These popped off edges form a biconnected component

• End of unit 3

Unit 3 - Basic Search and Traversal Techniques

Documents

Transcript of Unit 3 - Basic Search and Traversal Techniques