生日蛋糕POJ 1190

POJ 生日蛋糕

（Tag 深搜 + 剪枝）

题目描述：
7月17日是Mr.W的生日，ACM-THU为此要制作一个体积为Nπ的M层生日蛋糕，每层都是一个圆柱体。
设从下往上数第i(1 <= i <= M)层蛋糕是半径为Ri, 高度为Hi的圆柱。当i < M时，要求Ri > Ri+1且Hi > Hi+1。
由于要在蛋糕上抹奶油，为尽可能节约经费，我们希望蛋糕外表面（最下一层的下底面除外）的面积Q最小。
令Q = Sπ
请编程对给出的N和M，找出蛋糕的制作方案（适当的Ri和Hi的值），使S最小。
（除Q外，以上所有数据皆为正整数）

Input
有两行，第一行为N（N <= 10000），表示待制作的蛋糕的体积为Nπ；第二行为M(M <= 20)，表示蛋糕的层数为M。

Output
仅一行，是一个正整数S（若无解则S = 0）。

Sample Input
100
2

Sample Output
68

思路分析：
说实话，刚看完这个题目我是没有什么思路的。题目说所有数据都为整数，这个条件其实暗示我们可以用穷举来做，但是怎么做，一脸懵逼……
所以这个题的关键就是，怎么枚举这些圆柱体的半径和高。
题目有个条件就是高度从上往下一定是递增的，那么，
从1，2，3……m层，所以m层的最小半径就是m
同理第m层的最小h也是m
卡出了下界，那么还要有上界，否则无法穷举。
考虑当只有一个圆柱体存在的时候，取N最大为10000，令h最小为1，那么r最大，此时r = 100，同理可以得到h的最大值为10000
以上就是dfs的初始值。

那么这个题就可以写成下面这样的代码：

/**
 * Name: 生日蛋糕
 * P_ID: POJ 1190
 * date: 2016-04-13
 */
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int N, M;
int best;//目前已经找到的最小S

//从上往下层数依次增大，最上边是第1层

//now代表当前所处的层数，sumS代表从M到now层一共已经计算进入的表面积（其中包含了顶面投影到最底层的一次计算完成的那个面积），sumV代表从M到now层一共已经计算进入的体积，r和h分别代表下一层（物理上其实是上面那层）的半径和高
void dfs(int now, int sumS, int sumV, int r, int h)
{
    if(now==0)
    {
        if(sumV==N && best>sumS)
            best = sumS;
        return;
    }
    for(int i=r-1; i>=now; i--)
    {
        if(now==M)
            sumS = i*i;//只有第一次调用，相当于初始化sumS的值，算进去了顶面积
        int maxH = h-1;
        for(int j=maxH; j>=now; j--)
        {
            dfs(now-1, sumS+i*j*2, sumV+i*i*j, i, j);
        }
    }
}


int main()
{
    scanf("%d", &N);
    getchar();
    scanf("%d", &M);
    getchar();
    best = 9999999;
    dfs(M, 0, 0, 100, 10000);
    if(best==9999999) best = 0;
    printf("%d\n", best);
    return 0;
}

以上代码看起来相当自然，样例也过得很不错，然而，交上去的结果是：
Time Limit Exceeded
超时了。
显然，以上的代码我们几乎没有做任何剪枝优化的工作，但是事实上有很多情况在计算到中间某一层时候就不必再计算下去了。

比较容易想到得是两种剪枝：
由于存在每一层r和h的最小取值下界，也就是说，从第1层到底i层，存在所能达到的最小的表面积leftMinS和所能占用的最小的体积leftMinV，
我们可以建立两个数组，一开始就初始化好，然后在每次dfs递归调用的时候，上去就先判断：
1. 如果当前已经计算进入的表面积加上剩下的层所能达到的最小表面之后，已经大于了目前的最优解best，那么return，不必做下去了，无用功
2. 如果当前已经计算计入的体积加上剩下的层所能达到的最小体积之后，还大于了目前的最优解best，那么return，不必做下去了，无用功
//以上两点其实利用了极限的思想，这种思想在找最优解的算法中需要剪枝时候是很常用的。所谓极限，就是提前“高瞻远瞩”，判断出这条路走到这儿就不必再走下去了，因为以后他一定没有目前的最优解更好。

基于以上两点考虑，我把代码改成这样：

/**
 * Name: 生日蛋糕
 * P_ID: POJ 1190
 * date: 2016-04-13
 */
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int N, M;
int best;
int leftMinS[22], leftMinV[22];//分别代表剩下的还没用遍历到的层（因为M层必须刚好用完），所能代表的最小的表面积（只算侧面）和最小体积

void dfs(int now, int sumS, int sumV, int r, int h)
{
    if(now==0)
    {
        if(sumV==N && best>sumS)
            best = sumS;
        return;
    }

    if(sumS+leftMinS[now]>best || sumV+leftMinV[now]>N)
        return;

    for(int i=r-1; i>=now; i--)
    {
        if(now==M)
            sumS = i*i;
        int maxH = min((N-leftMinV[now-1]-sumV)/(i*i), h-1);//这里其实也剪枝了一部分
        for(int j=maxH; j>=now; j--)
        {
            dfs(now-1, sumS+i*j*2, sumV+i*i*j, i, j);
        }
    }
}


int main()
{
    leftMinS[0] = 0;
    leftMinV[0] = 0;
    for(int i=1; i<22; i++)
    {
        leftMinS[i] = leftMinS[i-1] + i*i*2;//初始化从第一层到第i层所能做到的的最小表面积
        leftMinV[i] = leftMinV[i-1] + i*i*i;//初始化从第一层到第i层所能做到的的最小体积
    }
    scanf("%d", &N);
    getchar();
    scanf("%d", &M);
    getchar();
    best = 9999999;
    dfs(M, 0, 0, 100, 10000);
    if(best==9999999) best = 0;
    printf("%d\n", best);
    return 0;
}

信心满满的交上去，然而结果是：
Time Limit Exceeded
卧槽？还超时？
宝宝真心没办法了。

看看大神们的解法把：
第三种剪枝：

    if((2*(N-sumV)/r + sumS) >=best)
        return;

这是啥意思？
这句话的意思是说：如果把剩下的所有体积，全部用来只做成一个圆柱体，这种情况加所增加到表面积是最小的。
怎么推出来的呢？

    /**
     *  2*r*h=S
     *  r*r*h=V
     *  => V*2/r = S
     *  S + sumS >= best => return;
     */

推法好理解，但是不得不说，这个点子有点难想啊。。。

下面贴上最后的AC代码：

/**
 * Name: 生日蛋糕
 * P_ID: POJ 1190
 * date: 2016-04-13
 */
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int N, M;
int best;
int leftMinS[22], leftMinV[22];

void dfs(int now, int sumS, int sumV, int r, int h)
{
    if(now==0)
    {
        if(sumV==N && best>sumS)
            best = sumS;
        return;
    }

    if(sumS+leftMinS[now]>best || sumV+leftMinV[now]>N)
        return;

    /**
     *  2*r*h=S
     *  r*r*h=V
     *  => V*2/r = S
     *  S + sumS >= best => return;
     */
    if((2*(N-sumV)/r + sumS) >=best)
        return;

    for(int i=r-1; i>=now; i--)
    {
        if(now==M)
            sumS = i*i;
        int maxH = min((N-leftMinV[now-1]-sumV)/(i*i), h-1);
        for(int j=maxH; j>=now; j--)
        {
            dfs(now-1, sumS+i*j*2, sumV+i*i*j, i, j);
        }
    }
}


int main()
{
    leftMinS[0] = 0;
    leftMinV[0] = 0;
    for(int i=1; i<22; i++)
    {
        leftMinS[i] = leftMinS[i-1] + i*i*2;
        leftMinV[i] = leftMinV[i-1] + i*i*i;
    }
    scanf("%d", &N);
    getchar();
    scanf("%d", &M);
    getchar();
    best = 9999999;
    dfs(M, 0, 0, 100, 10000);
    if(best==9999999) best = 0;
    printf("%d\n", best);
    return 0;
}

趁着这道题，总结一下剪枝：
作为初入ACM的小白来说，这是我遇到的第一道比较夸张的剪枝题目，
这里注明一些剪枝的特点：

剪枝一般不会关注某个小的分支的不同情况，而是着眼于大局，确切的说，是“高瞻远瞩”，也就是说，从某一步开始，就断定，这条路以后必定是条死路或一定不如当前的最优解，不必再走下去了。

有一个以此题为例分析剪枝的好文：链接