Balls（扔鸡蛋问题）

4554 Balls
The classic Two Glass Balls brain-teaser is often posed as:
“Given two identical glass spheres, you would like to determine the lowest floor in a 100-story
building from which they will break when dropped. Assume the spheres are undamaged
when dropped below this point. What is the strategy that will minimize the worst-case
scenario for number of drops?”
Suppose that we had only one ball. We’d have to drop from each floor from 1 to 100 in sequence,
requiring 100 drops in the worst case.
Now consider the case where we have two balls. Suppose we drop the first ball from floor n. If it
breaks we’re in the case where we have one ball remaining and we need to drop from floors 1 to n − 1
in sequence, yielding n drops in the worst case (the first ball is dropped once, the second at most n − 1
times). However, if it does not break when dropped from floor n, we have reduced the problem to
dropping from floors n + 1 to 100. In either case we must keep in mind that we’ve already used one
drop. So the minimum number of drops, in the worst case, is the minimum over all n.
You will write a program to determine the minimum number of drops required, in the worst case,
given B balls and an M -story building.
Input
The first line of input contains a single integer P , (1 ≤ P ≤ 1000), which is the number of data sets that
follow. Each data set consists of a single line containing three (3) decimal integer values: the problem
number, followed by a space, followed by the number of balls B, (1 ≤ B ≤ 50), followed by a space and
the number of floors in the building M , (1 ≤ M ≤ 1000).
Output
For each data set, generate one line of output with the following values: The data set number as a
decimal integer, a space, and the minimum number of drops needed for the corresponding values of B
and M .
Sample Input
4
1
2
3
4
2 10
2 100
2 300
25 900
Sample Output
1   4
2   14
3   24
4   10

这题就是很出名的扔鸡蛋问题，不过这道题改成了玻璃球。

想要找到，在最坏的情况下，我们所需要的检测次数最少来找到鸡蛋在哪一楼层之下，鸡蛋不会被摔碎，输出最少的次数。

一共有m个鸡蛋，n层楼,dp[m][n]表示有m个鸡蛋，需要检测的层数有n层。

首先我们要确立最坏的情况，

假设我们在1 to n层中任选一层扔下鸡蛋，假设在第i层扔下，1：如果鸡蛋在第i层碎掉了，还剩m-1个鸡蛋，现在只需要 在1 to
i-1层中检测，剩下i-1个楼层需要检测，dp[m][i] = dp[m-1][i-1] +
1,1表示第i层的检测。2：如果鸡蛋在第i层没有碎，还剩m个鸡蛋，现在只需要在i+1 to
n层中检测，剩下n-i个楼层需要检测，dp[m][i] = dp[m][n-1] +
1,1表示第i层的检测。最坏的情况就是，两种情况之下，所需要检测的次数最多的那一种情况。

然后找到在（1，n）层中，从哪层扔下所需次数最少的情况。

 1 #include<cstdio>
 2 #include<algorithm>
 3 using namespace std;
 4 int dp[1001][1001];
 5 int judge_(int a,int b){
 6     for(int i = 0; i <=b; ++i) {
 7         dp[0][i] = 0;//如果没有鸡蛋，需要的次数都为0
 8         dp[1][i] = i;//如果鸡蛋只有一个，那么需要的次数就是楼层数
 9     }
10     for(int i = 2; i <= a; ++i) {
11         dp[i][0] = 0;//如果没有楼层，所需要的次数是0
12         dp[i][1] = 1;//如果只有1个楼层，所需要的次数是1
13     }
14     for(int i = 2; i <= a; ++i) {//鸡蛋从2 to a 遍历
15         for(int j = 2; j <= b;j++) {//楼层从2， to b遍历，dp[i][j]表示，在有i个鸡蛋，j个楼层需要检测的情况下所需要的最小检测次数
16             int  t = 0x3f3f3f;
17             for(int k = 1; k <= j; ++k) {//找到1 to j从哪一个楼层扔下所需要的次数最少
18                  t = min(t,1 + max(dp[i-1][k-1],dp[i][j-k]));// max(dp[i-1][k-1],dp[i][j-k]) 找到碎和不碎的情况下，所需要的最大的次数，即最坏的情况
19             }
20             dp[i][j] = t;//将最小的次数赋值给在有i个鸡蛋，j个楼层需要检测的情况下的最小次数
21         }
22     }
23     return dp[a][b];//输出在有a个鸡蛋，b个楼层需要检测的情况下的需要的最小次数
24 }
25 int main()
26 {
27     int p;
28     scanf("%d",&p);
29     while (p--) {
30         int  n,a,b;
31         scanf("%d %d %d",&n,&a,&b);
32         printf("%d %d\n",n,judge_(a,b));
33     }
34     return 0;
35 }

贴一个写的比较好的博客吧

https://blog.csdn.net/joylnwang/article/details/6769160