分析：对于一组[n,k] 在一次尝试中选择了在dep层测试 其可以分为    

如果在dep层炸了: 则变成了[dep-1,k-1]读作在dep-1层用k-1个鸡蛋来找鸡蛋的极限所需次数

如果在dep层没炸: 则变成了[n-dep,k]读作在n-dep层用k个鸡蛋来找鸡蛋的极限所需次数

可以发现这都是子问题的传递，而这也是可以使用动态规划的依据。

为了保证能完成，所以对于 [n,k]在一次dep的选择时，需要取max([dep-1,k-1],[n-dep,k])

但对与每个dep产生的max([dep-1,k-1],[n-dep,k])需要取最小值，因为在能完成的情况下要找最少的次数

        需要注意的是，对于上述理论只有在k>=2时成立，因为当n==1时其已经没有，任何容错，除当前不知道是否能承受的最小值进行遍历尝试才能确保找到。

        动态规划代码

class Solution {
public:
    int dp[10005][101];
    int superEggDrop(int k, int n) {
        if(k==1){return n;}
        for (int d = 1; d <= n; d++)
            for (int j = 1; j <= k; j++) {
                dp[d][j] = 1005;
                for (int i = 1; i <= d; i++) {
                    dp[d][j] =
                        min(dp[d][j], max((j == 2 ? i - 1 : dp[i - 1][j - 1]),
                                          dp[d - i][j]) + 1);
                }
            }
        return dp[n][k];
    }
};

时间复杂度：O(n^2*k);虽说使用的是动态归划但是也很暴力，时间上通不过

优化

        反转问题求在num次投掷中最多能映射到哪些层

        对于一组[num,Egg]能映射到最多多少层可分为

        一次尝试蛋炸了剩[num-1,Egg-1]与
        一次尝试蛋没炸[num-1,Egg]此处和上面不太相同[num,Egg]=[num-1,Egg-1]+[num-1,Egg]+1

解释：对于一组[now_num,now_Egg] 

假设我们当前知道了所有1<num<now_num和1<Egg<now_Egg的组合能映射到的最多层数

例如      一组[5,2]最多能映射到A 层        一组 [5,3]最多能映射到B 层

在一次对X层的测试中，为了使[6,3]映射的尽可能多 则排布方式为[5,2] X [5,3]总计A+B+1层，

又找到了子问题可以继续递推，下面为递归实现出口为num=0||k==1;

代码

class Solution {
public:
    int calc(int k, int t) {
        if (k == 1 || t == 0) {
            return t;
        }
        return calc(k - 1, t - 1) + calc(k, t - 1) + 1;
    }
    int superEggDrop(int k, int n) {
        int t = 1;
        while (calc(k, t++) < n)
            ;
        return t - 1;
    }
};

为了使t尽可能小使用对t从一开始网上找，此处也可二分优化时间将进一步提升