HDU 1069 Monkey and Banana（线性DP）

Description

 

A group of researchers are designing an experiment to test the IQ of a monkey. They will hang a banana at the roof of a building, and at the mean time, provide the monkey with some blocks. If the monkey is clever enough, it shall
 be able to reach the banana by placing one block on the top another to build a tower and climb up to get its favorite food.

The researchers have n types of blocks, and an unlimited supply of blocks of each type. Each type-i block was a rectangular solid with linear dimensions (xi, yi, zi). A block could be reoriented so that any two of its three dimensions determined the dimensions
 of the base and the other dimension was the height.
They want to make sure that the tallest tower possible by stacking blocks can reach the roof. The problem is that, in building a tower, one block could only be placed on top of another block as long as the two base dimensions of the upper block were both strictly
 smaller than the corresponding base dimensions of the lower block because there has to be some space for the monkey to step on. This meant, for example, that blocks oriented to have equal-sized bases couldn't be stacked.

Your job is to write a program that determines the height of the tallest tower the monkey can build with a given set of blocks.

 

Input
The input file will contain one or more test cases. The first line of each test case contains an integer n,

representing the number of different blocks in the following data set. The maximum value for n is 30.

Each of the next n lines contains three integers representing the values xi, yi and zi.

Input is terminated by a value of zero (0) for n.

Output
For each test case, print one line containing the case number (they are numbered sequentially starting from 1) and the height of the tallest possible tower in the format "Case case: maximum height = height".

 

Sample Input

1
10 20 30
2
6 8 10
5 5 5
7
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
6 6 6
7 7 7
5
31 41 59
26 53 58
97 93 23
84 62 64
33 83 27
0

 

Sample Output

Case 1: maximum height = 40
Case 2: maximum height = 21
Case 3: maximum height = 28
Case 4: maximum height = 342

看了几篇博客想了好久才差不多理解...https://blog.csdn.net/lishuhuakai/article/details/8060529 https://blog.csdn.net/qq_34374664/article/details/52249801 这两篇讲的更详细一点

首先是对于输入的长方体的处理，长方体长宽高最多三者两两不同，这里有一个比较重要的思想就是把一个长方体拓展成三个长方体，每个长方体的高是原长方体的长/宽/高。注意，拓展成六个是错误的，因为高一样，剩下两条边x作为长y作为宽和x作为宽y作为长是一样的。在这里可以选择把两边里较长的赋值给x，较短的给y，为了方便判定（当然也可以随机，只不过判定的时候写的会麻烦一点）。为了优化时间，这里可以对结构体数组进行排序（按照面积递减，按照x，y的值递减都可以，按照面积的话比当前面积小的肯定不可能作为底座，按照x，y的话最长边比当前矩形最长边小的肯定也不可能），然后进行线性dp就可以了，dp[i]=max(dp[i],dp[k]+h[i])。注意初始化，假设一个长方体没有任何底座，他自己的高就是最终的高，同时也要注意，排了序以后在当前长方体前面的也不一定能成为底座，还得再判定一下。

#include <bits/stdc++.h>
using namespace std;
struct rectangle
{
    int x;
    int y;
    int z;
    int size;
};
bool cmp(rectangle a,rectangle b)
{
//    if(a.x!=b.x)return a.x>b.x;
//    else return a.y>b.y;
    return a.size>b.size;
 }
vector<rectangle>v;
int n;
//dp[i]:以第i个为顶的最大高度 dp[i]=max(dp[i],dp[k]+h[i])
int dp[];

int main()
{
    int i,j;
    int cnt=;
    while(scanf("%d",&n)&&n)
    {
        cnt++;
        v.clear();
        rectangle occ;
        v.push_back(occ);
        for(i=;i<=n;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            rectangle temp;
            temp.z=x;
            temp.x=max(y,z);
            temp.y=min(y,z);
            temp.size=y*z;
            v.push_back(temp);
            temp.z=y;
            temp.x=max(x,z);
            temp.y=min(x,z);
            temp.size=x*z;
            v.push_back(temp);
            temp.z=z;
            temp.x=max(x,y);
            temp.y=min(x,y);
            temp.size=x*y;
            v.push_back(temp);
        }
        sort(v.begin()+,v.end(),cmp);//不要sort占位的
        for(i=;i<v.size();i++)//初始化！！假设一个长方体没有任何底座，他自己的高就是最终的高
        {
            dp[i]=v[i].z;
        }
        int ans=dp[];
        for(i=;i<v.size();i++)
        {
            for(j=;j<i;j++)//只有i之前的能作为底座
            {
                if(v[j].x>v[i].x&&v[j].y>v[i].y)
                {
                    dp[i]=max(dp[i],dp[j]+v[i].z);

                }
                ans=max(ans,dp[i]);
            }
        }

        printf("Case %d: maximum height = %d\n",cnt,ans);
    }
    return ;
}