DP_扔鸡蛋

初阶——100层，2个鸡蛋
两个鸡蛋的硬度相同，从X层扔不碎，X+1层扔碎了，则硬度为X，
要测试鸡蛋的硬度，如果每次用最优的方法，在最坏的情况下测试次数n为多少？
测试次数为n，则第一次扔需要在第n层，
这样如果鸡蛋碎了，第2次就要从第1层开始往上慢慢试，试到第n-1层，都没碎，这样鸡蛋的硬度就是n，测试次数是1 + n -1 = n.
如果鸡蛋没碎，第2次的最优选择就在n+n-1层扔，结果同样有两种，碎了，同理上面测试次数为 1 + 1 + n-2 = n,
又没碎的话，第3次就在n+n-1+n-2层开始扔，一直不碎的情况一直尝试到100层时，测试结束，得到一个公式
n+n-1+n-2+n-3+…+1 = 100,
转换后 n（n+1)/2 = 100; n向上取整， 也就是n正好让公式大于等于100；
求得n=14;

进阶——1000层，3个鸡蛋
三个鸡蛋的情况用上述方法并不完全可行，因为第1个鸡蛋碎了，还有第2个鸡蛋可以碎，所以第一次不在第n层扔，可以假设第一次从1~1000层扔，取最小的次数，就是最优解。假设第一次在第x层开始扔。
第一次扔后，有碎和不碎两种情况，测试次数是在扔完第1次后，后面所有需要测试的次数加1。
如果第一次扔碎了， 第二次就是x-1层，2个鸡蛋的问题。
如果第一次没碎，第二次就是1000-x层，3个鸡蛋的问题。
用函数func(m,n)求次数, func(m, n)=max(func(1000-x, 3), func(x-1, 2));
x从1~1000尝试，取这1000种选择中最小的值
测试次数 = min( max((func(1000-x, 3), func(x-1, 2)) ) (1<= x <= 1000);
这就是一个递归求解的过程, n = 19

动态规划——m层,n个鸡蛋
由上面的分析，得到状态转移
func(m,n) = min(max((func(m-x, n), func(x-1, n-1)) ) (1<= x <= 1000)
用递归的话，时间复杂度太高，考虑用循环求解，思想可以参考斐波那契数列，自底向上，把底层结果保存在数组arr[n][m]中，然后向上推导。
当n=1时，测试次数=m,当m=1时，测试次数=1；
然后推导n=2时，0~m层所有结果，保存在对应arr[2][m]的位置中，
依次n=3,4,5…的情况，就可以求到m层，n个鸡蛋的测试次数。

代码如下：

int max(int a, int b)
{
    if(a>b)
    return a;
    return b;
}

int dp(int arr[][1024], int m, int n)
{
    int i,j;
    int x;
    for(i = 2; i <= n; i++)
    {
        for(j = 2; j <= m; j++)
        {
            int min = 1024;
            for(x = 1; x <= j; x++)
            {
                int tmp;
                if(x == 1)
                    tmp = arr[i][j-x]+1;
                else if(x == m)
                    tmp = arr[i-1][x-1]+1;
                else
                    tmp = max(arr[i][j-x]+1, arr[i-1][x-1]+1);
                if(min > tmp)
                    min = tmp;
            }
            arr[i][j] = min;
        }
    }
    return arr[n][m];
}

int main(int argc, char *argv[]) {
    //test1();
    int arr[100][1024] = {0};
    int m = 1024;
    int n = 100;
    int con = 0;
    int i, j;
    for(i = 0; i < n; i++)
        arr[i][1] = 1;
    for(j = 0; j < m; j++)
        arr[1][j] = j;
    printf("%d %d\n", dp(arr,100,2), dp(arr,1000,3));
    return 0;
}