轮流取硬币

问题：
直线上一排硬币，币额不等，某人与对手轮流取硬币，一次取一枚，只能从头或者尾取，假设他开始取第一枚，看谁最后拿的钱最多。问
* 1）有没有办法保证他不败。
* 2）他最多可以拿多少钱。

怎么才能不败？原理在于第一个取硬币的人可以控制对手的行为，给硬币从1开始顺序编号，分别计算单数硬币和双数硬币的总的价值，看哪一个大。

但是这个值并不是最大值，要取到最多的钱，可以考虑动态规划。
假设位置区间[i, j]，f(i, j)为此区间可取到的最大值(注意一个约定，一定是他先开始取)，
1) 如果他取a[i]，对手可以选择a[i+1]或者a[j], 则
f(i, j) = max {a[i]+f(i+2, j), a[i]+f(i+1, j-1)}

2) 如果他取a[j]，对手可以选择a[i]或者a[j-1]，则
f(i, j) = max {a[j]+f(i+1, j-1), a[j]+f(i, j-2)}

注意到上面重复出现f(i+1, j-1), 可以合并，则f(i, j)依赖于a[i],a[j]以及其他三个点。

i从上向下递增，j从左向右递增。比如要求w这个点，即f(0,2)最大值，它依赖于三个红色的x点。同理v依赖于三个蓝色的o点。所求的点是p，那么就按斜线向右上方不停填满这个表格，最后一个点就是我们要的最大值f(0,n-1)。因为i小于等于j，所以做下半部分的点被忽略。

斜线x表示只有一个硬币的情况，因为他先下手的，所以只有一种情况。斜线o表示有两个硬币，他必然是选二者中的较大的那个硬币。这两条线都是确定性的，可以事先初始化好。然后剩下的斜线可以在这个基础上，不断填满。

public static int start(int[] a, int n){        int[][] f = new int[n][n];        for(int i=0; i<n; i++){            f[i][i] = a[i];            if(i < n-1){                f[i][i+1] = a[i]>a[i+1] ? a[i] : a[i+1];            }        }        for(int k=2; k<n; k++){            for(int i=0; i<n-k; i++){                int j = i + k;                int m1 = a[i] + f[i+2][j];                int m2 = a[j] + f[i][j-2];                int x = a[i]>a[j] ? a[i] : a[j];                int m3 = x + f[i+1][j-1];                f[i][j] = getMax(m1, m2, m3);            }        }        return f[0][n-1];    }    private static int getMax(int n1, int n2, int n3){        int max = n1>n2 ? n1 : n2;        return max>n3 ? max : n3;    }

可以参考石子合并的那个题目，其实最直观的想法应该是个递归。
start(a, 0, n-1)就是答案。

    public static int run(int[] a, int i, int j){        if(f[i][j] > 0){            return f[i][j];        }        if(i == j){//line x            return a[i];        }        if((j - i) == 1){//line o            return a[i]>a[j] ? a[i] : a[j];        }        int m1 = a[i] + run(a, i+2, j);        int m2 = a[j] + run(a, i, j-2);        int x = a[i]>a[j] ? a[i] : a[j];        int m3 = x + run(a, i+1, j-1);        int max = getMax(m1, m2, m3);        f[i][j] = max;//save it for looking up later        return max;    }

动态规划就是动态查表，空间换时间，他和递归在时间效率上只是常量级别的区别，前提是这个递归一定要边递归，边存储。