HDU 1069 DP

/****************************************************************************************************
    经典DP，LIS，最长上升子序列
****************************************************************************************************/
#include <iostream>
#include <iomanip>
#include <functional>
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <limits>
#include <memory>
#include <string>
#include <vector>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
using namespace std;

#define LOWBIT(x) ( (x) & ( (x) ^ ( (x) - 1 ) ) )
#define CLR(x, k) memset((x), (k), sizeof(x))
#define CPY(t, s) memcpy((t), (s), sizeof(s))
#define SC(t, s) static_cast<t>(s)
#define LEN(s) static_cast<int>( strlen((s)) )
#define SZ(s) static_cast<int>( (s).size() )

typedef double LF;
//typedef long long LL;		//GNU C++
//typedef unsigned long long ULL;
typedef __int64 LL;		//Visual C++ 2010
typedef unsigned __int64 ULL;

typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<double, double> PDD;

typedef map<int, int>::iterator MI;
typedef vector<int>::iterator VI;
typedef list<int>::iterator LI;
typedef set<int>::iterator SI;

template <typename T>
T sqa(const T &x)
{
	return x * x;
}
template <typename T>
T gcd(T a, T b)
{
	if (!a || !b)
	{
		return max(a, b);
	}
	T t;
	while (t = a % b)
	{
		a = b;
		b = t;
	}
	return b;
}
template <typename T>
T ext_gcd(T a, T b, T &x, T &y)
{
	if (!b)
	{
		x = 1;
		y = 0;
		return a;
	}
	T d = ext_gcd(b, a % b, x, y);
	T t = x;					
	x = y;
	y = t - a / b * y;
	return d;
}
template <typename T>
T invmod(T a, T p)
{
	LL inv, y;
	ext_gcd(a, p, inv, y);
	inv < 0 ? inv += p : 0; 
	return inv;
}

const int INF_INT = 0x3f3f3f3f;
const LL INF_LL = 0x7fffffffffffffffLL;		//15f
const double oo = 10e9;
const double eps = 10e-7;
const double PI = acos(-1.0);

#define ONLINE_JUDGE

const int MAXN = 504;
const int loop[][3] = {{0, 1, 2}, {0, 2, 1}, {2, 1, 0}};

int n, cube[MAXN][3];
int dp[MAXN];
struct Node
{
	int x, y, z;
	int s;
	bool operator < (const Node &rhs) const
	{
		return x < rhs.x && y < rhs.y || x < rhs.y && y < rhs.x;
	}
	bool operator > (const Node &rhs) const
	{
		return x > rhs.x && y > rhs.y || x > rhs.y && y > rhs.x;
	}
}node[MAXN], tmp[MAXN];

bool inline nodeCmp(const Node &na, const Node &nb)
{
	return na.s < nb.s;
}
void ace()
{
	int cas = 1;
	int ncnt;
	while (cin >> n, n)
	{
		for (int i = 0; i < n; ++i)
		{
			for (int j = 0; j < 3; ++j)
			{
				cin >> cube[i][j];
			}
		}
		for (int i = 0; i < n; ++i)
		{
			for (int j = 0; j < 3; ++j)	//因为立方体是无限的，但是x,y相同的立方体只可能出现一次
			{
				int k = i * 3 + j;
				node[k].x = cube[i][ loop[j][0] ];
				node[k].y = cube[i][ loop[j][1] ];
				node[k].z = cube[i][ loop[j][2] ];
				node[k].s = node[k].x * node[k].y;
			}
		}
		n *= 3;
		sort(node, node + n, nodeCmp);	//对面积排序，尽量使小面积的在前面
		ncnt = 0;
		CLR(dp, 0);
		dp[0] = node[0].z;	//dp数组记录在当前第i个立方体放入后，以第i个立方体为底的高度
		for (int i = 1; i < n; ++i)
		{
			int buf = 0;
			for (int j = 0; j < i; ++j)	
			{
				if (node[i] > node[j] && buf < dp[j])	//显然应该找之前最高的，因为只要保证node[i] > node[j]
				{										//那么i之前的状态对于i来说是无关的	
					buf = dp[j];
				}
			}
			dp[i] = buf + node[i].z;
		}
		int res = 0;
		for (int i = 0; i < n; ++i)
		{
			res = max(res, dp[i]);
		}
		printf("Case %d: maximum height = %d\n", cas++, res);
	}
	return ;
}
int main()
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	ace();
	return 0;
}