HDU - 1069 Monkey and Banana（DP）

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”.

输入n种方块，并且每种都无限提供，让你cos一只聪明的猴子把他们叠起来，要求上面方块底面的长宽要严格小于下面方块的顶部长宽，问最高叠多高。

虽然题目告诉你无限提供方块，但是因为有“上面的方块底面长宽严格小于下面的顶部长宽”这一限制，实际上每种方块最多用6次（6面）。我本来以为是三次，因为一个长方体实际上每两面是对称的，但是仔细一想这题里长宽是限死的，所以其实对称的两面并不等价。

思考dp，当我们堆好了两堆，并且发现堆1的顶部长宽都严格大于堆2底部长宽，就可以快乐的把它们凑成一堆不用重新算了。

所以把方块的6种情况都摊开来排个序，然后快乐的取最优堆堆堆，合并合并合并，就得到了答案。

至于排序是升序还是降序其实无所谓…毕竟你不是真的猴子，你可以选择从上往下堆（雾）。

ac代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 30 * 6 + 5;
int n, dp[maxn];

struct Block {
	int x, y, h;
} b[maxn];

bool cmp(Block &a, Block &b) {
	if(a.x == b.x) {
		return a.y < b.y;
	}
	return a.x < b.x;
}

int main() {
	int kase = 0;
	while(~scanf("%d", &n) && n) {
		memset(dp, 0, sizeof(dp));

		int x, y, h, g = 0;
		for(int i = 0; i < n; i++) {
			scanf("%d%d%d", &x, &y, &h);
			for(int j = 0; j < 3; j++) {
				b[g].x = x, b[g].y = y, b[g].h = h;
				swap(x, h), ++g;
				b[g].x = x, b[g].y = y, b[g].h = h;
				swap(x, y), ++g;
			}
		}

		sort(b, b + g - 1, cmp);

		int ans = 0;
		for(int i = 0; i < g - 1; i++) {
			//dp[i]代表以i号方块为底部
			dp[i] = b[i].h;
			for(int j = 0; j < i; j++) {
				//然后在小于它宽高的里面取个最优
				//从小到大dp，在求小的部分的时候已经求出部分最优解，这时候合并两堆就完事了
				if(b[i].x > b[j].x && b[i].y > b[j].y) {
					dp[i] = max(dp[i], dp[j] + b[i].h);
				}
			}
			//顺手记录个最大值
			ans = max(ans, dp[i]);
		}

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