Monkey and Banana

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 16364    Accepted Submission(s): 8704

 

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. 

InputThe 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. 
OutputFor 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

题解：    emmm，这篇文章其实很好理解，大概和汉诺塔一样，小在上，大在下，只是这是长方体，
            要求：上面的长方体的底边必须小于下面的。
            看第一组输入输出，10 20 30     下：30 20 10 上：20 10 30 注意我写的边的对应关系。
            所以你很容易想到，只要是给出三个数，就可以按大小排序整出来三组；
                    大/中/小   大/小/中   中/小/大
            然后按照三个数中的第一个和第二个数开始排序，这让我想起来一个很久之前写的题，
            好像是火柴排序怎么怎么样，还有个题是时间排排序啥的。记不清了，差不多就是这个先排序的思路。
            排好了之后怎么求那个最大的高度？？我从上往下，比较第一组的第二个数和下面的每一组的第一个数
            如果大，就sum+高度。这样不行哦，做的这么多题，思路无非就是正着写和倒着写。所以倒着比较。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
struct stu
{
    int a;
    int b;
    int c;
}tree[100];//结构体里存仨数
int tired[100];//倒着写不能改变tree.c的值，所以用这个来变化
bool cmp(const stu &x,const stu &y)//一个判断
{
    if(x.a>y.a)
        return true;
    if(x.a==y.a&&x.b>y.b)
        return true;
    return false;
}

int main()
{
    int n;
    int node=0;
    while(~scanf("%d",&n))
    {
        if(n==0)
            break;
        int three[3];
        int k=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d%d",&three[0],&three[1],&three[2]);//这里是我说的存
            sort(three,three+3);
            tree[k].a=three[2];
            tree[k].b=three[1];
            tree[k].c=three[0];
            k++;
            tree[k].a=three[2];
            tree[k].b=three[0];
            tree[k].c=three[1];
            k++;
            tree[k].a=three[1];
            tree[k].b=three[0];
            tree[k].c=three[2];
            k++;
        }
        sort(tree,tree+k,cmp);
        for(int i=0;i<k;i++)
            tired[i]=tree[i].c;
        for(int j=k-2;j>=0;j--)
        {
            for(int h=j+1;h<k;h++)//从后两位开始！！！！！！！！！！！
            {
                if(tree[j].a>tree[h].a&&tree[j].b>tree[h].b)//这样比较能先得到最近的能当成底的长方体
                {
                    if(tired[j]<tired[h]+tree[j].c)//动态变化
                        tired[j]=tired[h]+tree[j].c;
                }
            }
        }
        node++;
        int max=tired[0];
        for(int j=0;j<k;j++)//每次变化都会带来新的值，所以，不一定在哪组里就会有那个最大值
        {
            if(max<tired[j])
                max=tired[j];
        }
         printf("Case %d: maximum height = %d\n",node,max);
    }
    return 0;
}

 

今天也是元气满满的一天，good luck！