LIS的简单应用：UVA-437

上一次紫芝详细地介绍了动态规划中的经典问题LIS，今天我们抽出一个类似思想的简单题目进行实践练习。

The Tower of Babylon（巴比伦塔）

Perhaps you have heard of the legend of the Tower of Babylon. Nowadays many details of this tale have been forgotten. So now, in line with the educational nature of this contest, we will tell you the whole story:

你可能对巴比伦的传说有所耳闻，但如今诸多细节早已随风而逝。现在为了与比赛的教育目的相一致，我们将还原整个故事：

The babylonians had 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.

巴比伦人有 n 种无限供给的砖块，每个砖块 i 是三边为 xi，yi，zi 的长方体，可以以任意两边构成底，第三边为高。

They wanted to construct the tallest tower possible by stacking blocks. The problem was 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. 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 babylonians can build with a given set of blocks.

作为程序员的你来写个bug看看用他给的砖能堆多高。

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.

输入：多组数据。每组第一行给出种类数 n，最大30；接下来 n 行每行给出这种砖的长宽高。输入以n==0结束。

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’

输出：对于每组数据输出最高塔的高度值，格式Case要求见样例。

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

首先建议自己思考、编程实现并提交~

其实跟LIS还是不完全一样的（废话），但个人觉得思想都是对于每个元素都查一遍他前头有几个符合条件的。

简单再现一下我个人的思考过程：

啊这是单减序列啊 ----> 如果就按他输入的顺序扫一遍，遇到“大小中”这样的顺序我这个“中”好像插不进去啊 ----> 那先排个序？ ----> 怎么排啊？俩边？面积？ ----> 诶按面积排会不会出乱子呢？最后要严格递减的，那排后面的双边都小，肯定比前面的面积小啊；不在这个序列里的人他站哪都无所谓吧…… ----> 开始编程

放出蒟蒻代码：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <iostream>
 #include <vector>
 using namespace std;

 struct block
 {
     int a;
     int b;
     int height;
     block(int x, int y, int z){a = x; b = y; height = z;}
 };

 struct cmp
 {
     bool operator() (const block& x, const block& y)
     {
         return x.a * x.b > y.a * y.b;
     }
 };

 bool yes(block x, block y)
 {
     return (x.a > y.a && x.b > y.b) || (x.a > y.b && x.b > y.a);
 }

 int main()
 {
     int n, kase = ;
     while (~scanf("%d", &n) && n)
     {
         vector <block> v;
         for (int i = ; i < n; i++)
         {
             int a, b, c;
             scanf("%d%d%d", &a, &b, &c);
             //每块都有三种用法
             v.push_back(block(a,b,c));
             v.push_back(block(a,c,b));
             v.push_back(block(b,c,a));
         }

         sort(v.begin(), v.end(), cmp());

         int ans = v[].height;
         int dp[] = {};
         for (int i = ; i < v.size(); i++)
         {
             dp[i] = v[i].height;//这是不能省的一步
             //万一前面没有一个可以匹配的，它本身高度就是本序列的一血
             for (int j = ; j < i; j++)//前面扫荡一遍
                 if (yes(v[j], v[i]))//双边严格小于
                     dp[i] = max(dp[i], dp[j] + v[i].height);
             ans = max(ans, dp[i]);
         }

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

刘汝佳大爷给的教程是用记忆化搜索做的，将此题归类为DAG上的最长路问题。我稍加注释，下面贴上代码大家一起观摩~

 // UVa437 The Tower of Babylon

 // Rujia Liu

 // 算法：DAG上的最长路，状态为(idx, k)，即当前顶面为立方体idx，其中第k条边（排序后）为高

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 using namespace std;

 #define REP(i,n) for(int i = 0; i < (n); i++)
 //此处把for循环宏定义了一下，下面就比较好写

 const int maxn =  + ;

 int n, blocks[maxn][], d[maxn][];

 void get_dimensions(int* v, int b, int dim) {

   int idx = ;

   REP(i,) if(i != dim) v[idx++] = blocks[b][i];
 }

 int dp(int i, int j) {

   int& ans = d[i][j];
   //加了&以后下面对ans的读写修改就相当于对d[i][j]的修改

   if(ans > ) return ans;

   ans = ;

   int v[], v2[];

   get_dimensions(v, i, j);
   //这个j的用途就是决定一下哪个边作为高

   REP(a,n) REP(b,) {

     get_dimensions(v2, a, b);

     if(v2[] < v[] && v2[] < v[]) ans = max(ans, dp(a,b));
     //因为他的边存的时候就是排好序的，故不会纠结旋转90°会不会成立的问题

   }

   ans += blocks[i][j];

   return ans;

 }

 int main() {

   int kase = ;

   while(scanf("%d", &n) ==  && n) {

     REP(i,n) {

       REP(j,) scanf("%d", &blocks[i][j]);

       sort(blocks[i], blocks[i]+);
       //将三边由小到大排序
     }

     memset(d, , sizeof(d));
     //这个d就是个dp数组，d[i][j]表示：
     //i种类的砖以第j条边做高，且这块砖作为塔顶时，能达到的最大高度

     int ans = ;

     REP(i,n) REP(j,) ans = max(ans, dp(i,j));//这里是个二重循环

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

   }

   return ;
 }