1

Design and Analysis of Algorithms

演算法設計與分析

Lecture 10November 26, 2014

洪國寶

2

Homework # 81. 20.2-1 (p. 488) / 19.2-1 (p. 518) 2. 20.4-1 (p. 496) / 19.4-1 (p. 526)3. Show that if we start with empty Fibonacci heap and do

not perform cascading-cuts, then it is possible for a sequence of Fibonacci heap operations to result in degree k trees that have only k+1 nodes, k1.

4. Provide a sequence of operations on a Fibonacci heap such that, for any n 0, a binomial tree Bn is produced.

5. 21.3-2 (p. 504 / p. 572)

Due December 3, 2014

3

Outline

• Review• Data structures for disjoint sets• Elementary graph algorithms

4

Review: Complexity of Mergeable Heaps

• Extract-Min(H): deletes the node with the minimum key.• Decrease-Key(H, x, k): assigns to node x the new key

value k, which is its current key value.

5

Binomial Trees

• Binomial tree.–Recursive definition:

Bk-1

Bk-1

B0 Bk

B0 B1 B2 B3 B4

6

Review: Binomial Heap• Binomial heap. Vuillemin, 1978.– Sequence of binomial trees that satisfy binomial heap

property.• each tree is min-heap ordered• 0 or 1 binomial tree of order k

B4 B0B1

55

45 32

30

24

23 22

50

48 31 17

448 29 10

6

37

3 18

7

Review: Binomial Heap Properties• Properties of N-node binomial heap.– Min key contained in root of B0, B1, . . . , Bk. (root list) – Contains binomial tree Bi iff bi = 1 where bn b2b1b0 is binary

representation of N.– At most log2 N + 1 binomial trees.– Height log2 N.

B4 B0B1

55

45 32

30

24

23 22

50

48 31 17

448 29 10

6

37

3 18

N = 19# trees = 3height = 4binary = 10011

8

Review: Binomial Heap Union

• Create heap H that is union of heaps H' and H''.– Analogous to binary addition.

• Running time = O(log N)– Proportional to number of trees in root lists 2( log2 N + 1).

001 1100 1+011 1

11110

1

19 + 7 = 26

9

3

37

6 18

55

45 32

30

24

23 22

50

48 31 17

448 29 10

H

Review: Binomial Heap Extract-min Operation• Delete node with minimum key in binomial heap H.– Find root x with min key in root list of H, and delete– H' broken binomial trees– H Union(H', H)

• Running time. O(log N)

10

3

37

6 18

55

x 32

30

24

23 22

50

48 31 17

448 29 10

H

Review: Binomial Heap Decrease Key Operation

• Decrease key of node x in binomial heap H.– Suppose x is in binomial tree Bk.– Bubble node x up the tree if x is too small.

• Running time. O(log N)– Proportional to depth of node x log2 N .

depth = 3

11

Review: Fibonacci Heaps• Fibonacci heap history. –Fredman and Tarjan (1986)–Ingenious data structure and analysis.

• Fibonacci heap intuition.–Similar to binomial heaps, but less structured.–Decrease-key and union run in O(1) time.–"Lazy" unions and inserts

• We do not attempt to consolidate trees in a Fibonacci heap when we unite two heaps or insert a new node.

12

Fibonacci Heaps: Structure

• Fibonacci heap.–Set of min-heap ordered trees.

723

30

17

35

26 46

24

H 39

4118 52

3

44

min

marked

13

Fibonacci Heaps: Potential Function• Key quantities.– degree[x] = degree of node x.– mark[x] = mark of node x (black or gray).– t(H) = # trees.– m(H)= # marked nodes.– (H)= t(H) + 2m(H) = potential function.

723

30

17

35

26 46

24

H

t(H) = 5, m(H) = 3

(H) = 11

39

4118 52

3

44

mindegree = 3

14

Fibonacci Heap Operation 5: Extract Min

• Extract min.– Delete min and concatenate its children into root list.– Consolidate trees so that no two roots have same degree.

39

411723 18 52

30

7

35

26 46

24

44

currentmin

15

Fibonacci Heap Extract Min Analysis

• Notation.– D(n) = max degree of any node in Fibonacci heap with n nodes.– t(H) = # trees in heap H.– (H)= t(H) + 2m(H).

• Actual cost. O(D(n) + t(H))

• Amortized cost. O(D(n))– t(H') D(n) + 1 since no two trees have same degree.– (H) D(n) + 1 - t(H).

scale up the units of potential to dominate the constant hidden in O(t(H)).

16

• Decrease key of element x to k.– Case 0: min-heap property not violated.

• decrease key of x to k• change heap min pointer if necessary

– Case 1: parent of x is unmarked.• decrease key of x to k• cut off link between x and its parent• mark parent• add tree rooted at x to root list, updating heap min pointer

– Case 2: parent of x is marked.• decrease key of x to k• cut off link between x and its parent p[x], and add x to root list• cut off link between p[x] and p[p[x]], add p[x] to root list

– If p[p[x]] unmarked, then mark it.

– If p[p[x]] marked, cut off p[p[x]], unmark, and repeat. Cascading-cuts

Fibonacci Heap Decrease Key

17

• Notation.– t(H) = # trees in heap H.– m(H) = # marked nodes in heap H.– (H) = t(H) + 2m(H).

• Actual cost. O(c)• Amortized cost. O(1)– t(H') = t(H) + c– m(H') m(H) - c + 2

• each cascading cut (except the last one) unmarks a node• last cascading cut could potentially mark a node

– c + 2(-c + 2) = 4 - c.

Fibonacci Heap Decrease Key

scale up the units of potential to dominate the constant hidden in O(c).

18

Fibonacci Heaps: Bounding Max Degree

• Definition.D(N) = max degree in Fibonacci heap with N nodes.

• Key lemma.D(N) log N, where = (1 + 5) / 2.

• Corollary.Delete and Extract-min take O(log N) amortized time.

19

Outline

• Review• Data structures for disjoint sets• Elementary graph algorithms

20

Data structure for disjoint sets

• Discuss the data structures to maintain a collection of pair-wise disjoint dynamic sets.– Operations: make-set, union, find-set– Implementations: linked-lists, rooted trees– Applications: many

21

Disjoint Sets• Maintain a collection S = {S1, …, Sk} of disjoint dynamic sets.• Each set has a representative member.• Support Operations:

– Make-Set(x): Make new singleton set containing object x (x is representative).

– Union(x, y): Like before (x and y are objects in two sets to be merged).

– Find-Set(x): Returns pointer to representative set containing x.

• Complexity: In terms of – n = # of Make-Set operations.– m = total # of operations.– Note: m n.

22

Applications for disjoint sets

• Fortran compliers (common, equivalent statements)

• Computational geometry problems• Unification in logic programming• Longest common subsequences• Graph problems (minimum spanning trees,

connected components, …)

23

Connected components

• Given a graph G=(V,E), a path of length k from a vertex u to a vertex u’ is a sequence of vertices <V0, V1, …, Vk> such that u=V0, u’=Vk, and (Vi-1, Vi) E for i=1,2, … ,k.

• If there is a path p from u to u’, we say that u’ is reachable from u to u’ via p.

• The connected components of a graph are the equivalence classes of vertices under the is-reachable-from relation.

24

Compute the connected components

25

26

Determine whether two vertices are in the same component

Time complexity?

27

Data structure for disjoint sets

• Discuss the data structures to maintain a collection of pair-wise disjoint dynamic sets.– Operations: make-set, union, find-set– Implementations: linked-lists, rooted trees– Applications: many

28

Linked ListsStore set {a, b, c} as:

Make-Set and Find-Set are O(1).

Union(x, y): Append x’s list onto the end of y’s list. Update representative pointers in x’s list (Figure 21.2).

•Time is linear in |x|.

•Running time for a sequence of m ops can take (m²) time. (Figure 21.3) (Not very good.)

a b c

representativetail

29

union

Union(x, y): Append x’s list onto the end of y’s list. Update representative pointers in x’s list.

30

Example

n make-set operations

n-1 union operations

Total time: next slide

31

Example (Cont.)

OperationM-S(x1)M-S(x2)M-S(xn)U(x1, x2)U(x2, x3)U(x3, x4)U(xn-1, xn)

“Time”111123n–1

m = 2n – 1 operations.

Total Time is:

• (n) = (m) for Make-Set ops.

• for Union ops.

• (m²) total.• (m) amortized.

Total Time is:

• (n) = (m) for Make-Set ops.

• for Union ops.

• (m²) total.• (m) amortized.

)Θ(m)Θ(ni 221n

1i

32

Improvement: Weighted-Union Heuristic

• Keep track of list length in representative. (Time/space tradeoff)

• Modify Union so that smaller list is appended to longer one.

• Time for Union is now proportional to the length of the smaller list.

33

Amortized Running Time of WUHTheorem 21.1: Sequence of m operations takesO(m + n log n) time.

Theorem 21.1: Sequence of m operations takesO(m + n log n) time.

Proof:

M-S and F-S contribute O(m) total.

What about Union? (See the next slide)

Time is dominated by no. of total times we change a rep. pointer.

A given object’s rep. pointer can change at most log n times.

34

What about Union?

o1 o2 o3 o4… .. On totalU1 v v 2U2 v v 2U3 v v v 3..Uj v v v v v O(n)Total O(?)

35

Proof of Theorem 21.1 (Continued)

Note: n = no. of M-S’s = no. of objects

After object x’s rep. ptr. has been changed once, set has 2 members. …………………………………………… twice..…….. 4 members.…………………………………………… three times... 8 members.…………………………………………… log k times.. k members.

k n , so x’s rep. pointer can change at most log n times.

O(n log n) for n objects.

O(m + n log n) total.

36

Data structure for disjoint sets

• Discuss the data structures to maintain a collection of pair-wise disjoint dynamic sets.– Operations: make-set, union, find-set– Implementations: linked-lists, rooted trees– Applications: many

37

Disjoint-Set Forests

M-S, F-S: EasyUnion: As follows…

Union

Will speed up sequence of Union, M-S, and F-S operations by means of two heuristics.

x y xy

a

b d

c

representative

set is {a, b, c, d}

38

39

Heuristics to improve the running time of the rooted tree representation• Weighted-union heuristic

– union by size: make the root of the smaller tree point to the root of the larger, arbitrarily breaking a tie

– union by rank: make the root of the shallower tree point to the root of the other, arbitrarily breaking a tie

40

• Find-path compaction– path compression: make every encountered

node point to the root node– path splitting: make every encountered node

(except the last and next to last) point to its grandparent

– path halving: make every other encountered node (except the last and next to last) point to its grandparent

Heuristics to improve the running time of the rooted tree representation

41

Two heuristics used in the textbook1) Union by Rank

• Store rank of tree in rep. • Rank u.b. on height.

• Make root with smaller rank point to root with larger rank.

2) Path Compression• During Find-Set, “flatten” tree.

bc

d

a b c

dF-S(a)

a

42

OperationsMake-Set(x)

p[x] := x;rank[x] := 0

Make-Set(x)p[x] := x;rank[x] := 0

Union(x, y)Link(Find-Set(x), Find-Set(y))

Union(x, y)Link(Find-Set(x), Find-Set(y))

Link(x, y)if rank[x] > rank[y] then

p[y] := xelse

p[x] := y;if rank[x] = rank[y] then

rank[y] := rank[y] + 1

Link(x, y)if rank[x] > rank[y] then

p[y] := xelse

p[x] := y;if rank[x] = rank[y] then

rank[y] := rank[y] + 1

Find-Set(x)if x p[x] then

p[x] := Find-Set(p[x])return p[x]

Find-Set(x)if x p[x] then

p[x] := Find-Set(p[x])return p[x]

43

Find-Setc

ab

ca b

F-S(a)p[a] := F-S(b)

p[b] := F-S(c){ return c

return creturn c

44

ExampleMS(a) ; MS(b) ; ... ; MS(i) ; MS(j)

e/0

j/0

a/0

f/0

c/0

h/0

b/0

g/0

d/0

i/0

U(a,b) ; U(c,d) ; U(e,f) ; U(g,h); U(i j)

rankparent pointer

j/1

i/0

b/1

a/0

f/1

e/0

d/1

c/0

h/1

g/0

45

Example (Continued)j/1

i/0

b/1

a/0

f/1

e/0

d/1

c/0

h/1

g/0

U(a,d)

b/1

a/0

d/2

c/0

j/1

i/0

f/1

e/0

h/1

g/0

d

dd

d

46

Example (Continued)

b/1

a/0

d/2

c/0

j/1

i/0

f/1

e/0

h/1

g/0

d

dd

d

U(f,h)

j/1

i/0

b/1

a/0

d/2

c/0

d

dd

d

f/1

e/0

h/2

g/0

h

h

hh

47

Example (Continued)

U(d,h)

j/1

i/0

b/1

a/0

d/2

c/0

d

dd

d

f/1

e/0

h/2

g/0

h

h

hh

j/1

i/0

b/1

a/0

d/2

c/0

d

d d

d

f/1

e/0

h/3

g/0

h

h

h

h

48

Example (Continued)

U(e,j)

j/1

i/0

b/1

a/0

d/2

c/0

d

d d

d

f/1

e/0

h/3

g/0

h

h

h

h

j/1

i/0

b/1

a/0

d/2

c/0

d

d

dd

f/1e/0

h/3

g/0

h

h hh

49

Example (Continued)

j/1

i/0

b/1

a/0

d/2

c/0

d

d

dd

f/1e/0

h/3

g/0

h

h hh

FS(i)

j/1i/0b/1

a/0

d/2

c/0

d

d

dd

f/1e/0

h/3

g/0

h

h hh

BC

BC

BC

PC

Block 0

Block 0

Block 1

Block 2

50

Example (Continued)

FS(a)

j/1i/0b/1

a/0

d/2

c/0

d

d

dd

f/1e/0

h/3

g/0

h

h hh

j/1i/0b/1a/0 d/2

c/0

dd

d

d

f/1e/0

h/3

g/0

h

hhh

51

Time Complexity• We will cover the complexity analysis

found in CLR rather than CLRS.– Note: This was Chapter 22 in CLR, which is

why the remaining lemmas etc. are numbered the way they are.

– CLRS uses potential method (pp. 509 –517 2nd edition; pp. 573 – 581 3rd edition)CLR uses aggregate method

52

Potential function

53

Potential function

A4(1) >> 1080

54

Time Complexity

• Tight upper bound on time complexity: O(m (n)).– (n) is almost a constant.

• A slightly easier bound of O(m log*n)is established in CLR.

55

Bound we will establish

• We establish O(m log*n) as an upper bound.

• log*n = min{i 0: log(i) n 1}.

– In particular:

– And hence: log*265536 = 5.– Thus, log*n 5 for all practical purposes.

12log2

2*

kk

56

Properties of RanksLemma 22.2:

(i) (x:: rank[x] rank[p[x]]).(ii) (x: x p[x]: rank[x] < rank[p[x]]).(iii) rank[x] is initially 0.(iv) rank[x] does not decrease.(v) Once x p[x] holds, rank[x] does not change.(vi) rank[p[x]] is a monotonically increasing function of time.

Lemma 22.2:(i) (x:: rank[x] rank[p[x]]).

(ii) (x: x p[x]: rank[x] < rank[p[x]]).(iii) rank[x] is initially 0.(iv) rank[x] does not decrease.(v) Once x p[x] holds, rank[x] does not change.(vi) rank[p[x]] is a monotonically increasing function of time.

Proof:By induction on number of operations (see example Slides 42 - 48).

57

Lemma 22.3Lemma 22.3: For all tree roots x, size(x) 2rank[x].Lemma 22.3: For all tree roots x, size(x) 2rank[x].

no. of nodes in tree rooted at xProof:

Induction on number of Link operations

Basis:Before first link, all ranks are 0 and each tree contains one node.

Inductive Step:Consider Link(x,y).

Assume lemma holds before this operation.

We show it holds after.

2 cases.

58

Case 1: rank[x] rank[y]Assume rank[x] < rank[y].

Link(x,y)x y xy

rank(x)size(x)

rank(y)size(y)

rank(x)size(x)

rank(y)size(y)

Note: rank(x) = rank(x)rank(y) = rank(y)

size(y) = size(x) + size(y) 2rank(x) + 2rank(y)

2rank(y)

= 2rank(y)

No ranks or sizes change for any nodes other than y.

59

Case 2: rank[x] = rank[y]

x y xy

rank(x)size(x)

rank(y)size(y)

rank(x)size(x)

rank(y)size(y)

Note: rank(x) = rank(x)rank(y) = rank(y) + 1

size(y) = size(x) + size(y) 2rank(x) + 2rank(y)

2rank(y) + 1

= 2rank(y)

Link(x,y)

60

Lemma 22.4Lemma 22.4: For any integer r 0, there are at most n/2r nodes of rank r.Lemma 22.4: For any integer r 0, there are at most n/2r nodes of rank r.

Corollary 22.5: Every node has rank at most log n.Corollary 22.5: Every node has rank at most log n.

61

Proving the Time Bound

Lemma 22.6: Suppose we convert a sequence S of m MS, U, and FS operations into a sequence S of m MS, Link, and FS operationsby turning each Union into two FS operations followed by a Link. Then, if sequence S runs in O(m log*n) time, sequence Sruns in O(m log*n) time.

Lemma 22.6: Suppose we convert a sequence S of m MS, U, and FS operations into a sequence S of m MS, Link, and FS operationsby turning each Union into two FS operations followed by a Link. Then, if sequence S runs in O(m log*n) time, sequence Sruns in O(m log*n) time.

Only have to consider MS, Link, FS operations.

62

Theorem 22.7Theorem 22.7: A sequence of m MS, L, and FS operations, n of which are MS operations, can be performed in worst-case time O(m log*n).

Theorem 22.7: A sequence of m MS, L, and FS operations, n of which are MS operations, can be performed in worst-case time O(m log*n).

Proof: Use blackboard

63

Remarks

64

Remarks (Cont.)

65

Outline

• Review• Data structures for disjoint sets• Elementary graph algorithms

66

Outline of the course (1/1)

• Introduction (1-4)• Data structures (10-14)• Dynamic programming (15)• Greedy methods (16)• Amortized analysis (17)• Advanced data structures (6, 19-21)• Graph algorithms (22-25)• NP-completeness (34-35)• Other topics (5, 31)

67

Graph algorithms• Topics:

– Elementary graph algorithms– Minimum spanning trees– Shortest paths

• Reading:– Chapters 22, 23, 24, 25

68

Graphs

• A graph G = (V, E) consists of a set V of vertices (nodes) and a set E of directed or undirected edges.– For analysis, we use V for |V| and E for |E|.

• Any binary relation is a graph.– Network of roads and cities, circuit representation, etc.

69

Directed graphs

• A directed graph (or digraph) G is a pair (V, E), where V is a finite set and E is a binary relation on V. – The set V is called the vertex set of G, and its elements

are called vertices (singular: vertex). – The set E is called the edge set of G, and its elements

are called edges.• Vertices are represented by circles in the figure,

and edges are represented by arrows. Note that self-loops--edges from a vertex to itself--are possible.

70

Undirected graphs

• In an undirected graph G = (V, E), the edge set E consists of unordered pairs of vertices, rather than ordered pairs. That is, an edge is a set {u, v}, where u, v V and u ≠ v.

• By convention, we use the notation (u, v) for an edge, rather than the set notation {u,v}, and (u,v) and (v, u) are considered to be the same edge.

• In an undirected graph, self-loops are forbidden, and so every edge consists of exactly two distinct vertices.

71

Figure B.2 Directed and undirected graphs.

(a) A directed graph G = (V, E), where V = {1,2,3,4,5,6} and E = {(1,2), (2,2), (2,4), (2,5), (4,1), (4,5), (5,4), (6,3)}. The edge (2,2) is a self-loop.

(b) An undirected graph G = (V,E), where V = {1,2,3,4,5,6} and

E = {(1,2), (1,5), (2,5), (3,6)}. The vertex 4 is isolated.

(c) The subgraph of the graph in part (a) induced by the vertex set {1,2,3,6}.

72

Definitions

• Many definitions for directed and undirected graphs are the same, although certain terms have slightly different meanings in the two contexts.

• If (u, v) is an edge in a directed graph G = (V, E), we say that (u, v) is incident from or leaves vertexu and is incident to or enters vertex v.

• If (u, v) is an edge in an undirected graph G = (V, E), we say that (u, v) is incident on vertices u and v.

73

Examples

• The edges leaving vertex 2 in Figure B.2(a) are (2, 2), (2, 4), and (2, 5). The edges enteringvertex 2 are (1, 2) and (2, 2).

• In Figure B.2(b), the edges incident on vertex 2 are (1, 2) and (2, 5).

74

Definitions (Cont.)

• If (u, v) is an edge in a graph G = (V, E), we say that vertex v is adjacent to vertex u. – When the graph is undirected, the adjacency

relation is symmetric. – When the graph is directed, the adjacency

relation is not necessarily symmetric.

75

Example (Cont.)

• In parts (a) and (b) of Figure B.2, vertex 2 is adjacent to vertex 1, since the edge (1, 2) belongs to both graphs. Vertex 1 is not adjacent to vertex 2 in Figure B.2(a), since the edge (2, 1) does not belong to the graph.

76

Definitions (Cont.)

• The degree of a vertex in an undirected graph is the number of edges incident on it.

• In a directed graph, – the out-degree of a vertex is the number of edges

leaving it, and – the in-degree of a vertex is the number of edges

entering it.

• The degree of a vertex in a directed graph is its in-degree plus its out-degree.

77

Example (Cont.)

• Vertex 2 in Figure B.2(a) has in-degree 2, out-degree 3, and degree 5.

78

Definitions (Cont.)

• A path of length k from a vertex u to a vertex u' in a graph G = (V, E) is a sequence of vertices <V0, V1, …, Vk> such that u=V0, u’=Vk, and (Vi-1, Vi) E for i=1,2, … ,k. The length of the path is the number of edges in the path. The path contains the vertices V0, V1, …, Vk and the edges (V0, V1), (V1, V2), . . . , (Vk-1, Vk).

• If there is a path p from u to u', we say that u' is reachable from u via p, which we sometimes write as if G is directed. A path is simple if all vertices in the path are distinct.

79

Example (Cont.)

• In Figure B.2(a), the path 1, 2, 5, 4 is a simple path of length 3. The path 2, 5, 4, 5 is not simple.

80

Definitions (Cont.)

• A subpath of path p = V0, V1, . . . , Vk, is a contiguous subsequence of its vertices. – That is, for any 0 i j k, the subsequence of

vertices Vi, Vi+1, . . . , Vj, is a subpath of p.

81

Definitions (Cont.)• In a directed graph, a path v0, v1, . . . , vk forms a cycle if

v0 = vk and the path contains at least one edge. – The cycle is simple if, in addition, v1, v2, . . . , vk are distinct. – A self-loop is a cycle of length 1. – Two paths v0, v1, v2, . . . , v k - 1, v0 and v'0, v'1, v'2, . . . , v‘ k - 1, v'0

form the same cycle if there exists an integer j s. t. v'i = v (i + j) mod k for i = 0, 1, . . . , k - 1.

• A directed graph with no self-loops is simple. In an undirected graph, a path v0, vl, . . . , vk forms a cycle if v0= vk and v1, v2, . . . , vk are distinct.

• A graph with no cycles is acyclic.

82

Example (Cont.)

• In Figure B.2(a), the path 1, 2, 4, 1 forms the same cycle as the paths 2, 4, 1, 2 and 4, 1, 2, 4 . This cycle is simple, but the cycle 1, 2, 4, 5, 4, 1 is not. The cycle 2, 2 formedby the edge (2, 2) is a self-loop.

• In Figure B.2(b), the path 1, 2, 5, 1 is a cycle.

83

Definitions (Cont.)

• An undirected graph is connected if every pair of vertices is connected by a path. – The connected components of a graph are the

equivalence classes of vertices under the "is reachable from" relation.

– An undirected graph is connected if it has exactly one connected component, that is, if every vertex is reachable from every other vertex.

84

Example (Cont.)

• The graph in Figure B.2(b) has three connected components: {1, 2, 5}, {3, 6}, and {4}. Every vertex in {1,2,5} is reachable from every other vertex in {1, 2, 5}.

85

Definitions (Cont.)

• A directed graph is strongly connected if every two vertices are reachable from each other. – The strongly connected components of a graph

are the equivalence classes of vertices under the "are mutually reachable" relation.

– A directed graph is strongly connected if it has only one strongly connected component.

86

Example (Cont.)

• The graph in Figure B.2(a) has three strongly connected components: {1, 2, 4, 5}, {3}, and {6}. All pairs of vertices in {1, 2, 4, 5} are mutually reachable. The vertices {3, 6} do not form a strongly connected component, since vertex 6 cannot be reached from vertex 3.

87

Definitions (Cont.)

• Two graphs G = (V, E) and G' = (V', E') are isomorphic if there exists a bijection f : V V' such that (u, v) E if and only if (f(u), f(v)) E'. – In other words, we can relabel the vertices of G

to be vertices of G', maintaining the corresponding edges in G and G'.

88

Example (Cont.)• Figure B.3(a) shows a pair of

isomorphic graphs G and G'with respective vertex sets V= {1, 2, 3, 4, 5, 6} and V' = {u, v, w, x, y, z}. The mapping from V to V' given by f(1) = u, f(2) = v, f(3) = w, f(4) = x, f(5) = y, f(6) = z is the required bijectivefunction.

• The graphs in Figure B.3(b) are not isomorphic. Although both graphs have 5 vertices and 7 edges, the top graph has a vertex of degree 4 and the bottom graph does not.

89

Definitions (Cont.)

• We say that a graph G' = (V', E') is a subgraph of G = (V,E) if V' V and E' E. Given a set V' V, the subgraph of G induced by V' is the graph G' = (V', E'), where E' = {(u, v) E: u, v V'} .

90

Example (Cont.)

• The subgraph induced by the vertex set {1, 2, 3, 6} in Figure B.2(a) appears in Figure B.2 (c) and has the edge set {(1, 2), (2, 2), (6, 3)}.

91

Definitions (Cont.)• Given an undirected graph G = (V, E), the directed version

of G is the directed graph G' = (V, E'), where (u, v) E' if and only if (u, v) E. – That is, each undirected edge (u, v) in G is replaced in the directed

version by the two directed edges (u, v) and (v, u). • Given a directed graph G =(V, E), the undirected version of

G is the undirected graph G' = (V, E'), where (u, v) E' if and only if u v and (u, v) E. – That is, the undirected version contains the edges of G "with their

directions removed" and with self-loops eliminated. • In a directed graph G = (V, E), a neighbor of a vertex u is

any vertex that is adjacent to u in the undirected version of G. That is, v is a neighbor of u if either (u, v) E or (v, u) E. In an undirected graph, u and v are neighbors if they are adjacent.

92

Definitions (Cont.)

• Several kinds of graphs are given special names. – A complete graph is an undirected graph in which

every pair of vertices is adjacent. – A bipartite graph is an undirected graph G = (V, E) in

which V can be partitioned into two sets V1 and V2 such that (u, v) E implies either u V1 and v V2 or u V2 and v V1. That is, all edges go between the two sets V1and V2.

– An acyclic, undirected graph is a forest, and a connected, acyclic, undirected graph is a (free) tree.We often take the first letters of "directed acyclic graph" and call such a graph a dag.

93

Definitions (Cont.)

• The contraction of an undirected graph G = (V, E) by an edge e=(u,v) is a graphG’=(V’,E’), where– V’= V - {u,v} U {x} and x is a new vertex. – The set of edges E’ is formed from E by

deleting the edge (u,v) and, for each vertex w incident to u or v, deleting whichever of (u,w) and (v,w) in E and adding the new edge (x,w).

94

Representations of Graphs: Adjacency List

• Adjacency list: An array Adj of |V | lists, one for each vertex in V. For each u V, Adj[u] pointers to all the vertices adjacent to u.

• Advantage: O(V+E) storage, good for sparse graph.• Drawback: Need to traverse list to find an edge.

95

Representations of Graphs: Adjacency Matrix• Adjacency matrix: A |V| |V| matrix A = (aij) such that

• Advantage: O(1) time to find an edge.• Drawback: O(V2) storage, more suitable for dense graph.• Q: How to save space if the graph is undirected?

96

Tradeoffs between Adjacency List and Matrix

97

Questions?