Scribd
Upload
123 views

18 Shortest Paths II

The document discusses the Bellman-Ford algorithm for finding shortest paths in a graph. It begins with an overview of negative-weight cycles and how they can prevent shortest paths from existing. It then describes the Bellman-Ford algorithm, providing pseudocode and running through a full example on a graph. It proves the correctness of Bellman-Ford and discusses how it can be used to solve systems of difference constraints, such as for VLSI layout compaction.

Uploaded by

Tanmay Baranwal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
123 views

18 Shortest Paths II

The document discusses the Bellman-Ford algorithm for finding shortest paths in a graph. It begins with an overview of negative-weight cycles and how they can prevent shortest paths from existing. It then describes the Bellman-Ford algorithm, providing pseudocode and running through a full example on a graph. It proves the correctness of Bellman-Ford and discusses how it can be used to solve systems of difference constraints, such as for VLSI layout compaction.

Uploaded by

Tanmay Baranwal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 45

Algorithms

LECTURE 18
Shortest Paths II Bellman-Ford algorithm Linear programming and difference constraints VLSI layout compaction

Professor Ashok Subramanian


Algorithms L18.1

Negative-weight cycles
Recall: If a graph G = (V, E) contains a negativeweight cycle, then some shortest paths may not exist. Example: <0

Algorithms

L18.2

Negative-weight cycles
Recall: If a graph G = (V, E) contains a negativeweight cycle, then some shortest paths may not exist. Example: <0

Bellman-Ford algorithm: Finds all shortest-path lengths from a source s V to all v V or determines that a negative-weight cycle exists.
Algorithms L18.3

Bellman-Ford algorithm
d[s] 0 for each v V {s} do d[v]

initialization

for i 1 to | V | 1 do for each edge (u, v) E do if d[v] > d[u] + w(u, v) relaxation then d[v] d[u] + w(u, v) step for each edge (u, v) E do if d[v] > d[u] + w(u, v) then report that a negative-weight cycle exists At the end, d[v] = d(s, v), if no negative-weight cycles. Time = O(V E).
Algorithms L18.4

Example of Bellman-Ford
B
3 4 1 2 3

Algorithms

L18.5

Example of Bellman-Ford
B
3 4 1 2 3

Initialization.
Algorithms L18.6

Example of Bellman-Ford
B
7 3 1

2
8

1
2
6

2 3

Order of edge relaxation.


Algorithms L18.7

Example of Bellman-Ford
B
7 3 1

2
8

1
2
6

2 3

Algorithms

L18.8

Example of Bellman-Ford
B
7 3 1

2
8

1
2
6

2 3

Algorithms

L18.9

Example of Bellman-Ford
B
7 3 1

2
8

1
2
6

2 3

Algorithms

L18.10

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

Algorithms

L18.11

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 4

Algorithms

L18.12

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 4

Algorithms

L18.13

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2 4

Algorithms

L18.14

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

Algorithms

L18.15

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

End of pass 1.
Algorithms L18.16

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

Algorithms

L18.17

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

Algorithms

L18.18

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D 1

Algorithms

L18.19

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D 1

Algorithms

L18.20

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D 1

Algorithms

L18.21

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D 1

Algorithms

L18.22

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D 1

Algorithms

L18.23

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D -2 1

Algorithms

L18.24

Example of Bellman-Ford
-1 B
7 3 1

2
8

1
2
6

2 3

C 2

D -2

End of pass 2 (and 3 and 4).


Algorithms L18.25

Correctness
Theorem. If G = (V, E) contains no negativeweight cycles, then after the Bellman-Ford algorithm executes, d[v] = d(s, v) for all v V.

Algorithms

L18.26

Correctness
Theorem. If G = (V, E) contains no negativeweight cycles, then after the Bellman-Ford algorithm executes, d[v] = d(s, v) for all v V.
Proof. Let v V be any vertex, and consider a shortest path p from s to v with the minimum number of edges.

s p : v0

v
1

v
v
2 3

v v
k

Since p is a shortest path, we have d(s, vi) = d(s, vi1) + w(vi1, vi) .
Algorithms L18.27

Correctness (continued)
s p : v0

v
1

v v
2 3

v v
k

Initially, d[v0] = 0 = d(s, v0), and d[v0] is unchanged by subsequent relaxations (because of the lemma from Lecture 14 that d[v] d(s, v)). After 1 pass through E, we have d[v1] = d(s, v1). After 2 passes through E, we have d[v2] = d(s, v2). M After k passes through E, we have d[vk] = d(s, vk). Since G contains no negative-weight cycles, p is simple. Longest simple path has | V | 1 edges.
Algorithms L18.28

Detection of negative-weight cycles


Corollary. If a value d[v] fails to converge after | V | 1 passes, there exists a negative-weight cycle in G reachable from s.

Algorithms

L18.29

Linear programming
Let A be an mn matrix, b be an m-vector, and c be an n-vector. Find an n-vector x that maximizes cTx subject to Ax b, or determine that no such solution exists. n m .

x b

maximizing
cT
Algorithms

x
L18.30

Linear-programming algorithms
Algorithms for the general problem Simplex methods practical, but worst-case exponential time. Interior-point methods polynomial time and competes with simplex.

Algorithms

L18.31

Linear-programming algorithms
Algorithms for the general problem Simplex methods practical, but worst-case exponential time. Interior-point methods polynomial time and competes with simplex. Feasibility problem: No optimization criterion. Just find x such that Ax b. In general, just as hard as ordinary LP.
Algorithms L18.32

Solving a system of difference constraints


Linear programming where each row of A contains exactly one 1, one 1, and the rest 0s. Example: x1 x2 3 xj xi wij x2 x3 2 x1 x3 2

Algorithms

L18.33

Solving a system of difference constraints


Linear programming where each row of A contains exactly one 1, one 1, and the rest 0s. Example: Solution: x1 = 3 x1 x2 3 x2 = 0 xj xi wij x2 x3 2 x3 = 2 x1 x3 2

Algorithms

L18.34

Solving a system of difference constraints


Linear programming where each row of A contains exactly one 1, one 1, and the rest 0s. Example: Solution: x1 = 3 x1 x2 3 x2 = 0 xj xi wij x2 x3 2 x3 = 2 x1 x3 2 Constraint graph: wij
Algorithms

xj xi wij

vi

vj

(The A matrix has dimensions |E | |V |.)


L18.35

Unsatisfiable constraints
Theorem. If the constraint graph contains a negative-weight cycle, then the system of differences is unsatisfiable.

Algorithms

L18.36

Unsatisfiable constraints
Theorem. If the constraint graph contains a negative-weight cycle, then the system of differences is unsatisfiable.
Proof. Suppose that the negative-weight cycle is v1 v2 L vk v1. Then, we have x2 x1 x3 x2 w12 w23
M

xk xk1 wk1, k x1 xk wk1

Algorithms

L18.37

Unsatisfiable constraints
Theorem. If the constraint graph contains a negative-weight cycle, then the system of differences is unsatisfiable.
Proof. Suppose that the negative-weight cycle is v1 v2 L vk v1. Then, we have x2 x1 x3 x2 w12 w23
M

xk xk1 wk1, k x1 xk wk1 0 weight of cycle <0


Algorithms

Therefore, no values for the xi can satisfy the constraints.


L18.38

Satisfying the constraints


Theorem. Suppose no negative-weight cycle exists in the constraint graph. Then, the constraints are satisfiable.

Algorithms

L18.39

Satisfying the constraints


Theorem. Suppose no negative-weight cycle exists in the constraint graph. Then, the constraints are satisfiable.
Proof. Add a new vertex s to V with a 0-weight edge to each vertex vi V.

v
1

v
4

v
3
Algorithms L18.40

v
7

Satisfying the constraints


Theorem. Suppose no negative-weight cycle exists in the constraint graph. Then, the constraints are satisfiable.
Proof. Add a new vertex s to V with a 0-weight edge to each vertex vi V.

0 s

v
1

v
4

v
3
Algorithms

Note: No negative-weight cycles introduced shortest paths exist.

v
7

L18.41

Proof (continued)
Claim: The assignment xi = d(s, vi) solves the constraints. Consider any constraint xj xi wij, and consider the shortest paths from s to vj and vi:

d(s, vi) d(s, vj)

vi
wij

vj
The triangle inequality gives us d(s,vj) d(s, vi) + wij. Since xi = d(s, vi) and xj = d(s, vj), the constraint xj xi wij is satisfied.
Algorithms L18.42

Bellman-Ford and linear programming


Corollary. The Bellman-Ford algorithm can solve a system of m difference constraints on n variables in O(m n) time. Single-source shortest paths is a simple LP problem. In fact, Bellman-Ford maximizes x1 + x2 + L + xn subject to the constraints xj xi wij and xi 0 (exercise). Bellman-Ford also minimizes maxi{xi} mini{xi} (exercise).
Algorithms L18.43

Application to VLSI layout compaction


Integrated -circuit features: minimum separation l Problem: Compact (in one dimension) the space between the features of a VLSI layout without bringing any features too close together.
Algorithms L18.44

VLSI layout compaction


d1 1 2

x1

x2

Constraint: x2 x1 d1 + l Bellman-Ford minimizes maxi{xi} mini{xi}, which compacts the layout in the x-dimension.
Algorithms L18.45

You might also like