Algorithms Dynamic Programming

Dynamic Programming II

Design and Analysis of Algorithms Andrei Bulatov

Algorithms Dynamic Programming

7-2

Shortest Path
Suppose that every arc e of a digraph G has length (or cost, or weight, or ) len(e) But now we allow negative lengths (weights) Then we can naturally define the length of a directed path in G, and the distance between any two nodes The s-t-Shortest Path Problem Instance: Digraph G with lengths of arcs, and nodes s,t Objective: Find a shortest path between s and t

Algorithms Dynamic Programming

7-3

Shortest Path: Difficulties

Negative Cycles.
s

<0
t

Greediness fails 2
s

-6 1
t

Adding constant weight to all arcs fails

Algorithms Dynamic Programming

7-4

Shortest Path: Observations

Assumption There are no negative cycles Lemma If graph G has no negative cycles, then there is a shortest path from s to t that is simple (i.e. does not repeat nodes), and hence has at most n 1 arcs Proof If a shortest path P from s to t repeat a node v, then it also include a cycle C starting and ending at v. The weight of the cycle is non-negative, therefore removing the cycle makes the path shorter (no longer). QED

Algorithms Dynamic Programming

7-5

Shortest Path: Dynamic Programming

We will be looking for a shortest path with increasing number of arcs Let OPT(i,v) denote the minimum weight of a path from v to t using at most i arcs
w v t

Shortest v t path can use i 1 arcs. Then OPT(i,v) = OPT(i 1,v) Or it can use i arcs and the first arc is vw. Then OPT(i,v) = len(vw) + OPT(i 1,w) OPT (i, v) = min{OPT (i 1, v), min{OPT (i 1, w) + len(vw)}}
wV

Algorithms Dynamic Programming

7-6

Shortest Path: Bellman-Ford Algorithm

Shortest-Path(G,s,t)
set n:=|V| /*number of nodes in G array M[0..n-1,V] set M[0,t]:=0 and M[0,v]:= for each vV-{t} for i=1 to n-1 do for vV do set M[i,v]:=min{M[i-1,v],minwV {M[i-1,w]+len(vw)}} endfor endfor return M[n-1,s]

Algorithms Dynamic Programming

7-7

Example
a

6 -1
d

-3 4
v e t a b c d

-4
b

0
0

1
0 -3 3 4 2

2
0 -3 0 3 3 0

3
0 -4 -2 3 3 0

4
0 -6 -2 3 2 0

5
0 -6 -2 3 0 0

-2 2 -3

8
c

M[i,v] = min{ M[i 1, v], minw V { M[ i 1, w] + len(vw) }}

Algorithms Dynamic Programming

7-8

Shortest Path: Soundness and Running Time

Theorem The ShortestPath algorithm correctly computes the minimum cost of an s-t path in any graph that has no negative cycles, and runs in O( n3) time

Proof. Soundness follows by induction from the recurrent relation for the optimal value. DIY. Running time: 2 We fill up a table with n entries. Each of them requires O(n) time

Algorithms Dynamic Programming

7-9

Shortest Path: Soundness and Running Time

Theorem The ShortestPath algorithm can be implemented in O(mn) time

A big improvement for sparse graphs Proof. Consider the computation of the array entry M[i,v]: M[i,v] = min{ M[i 1, v], minw V { M[ i 1, w] + len(vw) }} We need only compute the minimum over all nodes w for which v has an edge to w Let nv denote the number of such edges

Algorithms Dynamic Programming

7-10

Shortest Path: Running Time Improvements

It takes O( nv ) to compute the array entry M[i,v]. It needs to be computed for every node v and for each i, 1 i n. Thus the bound for running time is O n nv = O (nm) vV Indeed, nv is the outdegree of v, and we have the result by the Handshaking Lemma. QED

Algorithms Dynamic Programming

7-11

Shortest Path: Space Improvements

The straightforward implementation requires storing a table with entries It can be reduced to O(n) Instead of recording M[i,v] for each i, we use and update a single value M[v] for each node v, the length of the shortest path from v to t found so far Thus we use the following recurrent relation: M[v] = min{ M[v], minw V { M[ w] + len(vw) }}

Algorithms Dynamic Programming

7-12

Shortest Path: Space Improvements (cntd)

Lemma Throughout the algorithm M[v] is the length of some path from v to t, and after i rounds of updates the value M[v] is no larger than the length of the shortest from v to t using at most i edges

Algorithms Dynamic Programming

7-13

Shortest Path: Finding Shortest Path

In the standard version we only need to keep record on how the optimum is achieved Consider the space saving version. For each node v store the first node on its path to the destination t Denote it by first(v) Update it every time M[v] is updated Let P be the pointer graph P = (V, {(v, first(v)): vV})

Algorithms Dynamic Programming

7-14

Shortest Path: Finding Shortest Path

Lemma If the pointer graph P contains a cycle C, then this cycle must have negative cost. Proof If w = first(v) at any time, then M[v] M[w] + len(vw) Let v1, v2 ,K, vk be the nodes along the cycle C, and (vk , v1 ) the last arc to be added Consider the values right before this arc is added We have M [vi ] M [vi +1 ] + len(vi vi +1 ) for i = 1,, k 1 and M [vk ] > M [v1 ] + len(vk v1 ) Adding up all the inequalities we get

0>

k 1 i =1

len(vi vi +1) + len(vk v1)

Algorithms Dynamic Programming

7-15

Shortest Path: Finding Shortest Path (cntd)

Lemma Suppose G has no negative cycles, and let P be the pointer graph after termination of the algorithm. For each node v, the path in P from v to t is a shortest v-t path in G. Proof Observe that P is a tree. Since the algorithm terminates we have M[v] = M[w] + len(vw), where w = first(v). As M[t] = 0, the length of the path traced out by the pointer graph is exactly M[v], which is the shortest path distance. QED

Algorithms Dynamic Programming

7-16

Shortest Path: Finding Negative Cycles

Two questions: - how to decide if there is a negative cycle? - how to find one? Lemma It suffices to find negative cycles C such that t can be reached from C

<0 <0
t

Algorithms Dynamic Programming

7-17

Shortest Path: Finding Negative Cycles

Proof Let G be a graph The augmented graph, A(G), is obtained by adding a new node and connecting every node in G with the new node
t

As is easily seen, G contains a negative cycle if and only if A(G) contains a negative cycle C such that t is reachable from C QED

Algorithms Dynamic Programming

7-18

Shortest Path: Finding Negative Cycles (cntd)

Extend OPT(i,v) to i n If the graph G does not contain negative cycles then OPT(i,v) = OPT(n 1,v) for all nodes v and all i n Indeed, it follows from the observation that every shortest path contains at most n 1 arcs. Lemma There is no negative cycle with a path to t if and only if OPT(n,v) = OPT(n 1,v) Proof If there is no negative cycle, then OPT(n,v) = OPT(n 1,v) for all nodes v by the observation above

Algorithms Dynamic Programming

7-19

Shortest Path: Finding Negative Cycles (cntd)

Proof (cntd) Suppose OPT(n,v) = OPT(n 1,v) for all nodes v. Therefore OPT(n,v) = min{ OPT(n 1,v), min w V { OPT(n 1,w) + len(vw) }} = min{ OPT(n,v), min w V { OPT(n,w) + len(vw) }} = OPT(n + 1,v) = . However, if a negative cycle from which t is reachable exists, then lim OPT (i, v) =
i

Algorithms Dynamic Programming

7-20

Shortest Path: Finding Negative Cycles (cntd)

Let v be a node such that OPT(n,v) OPT(n 1,v). A path P from v to t of weight OPT(n,v) must use exactly n arcs Any simple path can have at most n 1 arcs, therefore P contains a cycle C Lemma If G has n nodes and OPT(n,v) OPT(n 1,v), then a path P of weight OPT(n,v) contains a cycle C, and C is negative. Proof Every path from v to t using less than n arcs has greater weight. Let w be a node that occurs in P more than once. Let C be the cycle between the two occurrences of w Deleting C we get a shorter path of greater weight, thus C is negative

Algorithms Dynamic Programming

7-21

The Sequence Alignment Problem

Question: How similar two words are? Say ocurrance and occurrence They are similar, because one can be turned into another by few changes oc-urrance mismatch gap occurrence Clearly, this can be done in many ways, say oc-urr- ance occurre-nce Problem: Minimize the number of gaps and mismatches

Algorithms Dynamic Programming

7-22

Alignments
Let X = x1, x2 ,K, xm and Y = y1 , y2 ,K, yn be two strings A matching is a set of ordered pairs, such that an element of each set occurs at most once. A matching is an alignment if there no crossing pairs: if (i,j) and (i,j) are in the matching and i < i then j < j o o o o c c c c c c u u u u r r r r r r a r a r n e n e c n c n e c e c e e

Algorithms Dynamic Programming

7-23

The Problem
Let M be an alignment between X and Y. Each position of X or Y that is not matched in M is called a gap. Each pair (i,j) M such that xi y j is called a mismatch The cost of M is given as follows: - There is > 0, a gap penalty. For each gap in M we incur a cost of - For each pair of letters p,q in the alphabet, there is a mismatch cost pq . For each (i,j) M we pay the mismatch cost xi y j . Usually, pp = 0. - The cost of M is the sum its gap penalties and mismatch costs

Algorithms Dynamic Programming

7-24

The Problem (cntd)

The Sequence Alignment Problem Instance: Sequences X and Y Objective: Find an alignment between X and Y of minimal cost.

Algorithms Dynamic Programming

7-25

Dynamic Programming Approach

Lemma Let M be any alignment of X and Y. If (m,n) M, the either the m-th position of X or the n-th position of Y is not matched in M. Proof Suppose that (m,n) M, and there are numbers i < m and j < n such that (m,j), (i,n) M. However, this is a crossing pair. QED

Algorithms Dynamic Programming

7-26

The Idea
Corollary In an optimal alignment M, at least one of the following is true (i) (m,n) M; or (ii) the m-th position of X is not matched; or (iii) the n-th position of Y is not matched. Let OPT(i,j) denote the minimum cost of an alignment between To get OPT(m,n) we (i) pay xm yn and then align x1, x2 ,K, xm1 and y1 , y2 ,K, yn1 as well as possible, to get OPT (m, n) = OPT (m 1, n 1) + xm yn

Algorithms Dynamic Programming

7-27

The Idea (cntd)

(ii) pay a gap cost of since the m-th position of X is not matched, and then align x1, x2 ,K, xm1 and y1 , y2 ,K, yn1 as well as possible, to get OPT (m, n) = OPT (m 1, n) + (iii) pay a gap cost to get OPT (m, n) = OPT (m, n 1) + Lemma. The minimum alignment cost satisfy the following recurrence OPT (i, j ) = min{OPT (i 1, j 1) + xi y j , OPT (i 1, j ) + ,
OPT (i, j 1) + } Moreover, (i,j) is in an optimal assignment for this subproblem if and

only if the minimum is achieved by the first of these values.

Algorithms Dynamic Programming

7-28

Alignment: Algorithm
Alignment(X,Y)
array M[0..m,0..n] set M[i,0]:=i for each i set M[0,j]:=j for each j for i=1 to m do for j=1 to n do set M[i,j]:=min{M[i-1,j-1]+ M[i,j-1]+} endfor endfor return M[m,n]

, M[i-1,j]+,