Create Presentation
Download Presentation

Download Presentation
## Advanced Dynamic Programming II

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -

**Advanced Dynamic Programming II**HKOI Training Team 2004**In the previous lesson...**• What is DP? • Some examples of DP • Probably NOT enough for you to solve DP problems in IOI/NOI • Except those classic ones • To identify a DP problem, the keys are • Recurrence • Optimal substructure • Experience (Chinglish(?) - “DP feel”)**In this lesson...**• Dimension reduction • DP on trees, graphs, etc. • Game strategy - Minimax**Dimension Reduction**• Reduce the memory complexity by one (or more) dimension • Usually a “rolling” array is employed**Triangle revisited**• Only a 2x5 array is needed A F**Rolling array**F’ F**LCS revisited**• Recall the recurrence • F[i,j] = F[i-1,j-1]+1 if A[i]=B[j] • F[i,j] = max{F[i-1,j],F[i,j-1]} if A[i]B[j] • Note that F[i,?] only depends on F[i,?] and F[i-1,?] • Thus we can just keep 2 rows**Non-rectangular structures**• DP can also be applied on graphs, trees, etc. • Usually structures with no cycles • Recurrence should not contain cycles! • Rooted tree is a recursive structure • Notation • C(v): the set of children of v (in a rooted tree)**Path Counting**• A graph is a directed acyclic graph (DAG) if it is directed and has no cycles This is not a DAG. This is a DAG.**Path Counting**• Given a DAG G, and two vertices of G, s and t, count the number of distinct paths from s to t • What if I give you a graph with directed cycles? • How is the graph given to you? • Adjacency matrix • Adjacency list • Other ways**B**A D C E F Path (example) • s = A, t = E • Paths: • ABDE, ACBDE, ACDE • Answer = 3**s**t Path (an attempt) • Use DFS to find out all paths from s to t • Simple enough, but consider this graph • How many paths from s to t? • 24= 16**Path (solution)**• Obviously the three paths shown below must be distinct • Even if they meet at some intermediate vertices! s C B A ... ... ... t**Path (solution)**• Topological order 7 s 6 5 t 2 3 4 1**Path (solution)**• Number of paths from vertex to t 3 7 s 6 2 1 5 t 1 2 3 4 1 0 1 0**recurrence**relation Path (solution) • Algorithm • Tsort the vertices Set F[v] = 0 for every vertex v Set F[t] = 1 Following topological order, for each vertex v For each outgoing edge (v, u) F[v] = F[v] + F[u] • Time complexity • Tsort – O(V+E) • DP – O(V+E) • Total – O(V+E)**Path (extensions)**• Longest path in DAG • Given a weighted DAG G, find the length of a longest path from s to t • Shortest path counting • Given a weighted graph G, find the number of shortest paths from s to t**Longest Path in Tree I**• Given a weighted tree T, find the length of the longest path from a given node s s 5 7 4 5 6 3**Longest I (simple solution)**• Make s the root s 5 7 5 6 4 3**Longest I (simple solution)**• Calculate the nodes’ distances from s (in pre-order/level-order) 0 s 5 5 7 5 6 10 12 11 4 3 14 13**Longest I (another solution)**• A longest path must end at one of the leaves s 5 7 5 6 4 3**Longest I (another solution)**• Let F[v] be the longest distance between v to one of its descendant leaves • For example, F[x] = 9 s x 5 7 5 6 4 3**Longest I (another solution)**• Compute F in post-order • F[x] = 0 for every leaf x • F[v] = max {F[u]+length(v,u)} u C(v) s 14 answer 5 9 7 5 6 4 0 0 4 3 0 0**Longest I (another solution)**• Algorithm • Longest_One(vertex v) { if (v is a leaf) F[v] 0 else F[v] 0 for each child u of v do Longest_One(u) if (F[u]+length(v,u) F[v] F[u]+length(v,u) }**Longest I (another solution)**• Time complexity – O(V) • No overlapping subproblems • F[] is redundant!**Longest Path in Tree II**• Given a weighted tree T (all weights positive), find the length of the longest path in T 5 7 4 5 6 3**7**4 5 5 5 3 6 5 7 6 4 3 Longest II (solution) • Take any node and make it root**7**4 5 5 5 3 6 5 7 6 4 3 Longest II (solution) • A longest path must be a leaf-to-leaf or a root-to-leaf path • Must it pass the root?**z**z Longest II (solution) • Let z be the uppermost node in the longest path • Only two cases the only common node is z**Longest II (solution)**• As in Longest I, let F[v] be the longest distance between v to one of its descendant leaves • Define G as follows • G[v] = F[v] if v has less than 2 children • G[v] = max{F[u]+length(v,u)} + second_max {F[w]+length(v,w)} • Note that max may equal second_max u C(v) w C(v)**4**5 3 5 7 6 Longest II (demonstration) • Computing G from F 12 (7+5)+(0+4) = 16 7 (0+7)+(0+6) = 13 0 0 0 0 0 0 0 0 0 0**5**7 5 6 4 3 Longest II (demonstration) • Computing G from F (again) 14 14 9 (4+5)+(0+7) = 16 4 (0+4)+(0+3) = 7 0 0 0 0 0 0 0 0**Longest II (solution)**• Time complexity • Computing F – O(V) • Computing G – O(V) • Total – O(V) • F and G can be computed together • Not quite a DP problem**Simplified Gems**• Given a tree T with N nodes • Each node is to be covered by a gemstone • Costs of gemstones: 1, 2, 3, …, M • There is an unlimited supply of gemstones • Two adjacent nodes must contain gemstones of different costs • What is the minimum total cost?**2**1 1 1 3 1 1 1 Gems (example) • N = 8, M = 4**Gems (attempt)**• Make the tree a rooted one first**Gems (attempt)**• Let G[v] be the minimum cost to cover all nodes in the subtree rooted at v • How to set up the recurrence?**Gems (solution)**• Let F[v,c] be the minimum cost to cover all nodes in the subtree rooted at v and the cost of the gemstone covering v is c • Base cases • F[x,c] = c for every leaf x and 1 c M • Progress • F[v,c] = min {F[u,d]} + c • Post-order traversal u C(v) 1dM,dc**Gems (demostration)**• M = 4**Gems (solution)**• Algorithm (recursive, non-DP) • Gems(vertex v,integer c) { if (v is leaf) return c valuec for each child u of v do temp ∞ for d 1 to M do if (d c) temp min{temp, Gems(u,d)} value value + temp return value }**Gems (solution)**• Algorithm (DP) • Gems_DP(vertex v) { if (v is a leaf) set base case and exit for each child u of v do Gems_DP(u) for c 1 to M do F[v,c] c for each child u of v do temp ∞ for d 1 to M do if (d c) temp min{temp, F[u,d]} F[v,c] temp + c }**Gems (solution)**• Time complexity • Computing F[v,c] – O(M × #children of v) • Computing F[v,c] for all vertices – O(MN) • Computing all entries – (M2N) • The time complexity can be reduced to O(MN) with a “trick” • The original problem allows N to be as large as 10000 and M arbitrarily large • Even O(N2) is too slow • How to solve it??**Game strategies**• Not closely related to DP • Almost all game-type problems in IOI/BOI/CEOI requires the concept of Minimax • DP is needed in most of these problems**Game-type problems**• Usually interactive problems • Write a program to play a simple two-player game with a judging program • e.g. play tic-tac-toe with the judging program • Often the judging program uses an optimal strategy**Game tree**• A (finite or infinite) rooted tree showing the movements of a game play … … … … … … … …**Card Picking**• A stack of N cards with numbers on them • Two players take turns to take cards from the top of the stack • 1, 2, or 3 cards can be taken in each turn • Game ends when all cards have been taken • The player with a higher total score (sum of numbers) wins**Card (example)**B A 2 1 9 7 1 4 3 17 14 4**Card (game tree)**• N = 4 • Only 5 different states A’s move B’s move NULL NULL NULL NULL NULL NULL NULL**Minimax**• A recursive algorithm for choosing the next move in a two-player game • A value is associated with each state • e.g. in tic-tac-toe, all winning states may have value 1 • We assume that the other player always chooses his best move**A’s moves**B’s moves 1 -1 4 3 2 1 7 -2 Minimax • Suppose A wants to maximize his final score (value), which move should he make? 1 max -1 1 -2 min min min