Monkey and Banana HDU - 1069 [ 结构体排序+DP最长不上升子序列 ] 详细题解

Bertha 。 2021-08-28 17:25 327阅读 0赞

### 题解目录 ###

*   *   *  1.题目
         *  2.题意
         *  3.思路
         *  4.代码

### 1.题目 ###

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

### 2.题意 ###

给你n个长方体的长a宽b高c，每一个型号的长方体可以用无限多个。用这些长方体来堆一个高度最高的塔，每一个长方体的长宽大于上面一个长方体的长宽。

### 3.思路 ###

一个长方形共有三种方法，n个就有3\*n放法。 每一个长方体的长宽必须严格大于上面一个长方体的长宽，因此每次让底面的两条边，大的当做长，小的当做宽。对每个长方体进行结构体排序，先按照长度排，长相等按宽排（这样可以满足对要进行DP的积木块按底面积从大往小排）。接下来的问题就是找到一个递减的子序列，使得子序列的高度和最大即可。类似于最长不下降子序列 链接: [点击这里][Link 1].  
1.dp\[i\]表示表示以第i块积木为顶的塔的最大高度；  
2.对于每个dp\[i\]有两种状态。  
(1) 在dp\[i\]的前面可以找到dp\[j\] ( i<j ),即满足第i块积木的底面积小于第j块积 木的底面积，使得第i块积木可以放到第j块积木上形成更高的塔。状态转移方程 dp\[i\]=dp\[j\]+a\[i\].h. 。  
(2) 在第i块积木的前面找不到符合条件的积木j，那么以它自己为塔最下面的积木块。dp\[i\]=a\[i\].h。（这也是初始边界）即每块积木以自己为塔底进行重新累积。  
3.状态转移方程 dp\[i\] = max(dp\[i\], dp\[j\] + a\[i\].h)。

### 4.代码 ###

#include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    const int maxn = 105;
    struct Node
    { 
    	int x, y, h;
    }a[maxn];
    bool cmp(Node a, Node b)
    { 
    	if (a.x != b.x)      先按照长度排
    		return a.x > b.x;
    	else
    		return a.y > b.y;   长相等按宽排
    }
    int dp[maxn];  //表示以第i块积木为顶的塔的最大高度
    int main()
    { 
    	int n, cas = 0;
    	while (cin >> n && n)
    	{ 
    		memset(dp, 0, sizeof(dp));
    		int x, y, z;
    		int k = 1;
    		while (n--)
    		{ 
    			cin >> x >> y >> z;
    			a[k].x = max(x, y);   ///积木的长
    			a[k].y = min(x, y);   ///积木的宽
    			a[k].h = z;           ///积木的高
    			k++;
    			a[k].x = max(x, z);  
    			a[k].y = min(x, z);  
    			a[k].h = y;           
    			k++;
    			a[k].x = max(y, z);
    			a[k].y = min(y, z);
    			a[k].h = x;
    			k++;
    		}
    		sort(a + 1, a + k, cmp);
    		for (int i = 1; i < k; i++)
    		{ 
    			dp[i] = a[i].h;      ///边界
    		}
    		int ans = 0;
    		for (int i = 1; i < k; i++)
    		{ 
    			for (int j = 1; j < i; j++)
    			{ 
    				if (a[j].x > a[i].x&&a[j].y > a[i].y)
    				{ 
    					dp[i] = max(dp[i], dp[j] + a[i].h); 状态转移方程
    				}
    				ans = max(ans, dp[i]);
    			}
    		}
    		printf("Case %d: maximum height = %d\n", ++cas, ans);
    	}
    	return 0;
    }

参考博客：链接: [点击这里][Link 2].

[Link 1]: https://blog.csdn.net/weixin_45629285/article/details/105599495
[Link 2]: https://blog.csdn.net/qq_34374664/article/details/52249801