POJ 3783 Balls (线性dp 智力题)

Balls

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 664		Accepted: 463

Description

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 10 
2 2 100 
3 2 300 
4 25 900

Sample Output

1 4
2 14
3 24
4 10

Source

Greater New York Regional 2009

题目链接：http://poj.org/problem?id=3783

题目大意：b个球，m层楼，有一个分界楼层k，当楼层大于等于k时扔下球球会碎，问在最坏的情况下，最少扔几次能确定这个k

题目分析：dp[i][j]表示第i层还剩j个球且在最坏的情况下确定k需要的次数，则我们可以枚举中间的k，假设：
第k层落下碎了则dp[i][j] = dp[k - 1][j - 1]表示第k层确认过了，还有k－1层，因为碎了一个，还剩j－1个
第k层落下没碎则dp[i][j] = dp[i - k][j]表示第k层及以下的层扔下去都不会碎，还剩i－k层未确定，因为没碎，还有j个球
因为我们要求最坏的情况下的最小次数，则dp[i][j] = min(dp[i][j]，max(dp[k - 1][j - 1], dp[i - k][j]) + 1)  加1是因为本次扔球也算作一次
按这题的数据10^3 * 10^3 * 50一秒肯定T，结果62ms就水过了，离线居然也只用了157ms。

离线：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int const INF = 0xffffff;
int dp[1005][55];

void cal()
{
    for(int i = 0; i <= 1001; i++)
        for(int j = 0; j <= 51; j++)
            dp[i][j] = INF;
    for(int i = 0; i <= 51; i++)
        dp[0][i] = 0;
    for(int i = 1; i <= 1001; i++)
        for(int j = 1; j <= 51; j++)
            for(int k = 1; k <= i; k++)
                dp[i][j] = min(dp[i][j], max(dp[i - k][j], dp[k - 1][j - 1]) + 1);
}

int main()
{
    int T, ca, b, m;
    cal();
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d %d %d", &ca, &b, &m);
        printf("%d %d\n", ca, dp[m][b]);
    }
}

在线：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int const INF = 0xffffff;
int dp[1005][55];

int main()
{
    int T, ca, b, m;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d %d %d", &ca, &b, &m);
        for(int i = 0; i <= m; i++)
            for(int j = 0; j <= b; j++)
                dp[i][j] = INF;
        for(int i = 0; i <= b; i++)
            dp[0][i] = 0;
        for(int i = 1; i <= m; i++)
            for(int j = 1; j <= b; j++)
                for(int k = 1; k <= i; k++)
                    dp[i][j] = min(dp[i][j], max(dp[i - k][j], dp[k - 1][j - 1]) + 1);
        printf("%d %d\n", ca, dp[m][b]);
    }
}