887. 鸡蛋掉落

#887. 鸡蛋掉落

2020/4/11每日一题打卡√ 难度：困难
完全不会，参考了好多题解
题目理解 + 基本解法 + 进阶解法
动态规划（只解释官方题解方法一）（Java）
题目描述

解题思路
经典动态规划题，可惜我不会，今天也是抄答案的一天呢

1、朴素动态规划，未优化

首先参考李永乐老师讲的，理解题意：李永乐老师讲解视频
讲的很清楚，状态转换方程：

用最经典最淳朴的DP思想，设置一个状态数组，然后自底向上填表，能得到一个满足题意的代码（但是提交会超时8/10000）。

public int superEggDrop(int K, int N) {
  	if(K == 1)
   		return N;
  	if(N == 0)
   		return 0;
 	 int [][]dp = new int[K+1][N+1];   //动态规划数组,k个鸡蛋，面对n层楼
  	for (int i = 0; i <= N; i++) {  //初始化,一个鸡蛋的时候总是要丢n次，一层楼总是只要丢1次
   		dp[1][i] = i;
  	}
  	for (int i = 1; i <= K; i++) {  
   		dp[i][1] = 1;
  	}
  	// 从第 2 行，第 2 列开始填表
  	for (int i = 2; i <= K; i++) {
   		for (int j = 2; j <= N; j++) {
     			int min = N+1;
   		 	for (int k = 1; k <= j; k++) { 
    //这个循环意思是尝试第一次从第i楼开始丢鸡蛋，在每次不同的楼层尝试中找一个最大值，
    //在所有最大值中找最小值就是符合题目要求的
     				min = Math.min(min, 1 + Math.max(dp[i-1][k-1], dp[i][j-k]));
    			}
    		dp[i][j] = min;
   		}
  	}
 
  	return dp[K][N];
 }

复杂度分析：O（kn2)，平方级的时间复杂度，还有很大的优化空间
提交结果:
还有递归版本，时间复杂度更是指数级，但是参考一下还是把代码贴出来吧。

public static int superEggDrop(int K, int N) {
  	if(K == 1 || N <= 1)
   		return N;
  	int re = Integer.MAX_VALUE;
  	for (int i = 1; i <= N; i++) {
   		re = Math.min(re,1+Math.max(superEggDrop(K-1, i-1), superEggDrop(K, N-i)));
  	}
  	return re;
 }

2、使用二分思想进行优化

如果不限制鸡蛋个数的话，本题最容易想到的就二分，用二分法肯定能最少次数logn的找到最小值。但是鸡蛋次数的限制决定了不能用普通的二分，得把二分法和动态规划结合起来。


根
根据这个思路得到二分思想优化过的第二版代码（但是其实还是很慢）：

public static int superEggDrop2(int K, int N) {
  	if(K == 1 || N <= 1)
   		return N;
  	int [][]dp = new int[K+1][N+1];   //动态规划数组,k个鸡蛋，面对n层楼
  	for (int i = 0; i <= N; i++) {
   		dp[1][i] = i;
  	}
  	for (int i = 0; i <= K; i++) {
   		dp[i][1] = 1;
  	}
  	for (int i = 2; i <= K; i++) {
   		for (int j = 2; j <= N; j++) {
    			int low = 1,high = j;
    			while(low < high) { 
     				int mid = low + (high-low+1)/2;
     				if(dp[i-1][mid-1] > dp[i][j-mid]) {//蛋碎了>蛋没碎，一定不是解
      					high = mid - 1;
     				}
    				 else {
      					low = mid;
     				}
    			}
    // left 这个下标就是最优的 k 值，把它代入转移方程 Math.max(dp[k - 1][j - 1], dp[i - k][j]) + 1) 即可
                	dp[i][j] = Math.max(dp[i - 1][low - 1], dp[i][j-low]) + 1;
   		}
 	 }
  	return dp[K][N];
 }

时间复杂度O（KNlogn），虽然还是不优秀但是好歹能提交成功不超时了对不对！