[刷题]Google Code Jam 2017 - Round1 C Problem A. Ample Syrup

最新推荐文章于 2018-05-20 01:49:46 发布

转载最新推荐文章于 2018-05-20 01:49:46 发布 · 221 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/xienaoban/p/6798052.html

探讨了如何通过选择特定的煎饼堆栈以最大化暴露表面面积的问题，并提供了一种有效的算法解决方案。该问题来源于无限煎饼屋厨房的订单场景。

https://code.google.com/codejam/contest/3274486/dashboard

Problem

The kitchen at the Infinite House of Pancakes has just received an order for a stack of K pancakes! The chef currently has N pancakes available, where N ≥ K. Each pancake is a cylinder, and different pancakes may have different radii and heights.

As the sous-chef, you must choose K out of the N available pancakes, discard the others, and arrange those K pancakes in a stack on a plate as follows. First, take the pancake that has the largest radius, and lay it on the plate on one of its circular faces. (If multiple pancakes have the same radius, you can use any of them.) Then, take the remaining pancake with the next largest radius and lay it on top of that pancake, and so on, until all K pancakes are in the stack and the centers of the circular faces are aligned in a line perpendicular to the plate, as illustrated by this example:

A stack of pancakes with varying radii and thicknesses, obeying the rules in the statement.

You know that there is only one thing your diners love as much as they love pancakes: syrup! It is best to maximize the total amount of exposed pancake surface area in the stack, since more exposed pancake surface area means more places to pour on delicious syrup. Any part of a pancake that is not touching part of another pancake or the plate is considered to be exposed.

If you choose the K pancakes optimally, what is the largest total exposed pancake surface area you can achieve?

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each begins with one line with two integers N and K: the total number of available pancakes, and the size of the stack that the diner has ordered. Then, N more lines follow. Each contains two integers Ri and Hi: the radius and height of the i-th pancake, in millimeters.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the maximum possible total exposed pancake surface area, in millimeters squared. y will be considered correct if it is within an absolute or relative error of 10-6 of the correct answer. See the FAQ for an explanation of what that means, and what formats of real numbers we accept.

Limits

1 ≤ T ≤ 100.
1 ≤ K ≤ N.
1 ≤ Ri ≤ 106, for all i.
1 ≤ Hi ≤ 106, for all i.

Small dataset
1 ≤ N ≤ 10.

Large dataset
1 ≤ N ≤ 1000.

Sample

Input

Output

Case #1: 138230.076757951
Case #2: 150796.447372310
Case #3: 43982.297150257
Case #4: 625.176938064

In Sample Case #1, the “stack” consists only of one pancake. A stack of just the first pancake would have an exposed area of π × R02 + 2 × π * R0 × H0 = 14000π mm2. A stack of just the second pancake would have an exposed area of 44000π mm2. So it is better to use the second pancake.

In Sample Case #2, we can use both of the same pancakes from case #1. The first pancake contributes its top area and its side, for a total of 14000π mm2. The second pancake contributes some of its top area (the part not covered by the first pancake) and its side, for a total of 34000π mm2. The combined exposed surface area is 48000π mm2.

In Sample Case #3, all of the pancakes have radius 100 and height 10. If we stack two of these together, we effectively have a single new cylinder of radius 100 and height 20. The exposed surface area is 14000π mm2.

In Sample Case #4, the optimal stack uses the pancakes with radii of 8 and 9.

Key

可以用DP做。对DP还是不太熟练，一开始没排序，于是考虑的情况就多一些，总有小规模案例不正确，偏小。后来排个序考虑起来就方便多了。时间复杂度O(n2)。难倒是不难，之前没Debug出来才是最气的。时间复杂度O(n2)。

其实贪心就可以了，同学贪心做的但是时间复杂度也要O(n2)，就是少很多赋值。

Code

#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long lld;

const int maxn = 1000 + 10;
const long double pi = 3.1415926535897932;

int T, N, K;
struct RH { lld R, H, A; } arr[maxn];
lld dp[maxn];

bool cmp(RH &a, RH &b) {
    if (a.R == b.R) return a.H > b.H;
    return a.R > b.R;
}

int main()
{
    //freopen("A-small-practice.in", "r", stdin);
    //freopen("A-small-practice.out", "w", stdout);
    ios::sync_with_stdio(false);
    cin >> T;
    for (int now_case = 1; now_case <= T; ++now_case) {
        cin >> N >> K;
        for (int i = 0; i < N; ++i) {
            cin >> arr[i].R >> arr[i].H;
            arr[i].A = arr[i].R * arr[i].H * 2;
            arr[i].R *= arr[i].R;
        }
        sort(arr, arr + N, cmp);
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < N; ++i) {
            for (int j = K; j > 1; --j) {
                if (dp[j - 1] == 0) continue;
                lld tmp = dp[j - 1] + arr[i].A;
                if (dp[j] < tmp) dp[j] = tmp;
            }
            lld tmp = arr[i].A + arr[i].R;
            if (dp[1] < tmp) dp[1] = tmp;
        }
        cout << "Case #" << now_case << ": " << fixed << setprecision(9) << ((long double)dp[K] * pi) << endl;
    }
    return 0;
}