DP11 高楼扔鸡蛋问题 Egg Dropping Puzzle @geeksforgeeks

package DP;

/**
 * 100层楼，两个鸡蛋。某层之上扔鸡蛋就会碎。问至少要测试多少次才能找出这层楼来
 * 我们可以决定怎么扔(min)，但必须假设我们的运气最差(max)
 * 
 * 100层楼，两个鸡蛋。某层之上扔鸡蛋就会碎。问至少要测试多少次才能找出这层楼来？


思路：
首先要理解清楚题意，本题不是要找在哪一层以上会把鸡蛋扔破！而是我们假设在W层以上会把鸡蛋仍破，现在问至少要测试Y次才能找到这个W层？求的是Y
另外一个要注意的是本题中要基于扔的人运气最差的情况，即要保证在worst case下也能找到。
定义W层位蛋破层，则
我们第一次从第x层扔蛋下去，有两种可能：
1) 蛋破了：这说明了两点  1.我们手上仍然有n-1颗蛋  2.蛋破层一定在1...x-1之间，这里共有x-1-1+1 =>x-1数量的嫌疑楼层
2）蛋没破：这也说明了两点  1.我们手上仍然有n颗蛋  2.蛋破层一定在x+1...k之间，这里共有k-(x+1)+1 =>k-x数量的嫌疑楼层

定义eggDrop(n, k)为在最差情况下找出蛋破层所需要的最少扔数。n为蛋的数量，k为要检查的连续的楼层的数量
因为我们要基于最差情况，所以我们要选择两种可能之间更坏的那种，即导致扔的数量更多的那种情况，
即max(eggDrop(n - 1, x - 1), eggDrop(n, k - x))
然后我们遍历所有楼层，要找出能使得最后扔的数量最小的那个初始楼层，因此
eggDrop(n, k) = 1 + min{max(eggDrop(n - 1, x - 1), eggDrop(n, k - x)): x in {1, 2, ..., k}}
加1是因为在第x层测试时也消耗了1次。
 */
public class EggDroppingPuzzle {

	public static void main(String[] args) {
		int n = 2, k = 20;
		System.out.println(eggDropDP(n, k));
		System.out.println(eggDropRec(n, k));
	}
	
	/* Function to get minimum number of trails needed in worst
	  case with n eggs and k floors */
	// n: 手上完好蛋的数量
	// k: 要测试的连续楼层的数量
	public static int eggDropRec(int n, int k){
		// If there are no floors, then no trials needed. OR if there is
	    // one floor, one trial needed.
		if(k==1 || k==0){
			return k;
		}
		// We need k trials for one egg and k floors
		if(n == 1){
			return k;
		}
		int min = Integer.MAX_VALUE;
		
		/**
		 我们要决策怎么扔使得总扔数最少（即使在我们运气最差的情况下）worst-case
		 所以在每一楼都测试第一扔，然后递归计算出总共需要的扔数，找到扔数最小的数量
		 所以假设在第x层扔第一个蛋：
		 结果1：蛋破了->现在我们只有n-1个蛋，还要测试x-1数量的楼层[1,x-1] -> 数量=x-1 -1 + 1 = x-1
		 结果2: 但没破 -> 现在我们仍有n个蛋，还要测试k-x数量的楼层[x+1,k] -> 数量=k - (x+1) + 1 = k-x
		 */
		for(int x=1; x<=k; x++){
			int res = Math.max(eggDropRec(n-1, x-1), eggDropRec(n, k-x));
			min = Math.min(min, res);
		}
		return min+1;		// +1是因为测试当前层消耗了一次扔
	}

	/* Function to get minimum number of trails needed in worst
	  case with n eggs and k floors */
	// Time Complexity: O(nk^2), Auxiliary Space: O(nk)
	public static int eggDropDP(int n, int k){
		/* A 2D table where entery dp[i][j] will represent minimum
	       number of trials needed for i eggs and j floors. */
		int[][] dp = new int[n+1][k+1];	
		
		// We need one trial for one floor and0 trials for 0 floors
		for(int i=1; i<=n; i++){
			dp[i][1] = 1;
			dp[i][0] = 0;
		}
		// We always need j trials for one egg and j floors.
		for(int j=1; j<=k; j++){
			dp[1][j] = j;
		}
		// Fill rest of the entries in table using optimal substructure
	    // property
		for(int i=2; i<=n; i++){			// i eggs
			for(int j=2; j<=k; j++){	// j floors
				dp[i][j] = Integer.MAX_VALUE;
				for(int x=1; x<=j; x++){	// try every floor from 1...j
					int res = 1 + Math.max(dp[i-1][x-1], dp[i][j-x]);
					dp[i][j] = Math.min(dp[i][j], res);
				}
			}
		}
		return dp[n][k];
	}
}