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

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]

import java.util.ArrayList;

public class OptimalGamePick {
    private ArrayList<Integer> picks;
    public int getOptimalStrategy(int[] pots) {
        picks = new ArrayList<Integer>();
        if(pots == null || pots.length == 0){
            return 0;
        }
        int[][] T = new int[pots.length][pots.length];
        for(int i = 0; i < pots.length; i++) {
            T[i][i] = pots[i];
        }
        for(int i = 0; i < pots.length - 1; i++) {
            T[i][i + 1] = Math.max(pots[i], pots[i + 1]);
        }
        for(int len = 3; len <= pots.length; len++) {
            for(int i = 0; i <= pots.length - len; i++) {
                T[i][i + len - 1] = Math.max(pots[i] + Math.min(T[i + 2][i + len - 1], T[i + 1][i + len - 2]), 
                                             pots[i + len - 1] + Math.min(T[i + 1][i + len -2], T[i][i + len - 3]));
            }
        }
        //reconstruct player 1's picks
        int start = 0, end = pots.length - 1;
        while(end - start >= 2) {
            int pickFront = pots[start] + Math.min(T[start + 2][end], T[start + 1][end - 1]);
            int pickEnd = pots[end] + Math.min(T[start + 1][end - 1], T[start][end - 2]);
            if(pickFront > pickEnd) {
                picks.add(start);
                if(T[start + 2][end] < T[start + 1][end - 1]) {
                    start++;
                }
                else {
                    end--;
                }
                start++;
            }
            else {
                picks.add(end);
                if(T[start + 1][end - 1] < T[start][end - 2]) {
                    start++;
                }
                else {
                    end--;
                }
                end--;
            }            
        }
        if(end - start == 1) {
            if(pots[start] > pots[end]) {
                picks.add(start);
            }
            else {
                picks.add(end);
            }
        }
        else {
            picks.add(start);
        }
        return T[0][pots.length - 1]; 
    }
    public static void main(String[] args) {
        int[] pots = {3, 9, 1, 2};
        OptimalGamePick test = new OptimalGamePick();
        System.out.println(test.getOptimalStrategy(pots));
    }
}

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.

public ResultEntry getOptimalStrategy(int[] pots) {
    ResultEntry[][] T = new ResultEntry[pots.length][pots.length];
    for(int i = 0; i < T.length; i++) {
        for(int j = 0; j < T[0].length; j++) {
            T[i][j] = new ResultEntry(0, 0);
        }
    }
    for(int i = 0; i < T.length; i++) {
        T[i][i].p1 = pots[i];
    }
    for(int i = 0; i < T.length - 1; i++) {
        T[i][i + 1].p1 = Math.max(pots[i], pots[i + 1]);
        T[i][i + 1].p2 = Math.min(pots[i], pots[i + 1]);            
    }
    for(int len = 3; len <= pots.length; len++) {
        for(int i = 0; i <= pots.length - len; i++) {
            int pickFront = pots[i] + T[i + 1][i + len - 1].p2;
            int pickEnd = pots[i + len - 1] + T[i][i + len -2].p2;
            if(pickFront >= pickEnd) {
                T[i][i + len - 1].p1 = pickFront;
                T[i][i + len - 1].p2 = T[i + 1][i + len - 1].p1;
            }
            else {
                T[i][i + len - 1].p1 = pickEnd;
                T[i][i + len - 1].p2 = T[i][i + len - 2].p1;                    
            }
        }
    }
    return T[0][pots.length - 1];
}