1 / 45

Dynamic Programming II

HKOI2008 Training (Advanced Group) Choi Sin Man, Kelly. Dynamic Programming II. (Powerpoint of Dynamic Programming II, HKOI Training 2005, by Liu Chi Man, cx). Review. Recurrence relation Dynamic programming State & Recurrence Formula Optimal substructure Overlapping subproblems. Outline.

magee-dixon
Download Presentation

Dynamic Programming II

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. HKOI2008 Training (Advanced Group) Choi Sin Man, Kelly Dynamic Programming II (Powerpoint of Dynamic Programming II, HKOI Training 2005, by Liu Chi Man, cx)

  2. Review • Recurrence relation • Dynamic programming • State & Recurrence Formula • Optimal substructure • Overlapping subproblems

  3. Outline • Dimension reduction (memory) • “Ugly” optimal value functions • DP on tree structures • Two-person games

  4. Dimension reduction • Reduce the space complexity by one or more dimensions • “Rolling” array • Recall: Longest Common Subsequence (LCS) • Base conditions and recurrence relation: • Fi,0 = 0 for all i • F0,j = 0 for all j • Fi,j = Fi-1,j-1 + 1 (if A[i] = B[j]) max{ Fi-1,j , Fi,j-1 } (otherwise)

  5. 0 0 0 0 0 0 0 0 1 2 3 4 5 6 0 1 2 3 4 5 6 0 0 0 0 0 0 0 0 0 1 0 0 2 0 3 0 4 0 Dimension Reduction • A: stxc, B: sicxtc 4 2 1 1 1 1 1 2 1 2 2 2 2 3 1 1 1 1 1 1 1 3 1 1 1 1 1 1 1 2 1 2 1 2 1 1 1 1 2 2 1 1 1 2 2 2 1 1 2 2 2 3

  6. Dimension Reduction • We may discard old table entries if they are no longer needed • Instead of “rolling” the rows, we may “roll” the columns • Even less memory (52 entries) • Space complexity: (min{N, M}) • Drawback • Backtracking is difficult • That means we can get the number but not the sequence easily

  7. Packing 8 cross pieces onto a 10  6 grid (Simplified) Cannoneer Base • How many non-overlapping cross pieces can be put onto a HW grid? • W ≤ 10, H is arbitrary • A cross piece: • There may be patterns, but we just focus on a DP solution

  8. ? k -2 k -1 k (Simplified) Cannoneer Base • We place the pieces from top to bottom • Phase k - putting all pieces centered on row k-1 • In phase k, we only need to consider the occupied squares in rows k-2 and k-1 Phase 3 Phase 4 Phase 5 Phase 6 Phase 7 Phase 8 Phase 9 Phase 10

  9. (Simplified) Cannoneer Base • The optimal value function C is defined by: • C(k,S) = the max number of pieces after phase k, with rows k-1 and k giving the shape S • How to represent a shape? • In a shape, each column can be • Use 2, 1, 0 to represent these 3 cases • A shape is a W-digit base-3 integer • For example, the following shape is encoded as 010121(3) = 97(10)

  10. (Simplified) Cannoneer Base • The recurrence relation is easy to construct • Max possible number of states = H  3W • That’s why W ≤ 10 • Cannoneer Base appeared in NOI2001 • Bugs Integrated, Inc. in CEOI2002 requires similar techniques

  11. Dynamic Programming on Tree Structures • States may be (related to) nodes on a graph • Usually directed acyclic graphs • Topological order is the obvious order of recurrence evaluation • Trees are special graphs • A lot of graph DP problems are based on trees • Two major types: • Rooted tree DP • Unrooted tree DP

  12. Rooted Tree Dynamic Programming • Base conditions at the leaves • Recurrence at a node involves its child nodes only • Solution • Evaluate the recurrence relation from leaves (bottom) to the root (top) • Top-down implementations work well • Time complexity is often (N) where N is the number of nodes

  13. Unrooted Tree Dynamic Programming • No explicit roots given • Two cases • The problem can be transformed to a rooted one • It can’t, so we try root every node • Case 2 increases the time complexity by a factor of N • Sometimes it is possible to root one node in O(N) time and each subsequent node in O(1) • overall O(N) time

  14. Node Heights • Given a rooted tree T • The height of a node v in T is the maximum distance between v and a descendant of v • For example, all leaves have height = 0 • Find the heights of all nodes in T • Notations • C(v) = the set of children of v • p(v) = the parent of v

  15. Node Heights • Optimal value function • H(v) = height of node v • Base conditions • H(u) = 0 for all leaves u • Recurrence • H(v) = max { H(x) | x C(v) } + 1 • Order of evaluation • All children must be evaluated before self • Post-order

  16. Node Heights • Example A H(A) = 3 B C H(C) = 1 H(B) = 2 H(D) = 1 D E F G H H(E) = 0 H(F) = 0 H(G) = 0 H(H) = 0 I H(I) = 0

  17. Node Heights • Time complexity analysis • Naively • There are N nodes • A node may have up to N-1 children • Overall time complexity = O(N2) • A better bound • The H-value of a v is at most used by one other node – p(v) • The total number of H-values inside the “max {}”s = N-1 • Overall time complexity = (N)

  18. Treasure Hunt • N treasures are hidden at the N nodes of a tree (unrooted) • The treasure at node u has value v(u) • You may not take away two treasures joined by an edge, otherwise missiles will fly to you • Find the maximum value you can take away

  19. Treasure Hunt • Let’s see if the problem can be transformed to a rooted one • We arbitrarily root a node, say r • How to formulate?

  20. Treasure Hunt • Optimal value function • Z(u,b) = max value for the subtree rooted at u and it is b that the treasure at u is taken away • b = true or false • Base conditions • Z(x,false) = 0 and Z(x,true) = v(x) for all leaves x • Recurrence • Z(u,true) =  Z(c, false) + v(u) • Z(u,false) =  max { Z(c,false), Z(c,true) } • Answer = max { Z(r,false), Z(r,true) } c C(u) c C(u)

  21. Treasure Hunt • Example (values shown in squares) false: 20 true: 27 7 false: 12 true: 3 false: 8 true: 6 2 6 false: 1 true: 9 9 3 5 1 2 false: 0 true: 3 false: 0 true: 5 false: 0 true: 1 false: 0 true: 2 false: 0 true: 1 1

  22. Treasure Hunt • Our formulation does not exploit the properties of a tree root • Moreover the correctness of our formulation can be proven by optimal substructure • Thus the unrooted-to-rooted transformation is correct • Time complexity: (N)

  23. Request Response Unrooted Tree DP – Basic Idea • In rooted tree DP, a node asks (request) for information from its children; and then provides (response) information to its parent

  24. A Request Response B C D E Unrooted Tree DP – Basic Idea • In unrooted tree DP, a node also makes a request to its parent and sends response to its children • Imagine B is the root • A sends information about the “subtree” {A,C} to B

  25. A A B C B C D E D E Unrooted Tree DP – Basic Idea • Similarly we can root C, D, E and get different request-response flows • These flows are very similar • The idea of unrooted tree DP is to root all nodes without resending all requests and responses every time

  26. A B C D E Unrooted Tree DP – Basic Idea • Root A and do a complete flow • A knows about subtrees {B,D,E} and {C} • Now B sends a request to A • A sends a response to B telling what it knows about {A,C} • B already knows about {D}, {E} • Rooting of B completes

  27. A B C D E Unrooted Tree DP – Basic Idea • Now let’s root D • D sends a request to B • B knows about {A,C}, {D}, and {E}; combining {A,C}, {E} and B itself, B knows about {B,A,C,E}, and sends a response to D • Rooting of D completes

  28. A B C D E Unrooted Tree DP – Basic Idea • Rooting a new node requires only one request and one response if its parent already knows about all its subtrees (including the “imaginary” parent subtree) • Further questions: • Fast computation of {B,A,C,E} from {A,C} and {E}? (rooting of D) • Fast computation of {B,A,C,E,D} from {A,C}, {E}, {D}? (rooting of B)

  29. Shortest Rooted Tree • Given an unrooted tree T, denote its rooted tree with root r by T(r) • Find a node v such that T(v) has the minimum height among all T(u), u T • The height of a tree = the height of its root • Solution • Just root every node and find the min height • We know how to find a height of a tree • Trivially this is (N2) • Now let’s use what we learnt

  30. Shortest Rooted Tree • Since parents and children are unclear now, we use slightly different notations • N(v) = the set of neighbors of v • H(v, u) = height of the subtree rooted at v if u is treated as the parent of v • H(v, ) = height of the whole tree if v is root

  31. Shortest Rooted Tree • Root A, complete flow • Height = 3 A H(A,) = 3 H(B,A) = 2 H(C,A) = 0 B C H(E,B) = 0 H(D,B) = 1 D E F H(F,D) = 0

  32. Shortest Rooted Tree • Root B • Request: B asks A for H(A,B) • How can A give the answer in constant time? A H(A,) = 3 H(B,A) = 2 H(C,A) = 0 B C H(E,B) = 0 H(D,B) = 1 D E F H(F,D) = 0

  33. Shortest Rooted Tree • Suppose now B asks A for H(A,B), how can A give the answer in constant time? • Two cases • B is the only largest subtree of A in T(A) • B is not the only largest subtree, or B is not a largest subtree A H(A,)=10 B C D E F G H I J K H(B,A)=7 H(D,A)=1 H(F,A)=9 H(H,A)=4 H(J,A)=3 H(C,A)=8 H(E,A)=2 H(G,A)=5 H(I,A)=6 H(K,A)=0

  34. Shortest Rooted Tree • (1) B is the only largest subtree of A in T(A) • H(A,B) < H(A,) • H(A,B) depends on the second largest subtree • Trick: record the second largest subtree of A • (2) B is not the only largest subtree, or B is not a largest subtree • H(A,B) = H(A,)

  35. Shortest Rooted Tree • To distinguish case (1) from case(2), we need to record the two largest subtrees of A • When? • When we evaluate H(A,) • Back to our example

  36. Shortest Rooted Tree • Root B • Request: B asks A for H(A,B) • Response: 1 A H(A,) = 3 1st = B, 2nd = C H(A,B) = 1 H(B,A) = 2 H(C,A) = 0 B C 1st = D, 2nd = E A 1st = , 2nd =  H(E,B) = 0 H(D,B) = 1 D E 1st = F, 2nd =  1st = , 2nd =  F H(F,D) = 0 1st = , 2nd = 

  37. Shortest Rooted Tree • Root B • H(B,) = 2 can be calculated in constant time A H(A,) = 3 1st = B, 2nd = C H(A,B) = 1 H(B,) = 2 H(B,A) = 2 H(C,A) = 0 B C 1st = D, 2nd = E A 1st = , 2nd =  H(E,B) = 0 H(D,B) = 1 D E 1st = F, 2nd =  1st = , 2nd =  F H(F,D) = 0 1st = , 2nd = 

  38. Shortest Rooted Tree • Root D • Request: D asks B for H(B,D) • Response: 2 • H(D,) = 3 A H(A,) = 3 1st = B, 2nd = C H(A,B) = 1 H(B,D) = 2 H(B,) = 2 H(B,A) = 2 H(C,A) = 0 B C 1st = D, 2nd = E A 1st = , 2nd =  H(D,) = 3 H(E,B) = 0 H(D,B) = 1 D E 1st = F, 2nd =  1st = , 2nd =  B F F H(F,D) = 0 1st = , 2nd = 

  39. Shortest Rooted Tree • Root F, E, and C in the same fashion • In general, root the nodes in preorder • Time complexity analysis • Root A – (N) • Root each subsequent nodes – O(1) • Overall - (N) • The O(1) is crucial for the linearity of our algorithm • If rooting of a new node cannot be done fast, unrooted tree DP may not improve running time

  40. Two-person Games • Often appear in competitions as interactive tasks • Playing against the judge • Most of them can be solved by the Minimax method

  41. o o o o x x o x o x x o x o o o Game Tree • A (finite or infinite) rooted tree showing the movements of a game play … … … … … … … …

  42. 2 9 4 5 6 6 8 1 7 6 Game Tree • This is a game • The boxes at the bottom show your gain (your opponent’s loss) • Your opponent is clever • How should you play to maximize your gain? WHY? Your turn Her turn End of game

  43. Minimax • You assume that your opponent always try to minimize her loss (minimize your gain) • So your opponent always takes the move that minimize your gain • Of course, you always take the move that maximize your gain 7 Your turn Her turn 4 6 6 7 9 4 5 6 8 7 2 9 4 5 6 6 8 1 7 6

  44. A A B C D C D D B 2 1 2 2 1 2 1 2 D 1 Minimax • Efficient? • Only if the tree is small • In fact the game tree may in fact be an expanded version of a directed acyclic graph • Overlapping subproblems  memo(r)ization

  45. Past Problems • IOI • 2001 Ioiwari (game), Score (game), Twofive (ugly) • 2005 Rivers(tree) • NOI • 2001 Cannon (ugly), 2002 Dragon (tree), 2003 逃學的小孩(tree) • IOI/NOITFT • 2004 A Bomb Too Far (tree) • CEOI • 2002 Bugs (ugly), 2003 Pearl (game) • Balkan OI • 2003 Tribe (tree) • Baltic OI • 2003 Gems (tree)

More Related