Monkey and Banana-A group of researchers are designing an experiment to test the IQ of a monkey...

题目描述：

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

    /**
     * 难度_中等题
     * 思路：这个题就是变形的最长递增子序列。所以难点就是能想到这种转换。
     * 具体做法：
     *      理解：
     * 
     *      step1:输入。
     *      题目中提到，“可以重新定向块，使其三维中的任何两个确定基部的尺寸，另一个尺寸是高度。”，所以将每一个立方体保存成６种状态。  
     * 
     *      step2:排序。
     *      将长度大的排到前面，长度相同时，宽度大的排到前面。
     * 
     *      step3:动态规划
     *      dp[i]表示包括第i个状态的方块，能达到的最高高度。
     *      详情见代码中的备注有“dp代码块”的代码。
     */
    #include<iostream>
    #include<algorithm>
    #include<stdio.h>

    using namespace std;

    int const N = 200;

    struct State{
        int l,w,h;//长宽高
        State(){}
    };

    bool cmp(State s1,State s2){
        if(s1.l!=s2.l){
            return s1.l>s2.l;
        }else{
            return s1.w>s2.w;
        }
        
    }

    int  Max(int a,int b){
        return a>b? a:b;
    }

    int main(){
        int n;
        int No = 1;//输出结果的序号
        while(cin>>n){
            if(n==0) break;
            State lib[N];
            int index = 0;
            for(int i=0 ;i<n;i++){
                int l,w,h;
                cin>>l>>w>>h;

                lib[index].l=l,   lib[index].w=w,   lib[index].h=h;
                index++;
                lib[index].l=l,   lib[index].h=w,   lib[index].w=h;
                index++;

                lib[index].w=l,   lib[index].l=w,   lib[index].h=h;
                index++;
                lib[index].w=l,   lib[index].h=w,   lib[index].l=h;
                index++;

                lib[index].h=l,   lib[index].l=w,   lib[index].w=h;
                index++;
                lib[index].h=l,   lib[index].w=w,   lib[index].l=h;
                index++;
            }
            sort(lib,lib+index,cmp);

            int dp[N] = {0};
            dp[0] = lib[0].h;//初始化

            //*******************dp代码段******************************
            for(int i=1;i<index;i++){
                int tMax = 0;
                for(int j=i-1;j>=0;j--){//在前面找一个可以放下当前块的状态。
                    if(lib[j].l>lib[i].l && lib[j].w>lib[i].w){
                        tMax = Max(dp[j],tMax);
                    }
                }
                dp[i] = lib[i].h + tMax;
            }

            int resMax = 0;
            for(int i=0;i<index;i++){
                resMax = Max(resMax,dp[i]);
            }
            //*******************dp代码段******************************

            printf("Case %d: maximum height = %d\n",No,resMax);
            No++;

        }
        return 0;
    }