动态规划，高楼扔鸡蛋问题的三种解答方法，区别在于状态不一样写出的转移方程就不一样

import java.util.HashMap;
import java.util.Map;

/**
 * 887. 鸡蛋掉落
 *     动态规划，选择是选择楼层，穷举 dp[k][n]=m 存的值就是答案 m
 *          法一：递归，超出时间限制 复杂度 O(KN^2)
 *          法二：递归，二分法缩小范围 复杂度O(KlogN)
 *     动态规划，选择是当前鸡蛋 k和最多尝试次数 m，能确定的最大楼层，dp[k][m] = n
 *          法三：逆推出 m，时间复杂度 O(KN)
 *
 * dp(K, N)为在状态 (K, N)下最少需要的步数
 * 鸡蛋不碎:
 *      那么状态变成 (K, N-X)，鸡蛋的数目不变，答案在上方的 N-X 层楼。
 * 鸡蛋碎了:
 *      那么状态变成 (K-1, X-1)，少了一个鸡蛋，答案在第 X 楼下方的 X-1层楼中。
 *
 * dp(K,N) = 1+ min(Math.max(dp(K-1,N-i),dp(K,i-1))+1);
 *
 * dp(K,N-X)，随着楼层的个数增加，值减小，递增的一个离散数列
 * dp(K-1,X-1),随楼层的个数增加，值增大，递减的一个离散数列
 * 要找到两个数最大值的最小值，那么就是两个函数相等的那个点，但是离散的情况下，我们
 * 找最靠近这个交点的整数。用 l 和 h 去缩小范围
 *
 *
 * @Auther:sommer1111
 * @date 2021/3/4 11:01
 */
public class supperEggDrop {
    public int superEggDrop(int K, int N) {
        return dp(K, N);
    }

//方法一：时间复杂度 O(KN^2)
    Map<Integer, Integer> map = new HashMap();
    public int dp(int K, int N) {

        int res = Integer.MAX_VALUE;
        for (int i = 1; i <=N; i++) {
            res = Math.min(res,Math.max(
                    //递归导致超出时间限制，当 N非常大时，无法通过测试
                    dp(K-1,N-i),dp(K,i-1))+1
            );
            map.put(N*100+K,res);
        }
        return res;
    }

//方法二：时间复杂度 O(KlogN)
    HashMap<Integer,Integer> memo = new HashMap<>();
    public int superEggDrop2(int k, int n) {
        return dp2(k,n);

    }

    public int dp2(int K,int N){
        if(K==1|| N==0){
            return N;
        };
        if(memo.containsKey(N * 100+K)){
            return memo.get(N * 100+K);
        }

        int l = 1,h = N;
        int ans;
        while (l+1  < h) {
            //随便选一层楼扔，为了最优化随便选的楼层，用二分法选择
            int x = (l + h) / 2;
            //鸡蛋破了，那么需要下楼，所以K-1,x-1
            int broken = dp(K-1, x-1);
            //鸡蛋没破，上楼，鸡蛋还是K，楼层数变成N-x
            int not_broken = dp(K, N-x);

            //ans = Math.min(ans,Math.max(碎，没碎)+1)
            if (broken < not_broken) {
                //没碎，只能往上继续找
                l = x;

            }else if (broken > not_broken) {
                //上面都会碎，只能往下继续缩小范围
                h = x;
            } else {
                l = h = x;
            }

        }
        ans = 1 + Math.min(
                //此时的 l 和 h 就是交点附近的两个整数，但是不知道谁跟接近交点
                //所以需要比较分别这个点的碎了，没碎的情况得出结论。
                Math.max(
                        dp(K - 1, l - 1),
                        dp(K, N - l)),
                Math.max(
                        dp(K - 1, h - 1),
                        dp(K, N - h))
        );
        //存放在备忘录中，防止重复计算。
        memo.put(N * 100+K, ans);
        return ans;
    }

//    方法三：执行时间最短，时间复杂度 O(KN)
    HashMap<Integer,Integer> map3  = new HashMap<>();
    public int dp3(int k,int n ){
        if(n==0 || k==1){
            return n;
        }
        int[][] dp = new int[k+1][n+1];
        int m = 0;
        while(dp[k][m]<n){
            m++;
            for (int i = 1; i <=k; i++) {
                dp[i][m] = dp[i-1][m-1] + dp[i][m-1] + 1;
            }
        }
        return m;
    }


}