[Coding Made Simple] Optimal Strategy Game Pick from Ends of array

Posted 2020-10-04 Push your limit!

N pots, each with some number of gold coins, are arranged in a line. You are playing a game against another player. You take turns picking a pot of gold. You may pick a pot from either end of the line, remove the pot, and keep the gold pieces. The player with the most gold at the end wins. Develop a strategy for playing this game.

 

After drawing the following flow diagram, it is clear that we have overlapping subproblems such as p1 for A[1-6]. As a result, we\'ll use dynamic programming here.

 

Solution 1. Dynamic Programming, only from player 1\'s perspective.

State: T[i][j]: the max value player 1 can get when pots[i......j] are available.

Function: T[i][j] = Max {pots[i] + Min {T[i + 2][j]},  T[i + 1][j - 1],    pots[j] + Min {T[i + 1][j - 1], T[i][j - 2]} }.   Min is used here is because player 2 is trying to play for the best strategy too.

Init: If there is only 1 pot, pick it; If there are 2 pots, pick the one that has a bigger value.

Answer: T[0][pots.length - 1]

 1 import java.util.ArrayList;
 2 
 3 public class OptimalGamePick {
 4     private ArrayList<Integer> picks;
 5     public int getOptimalStrategy(int[] pots) {
 6         picks = new ArrayList<Integer>();
 7         if(pots == null || pots.length == 0){
 8             return 0;
 9         }
10         int[][] T = new int[pots.length][pots.length];
11         for(int i = 0; i < pots.length; i++) {
12             T[i][i] = pots[i];
13         }
14         for(int i = 0; i < pots.length - 1; i++) {
15             T[i][i + 1] = Math.max(pots[i], pots[i + 1]);
16         }
17         for(int len = 3; len <= pots.length; len++) {
18             for(int i = 0; i <= pots.length - len; i++) {
19                 T[i][i + len - 1] = Math.max(pots[i] + Math.min(T[i + 2][i + len - 1], T[i + 1][i + len - 2]), 
20                                              pots[i + len - 1] + Math.min(T[i + 1][i + len -2], T[i][i + len - 3]));
21             }
22         }
23         //reconstruct player 1\'s picks
24         int start = 0, end = pots.length - 1;
25         while(end - start >= 2) {
26             int pickFront = pots[start] + Math.min(T[start + 2][end], T[start + 1][end - 1]);
27             int pickEnd = pots[end] + Math.min(T[start + 1][end - 1], T[start][end - 2]);
28             if(pickFront > pickEnd) {
29                 picks.add(start);
30                 if(T[start + 2][end] < T[start + 1][end - 1]) {
31                     start++;
32                 }
33                 else {
34                     end--;
35                 }
36                 start++;
37             }
38             else {
39                 picks.add(end);
40                 if(T[start + 1][end - 1] < T[start][end - 2]) {
41                     start++;
42                 }
43                 else {
44                     end--;
45                 }
46                 end--;
47             }            
48         }
49         if(end - start == 1) {
50             if(pots[start] > pots[end]) {
51                 picks.add(start);
52             }
53             else {
54                 picks.add(end);
55             }
56         }
57         else {
58             picks.add(start);
59         }
60         return T[0][pots.length - 1]; 
61     }
62     public static void main(String[] args) {
63         int[] pots = {3, 9, 1, 2};
64         OptimalGamePick test = new OptimalGamePick();
65         System.out.println(test.getOptimalStrategy(pots));
66     }
67 }

 

Solution 2.  Dynamic Programming, from both player 1 and 2\'s perspective.

State: T[i][j] stores the max value both players can get given pots i to j. Whoever picks first becomes player 1, so as the range of pots changes, player 1 and player 2 take turns to pick first.

Function:  If player 1 picks pots[i], then for pots i + 1 to j he becomes player 2 as he is the second player to pick from i + 1 to j.

　　　T[i][j]. first = max {T[i + 1][j].second + pots[i],  T[i][j - 1].second + pots[j]};

　　　T[i][j].second = T[i + 1][j].first or T[i][j - 1].first, depending on which pot was picked previously by the other player.

 

 1 public ResultEntry getOptimalStrategy(int[] pots) {
 2     ResultEntry[][] T = new ResultEntry[pots.length][pots.length];
 3     for(int i = 0; i < T.length; i++) {
 4         for(int j = 0; j < T[0].length; j++) {
 5             T[i][j] = new ResultEntry(0, 0);
 6         }
 7     }
 8     for(int i = 0; i < T.length; i++) {
 9         T[i][i].p1 = pots[i];
10     }
11     for(int i = 0; i < T.length - 1; i++) {
12         T[i][i + 1].p1 = Math.max(pots[i], pots[i + 1]);
13         T[i][i + 1].p2 = Math.min(pots[i], pots[i + 1]);            
14     }
15     for(int len = 3; len <= pots.length; len++) {
16         for(int i = 0; i <= pots.length - len; i++) {
17             int pickFront = pots[i] + T[i + 1][i + len - 1].p2;
18             int pickEnd = pots[i + len - 1] + T[i][i + len -2].p2;
19             if(pickFront >= pickEnd) {
20                 T[i][i + len - 1].p1 = pickFront;
21                 T[i][i + len - 1].p2 = T[i + 1][i + len - 1].p1;
22             }
23             else {
24                 T[i][i + len - 1].p1 = pickEnd;
25                 T[i][i + len - 1].p2 = T[i][i + len - 2].p1;                    
26             }
27         }
28     }
29     return T[0][pots.length - 1];
30 }