丢棋子问题

题目

分析

设P(N,K)的返回值时N层楼时有K个棋子在最差的情况下扔的最少次数。

1. 如果N = 0，棋子肯定不会碎，因此P(0,K) = 0
2. 如果K = 1，那么只能从第一层开始尝试，在最差的情况下需要扔N次，因此P(N,1) = N;
3. 对于N>0且K>1, 我们需考虑第1个棋子是从哪层开始扔的。如果第1个棋子从第i层开始仍，那么有以下两种情况:
     (1) 碎了。没必要尝试第i层以上的楼层了，接下来的问题就变成了剩下i-1层楼和K-1个棋子，所以总步数为 1+P(i-1, K-1);
     (2)没碎。 那么可以知道没必要尝试第i层及其以下的楼层了，接下来的问题就变成了还剩下N-i层和K个棋子，所以总步数为 1+P(N-i, K).。
4. 根据题意应该选取(1)和(2)中较差的那种情况，即 max{ P(i-1, K-1), P(N-i, K)}+1。 由于i的取值范围是 1到N, 那么步数最少的情况为， P ( N , K ) = m i n { m a x { P ( i − 1 , K − 1 ) , P ( N − i , K ) } } + 1 ( 1 < = i < = N ) P(N, K)=min\{max\{P(i-1, K-1), P(N-i, K)\}\}+1(1<=i<=N) P(N,K)=min{max{P(i−1,K−1),P(N−i,K)}}+1(1<=i<=N)

第一种方法：动态规划

public int solve (int n, int k) {
        if(n < 1 || k < 1) {
            return 0;
        }
        int[][] dp = new int[n+1][n+1];
        //初始化dp,如果只有一个棋子时，最坏情况下需要扔的次数等于楼层高度
        for(int i = 1; i < dp.length; i++) {
            dp[i][1] = i;
        }
        for(int i = 1; i <= n; i++) {//楼层高度
            for(int j = 2; j <= k; j++){//能够扔的棋子数
                int min = Integer.MAX_VALUE;
                for(int m = 1; m <= i; m++) {//初始化扔的楼层高度
                    min = Math.min(Math.max(dp[m-1][j-1],dp[i-m][j]),min);
                }
                dp[i][j] = min + 1;
            }
        }
        return dp[n][k];
    }

方法二：优化的动态规划，对二维数组进行优化

楼层数\棋子数	0	1	2	3	4
0	0	0	0	0	0
1	0	1	(1,2)
2	0	2	(2,2)
3	0	3	(3,2)
4	0	4	(4,2)
5	0	5	(5,2)

分析方法一种动态规划的过程，可以发现按照列对矩阵进行填充，只需要用到当前填充位置的上面的列和其左边的列。比如要填充（4,2）的位置，其用到的两个红框圈其来的两列。

 public int solve (int n, int k) {
        if(n < 1 || k < 1) {
            return 0;
        }
        //cur表示当前填充位置上面的列
        int[] cur = new int[n+1];
        //pre表示当前填充位置左边的列
        int[] pre = new int[n+1];
        //初始化pre
        for(int i = 0; i < pre.length; i++) {
            pre[i] = i;
        }
        for(int K = 2; K <= k; K++) {//棋子数
            for (int i = 1; i <= n; i++) {//楼层数
                int min = Integer.MAX_VALUE;
                for (int j = 0; j < i; j++) {
                    min = Math.min(Math.max(pre[j], cur[i - j - 1]), min);
                }
                cur[i] = min + 1;
            }
            //交换cur和pre
            int[] temp = pre;
            pre = cur;
            cur = temp;
            //重新填充cur中的值为0
            Arrays.fill(cur,0);
        }
        //这里返回的是pre[n],因此在最后一次循环后cur赋值给了pre
        return pre[n];
    }

第三种方法：动态规划+二分查找
P ( N , K ) = m i n { m a x { P ( i − 1 , K − 1 ) , P ( N − i , K ) } } + 1 ( 1 < = i < = N ) P(N, K)=min\{max\{P(i-1, K-1), P(N-i, K)\}\}+1(1<=i<=N) P(N,K)=min{max{P(i−1,K−1),P(N−i,K)}}+1(1<=i<=N)
由递推关系式可知，在K不变的情况下，$P(i-1,K-1)$关于$i$是递增函数，而$P(N-i,k)$关于$i$是递减函数，因此$P(N,K)$关于N的图像如下图蓝色线条：

因此可以通过二分查找找出这个最低点，由于N是一个离散值，所以函数图像并不是连续的，所以函数最小值是上图中$X_0$和$X_1$中的较小值，且$X_1=X_0+1$。下面给出代码，已详细注释。

//用于存储在在当前(K,N)下的最小尝试次数
    Map<Integer,Integer> map = new HashMap<>();
    //K表示鸡蛋数，N表示楼层数，superEggDrop表示确定临界楼层的最小尝试次数
    public int superEggDrop(int K,int N) {
        //如果楼层数为0或者鸡蛋数，则尝试次数为0
        if(N == 0 || K == 0) {
            return 0;
        }
        //如果鸡蛋数为1，则在最坏的情况下需要从第一层开始尝试到顶层
        if(K == 1) {
            return N;
        }
        //给当前的(K,N)确定一个key值，采用线性函数的方式
        int key = N * 1000 + K;
        //如果map中存储有当前节点值，直接返回
        if(map.containsKey(key)) {
            return map.get(key);
        }
        //二分查找的起始位置和终点位置，即楼层的第一层和最后一层
        int low = 1;
        int high = N;
        //二分查找交叉函数的最低点x
        while(low + 1 < high) {
            int mid = (low + high) / 2;
            //递增函数在mid处的值
            int value1 = superEggDrop(K - 1,mid -1);
            //递减函数在mid处的值
            int value2 = superEggDrop(K,N - mid);
            if(value1 > value2) {//如果递增函数在mid处的值大于递减函数，说明x在mid的左侧
                high = mid;
            } else if(value1 < value2) {//如果递增函数在mid处的值小于递减函数，说明x在mid的右侧
                low = mid;
            } else {//如果相等，说明mid就是最低点
                low = high = mid;
            }
        }
        int min = Math.min(superEggDrop(K,N-low),superEggDrop(K - 1,high - 1)) + 1;
        //int min = Math.min(Math.max(superEggDrop(K-1,low-1),superEggDrop(K,N-low)),Math.max(superEggDrop(K-1,high-1),superEggDrop(K,N-high))) + 1;
        map.put(key,min);
        return map.get(key);
    }

第四种方法：最优解法

class Solution {
    public int superEggDrop(int K, int N) {
        int[][] dp = new int[K + 1][N + 1];
        for (int m = 1; m <= N; m++) {
            dp[0][m] = 0; // zero egg
            for (int k = 1; k <= K; k++) {
                dp[k][m] = dp[k][m - 1] + dp[k - 1][m - 1] + 1;
                if (dp[k][m] >= N) {
                    return m;
                }
            }
        }
        return N;
    }
}

相关链接：
leetcode题解
博客园
程序员小灰