动态规划 高楼扔鸡蛋

leetcode 887 鸡蛋掉落
https://leetcode-cn.com/problems/super-egg-drop/
主要参考：
https://labuladong.gitbook.io/algo/dong-tai-gui-hua-xi-lie/gao-lou-reng-ji-dan-wen-ti
状态： 当前拥有的鸡蛋数量 K 和需要测试的楼层数N。可能你会觉得楼层区间是 [floor_begin, floor_last]，其实不是，当确定了搜索区间之后，只关心需要测试的楼层数量！ 与其物理高度没有关系。
选择：去哪一层楼扔鸡蛋。
dp数组定义：dp[ i ][ j ] , 有 i 个鸡蛋，要测试 j 层楼，在最坏情况下，最少的扔鸡蛋次数。

要计算dp[ i ][ j ]
1、暴力穷举尝试在所有楼层 1 <= p <= j 扔鸡蛋，每次选择尝试次数最少的那一层；(这里是有技巧的，可以选择在[ 1…j ]中线性搜索，但是会超出leetcode时间限制，可以采用二分查找的思想优化这一步)。
2、每次在p层扔鸡蛋有两种可能，要么碎，要么没碎。鸡蛋是碎了还是没碎，取决于哪种情况下尝试次数更多，因为我们想求的是最坏情况下的结果。
3、如果鸡蛋碎了，F 应该在第 p 层下面，否则，F 应该在第 p 层上面。

base case
j = 0 时, dp[..][0] = 0 //楼层数为0，尝试次数为0
i = 1 时， dp[1][j] = j //只有1个鸡蛋时，只能逐层测试，直接返回楼层数

1. 在第 p 层碎了， 鸡蛋数减一，搜索区间从[1..j] -> [1..p-1]，楼层数为 p-1,
表示为 dp[i-1][p-1]
2. 在第 p 层没有碎，鸡蛋数量不变，搜索区间从[1..j] -> [p+1..j], 楼层数为 j-p,
表示为 dp[i][j-p]

///高楼扔鸡蛋
//dp[K][N] : 拥有K个鸡蛋, 要测试N层楼, 最少次数
//原题限制条件 1 <= K <= 100    1 <= N <= 10000
int superEggDrop(int K, int N) {
    vector<vector<int>> dp(K+1, vector<int>(N+1, 10001));
    //base case
    for(int i = 1; i <= K; i++) {
        dp[i][0] = 0;
    }
    for(int j = 0; j <= N; j++) {
        dp[1][j] = j;
    }
    //正向遍历
    for(int i = 2; i <= K; i++) {
        for(int j = 1; j <= N; j++) {
            //dp[i][j] : 用i个鸡蛋, 测试j层楼
            int res = 10001;
            //线性搜索找楼层p
//            for(int p = 1; p <= j; p++)
//                res = min(res, max(dp[i-1][p-1], dp[i][j-p]) + 1);
            //二分查找找楼层p
            int left = 1, right = j;
            while(left <= right) {
                int mid = (left + right) / 2;
                int broken = dp[i - 1][mid - 1] + 1; //碎还是没碎都扔了一次
                int not_broken = dp[i][j - mid] + 1;
                if(broken > not_broken) {
                    right = mid - 1;
                    res = min(res, broken);
                }
                else {
                    left = mid + 1;
                    res = min(res, not_broken);
                }
            }

            dp[i][j] = res;
        }
    }
    return dp[K][N];
}

举例 K = 3，N = 14，dp数组如下：
行 index 从 0 … 3
列 index 从 0 … 14

0   10001 ......10001 (14个，10001视作无穷大)
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14
0	1	2	2	3	3	3	4	4	4	4	5	5	5	5
0	1	2	2	3	3	3	3	4	4	4	4	4	4	4