Advanced Dynamic Programming II

1. Advanced Dynamic Programming II HKOI Training Team 2004

2. 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”)

3. In this lesson... • Dimension reduction • DP on trees, graphs, etc. • Game strategy - Minimax

4. Dimension Reduction • Reduce the memory complexity by one (or more) dimension • Usually a “rolling” array is employed

5. Triangle revisited • Only a 2x5 array is needed A F

6. Rolling array F’ F

7. 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

8. 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)

9. 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.

10. 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

11. B A D C E F Path (example) • s = A, t = E • Paths: • ABDE, ACBDE, ACDE • Answer = 3

12. 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

13. Path (solution) • Obviously the three paths shown below must be distinct • Even if they meet at some intermediate vertices! s C B A ... ... ... t

14. Path (solution) • Topological order 7 s 6 5 t 2 3 4 1

15. 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

16. 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)

17. 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

18. 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

19. Longest I (simple solution) • Make s the root s 5 7 5 6 4 3

20. 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

21. Longest I (another solution) • A longest path must end at one of the leaves s 5 7 5 6 4 3

22. 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

23. 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

24. 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) }

25. Longest I (another solution) • Time complexity – O(V) • No overlapping subproblems • F[] is redundant!

26. 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

27. 7 4 5 5 5 3 6 5 7 6 4 3 Longest II (solution) • Take any node and make it root

28. 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?

29. z z Longest II (solution) • Let z be the uppermost node in the longest path • Only two cases the only common node is z

30. 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)

31. 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

32. 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

33. 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

34. 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?

35. 2 1 1 1 3 1 1 1 Gems (example) • N = 8, M = 4

36. Gems (attempt) • Make the tree a rooted one first

37. 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?

38. 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) 1dM,dc

39. Gems (demostration) • M = 4

40. Gems (solution) • Algorithm (recursive, non-DP) • Gems(vertex v,integer c) { if (v is leaf) return c valuec 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 }

41. 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 }

42. 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??

43. 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

44. 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

45. Game tree • A (finite or infinite) rooted tree showing the movements of a game play … … … … … … … …

46. 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

47. Card (example) B A 2 1 9 7 1 4 3 17 14 4

48. Card (game tree) • N = 4 • Only 5 different states A’s move B’s move NULL NULL NULL NULL NULL NULL NULL

49. 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

50. 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