ZOJ 1093 Monkey and Banana

和The Tower of Babylon一模一样，这里给出两个代码：一个是直接做的，不说了；

另一个是参考了Staginner大牛的方法，做了一个优化：将底面积按大到小排序，这样搜索时，只用从当前石块的下一个石块开始即可，最后打印 f[1] 即可，复杂度降低很明显的。

/* 方法二实际上有个错误，具体见后述。*/

方法一

 1 # include <stdio.h>
 2 # include <memory.h>
 3 # include <stdlib.h>
 4 
 5 typedef struct {
 6     int x, y, h;
 7 }block;
 8 
 9 int n;
10 int f[92];
11 block a[92];
12 
13 int cmp(const void *x, const void *y)
14 {
15     return (*(int *)x<*(int *)y ? -1:1);
16 }
17 
18 int dp(int i);            /* 记忆化搜索，f[i] = dp(i)； f[i]定义为从第i个箱子出发所能到达的最大高度 */
19 
20 int main()
21 {
22     int tmp[3], i, maxH, cnt;
23     
24     cnt = 0;
25     while (~scanf("%d", &n))
26     {
27         if (!n) break;
28         
29         ++cnt;
30         n *= 3;
31         for ( i = 1; i <= n; ++i)
32         {
33             scanf("%d%d%d", &tmp[0], &tmp[1], &tmp[2]);
34             qsort(tmp, 3, sizeof(int), cmp);
35             a[i].x = tmp[0]; a[i].y = tmp[1]; a[i].h = tmp[2];  ++i;
36             a[i].x = tmp[1]; a[i].y = tmp[2]; a[i].h = tmp[0];  ++i;
37             a[i].x = tmp[0]; a[i].y = tmp[2]; a[i].h = tmp[1];
38         }
39         
40         memset(f, 0, sizeof(f));
41         
42         maxH = 0;
43         for (i = 1; i <= n; ++i)
44             if (maxH < dp(i)) maxH = f[i];
45         
46         printf("Case %d: maximum height = %d\n", cnt, maxH);
47     }
48     
49     return 0;
50 }
51 
52 int dp(int i)
53 {
54     int k, tmp;
55     
56     if (f[i]) return f[i];
57     f[i] = a[i].h;
58     for ( k = 1; k <= n; ++k)
59         if (a[k].x < a[i].x && a[k].y < a[i].y && f[i] < (tmp = dp(k)+a[i].h))
60             f[i] = tmp;
61        
62        return f[i];
63 }

 1 # include <stdio.h>
 2 # include <memory.h>
 3 # include <stdlib.h>
 4 
 5 typedef struct {
 6     int x, y, h;
 7 }block;
 8 
 9 int n;
10 int f[92];
11 block a[92];
12 
13 int cmp(const void *xx, const void *yy)
14 {
15     return (*(int *)xx<*(int *)yy ? -1:1);
16 }
17 
18 int block_cmp(const void *xx, const void *yy)
19 {
20     return (*(block *)xx).x * (*(block *)xx).y > (*(block *)yy).x * (*(block *)yy).y ? -1:1;
21 }
22 
23 int dp(int i);            /* 记忆化搜索，f[i] = dp(i)； f[i]定义为从第i个箱子出发所能到达的最大高度 */
24 
25 int main()
26 {
27     int tmp[3], i, cnt;
28     
29     cnt = 0;
30     while (~scanf("%d", &n))
31     {
32         if (!n) break;
33         
34         ++cnt;
35         n *= 3;
36         for ( i = 1; i <= n; ++i)
37         {
38             scanf("%d%d%d", &tmp[0], &tmp[1], &tmp[2]);
39             qsort(tmp, 3, sizeof(int), cmp);
40             a[i].x = tmp[0]; a[i].y = tmp[1]; a[i].h = tmp[2];  ++i;
41             a[i].x = tmp[1]; a[i].y = tmp[2]; a[i].h = tmp[0];  ++i;
42             a[i].x = tmp[0]; a[i].y = tmp[2]; a[i].h = tmp[1];
43         }
44         
45         memset(f, 0, sizeof(f));
46         qsort(a+1, n, sizeof(block), block_cmp);
47                
48         printf("Case %d: maximum height = %d\n", cnt, dp(1));
49     }
50     
51     return 0;
52 }
53 
54 int dp(int i)
55 {
56     int k, tmp;
57     
58     if (f[i]) return f[i];
59     f[i] = a[i].h;
60     for ( k = i+1; k <= n; ++k)
61         if (a[k].x < a[i].x && a[k].y < a[i].y && f[i] < (tmp = dp(k)+a[i].h))
62             f[i] = tmp;
63        
64        return f[i];
65 }

为什么是按面积大小呢？因为会出现a[i].x>b[j].x && a[i].y<a[j].y的情况，如果按照能否放上去的方式排序，这种情况将处于无序状态；

ZOJ这道题的测试数据看来是弱的，因为实际上即使做了上述的优化，最终还必须循环查找f[i]的最大值，可以举个例子：第一个是一个6*6的正方形，第二个是3*11的长方形，后面的都可以放在这个长方形上（或者给三组数据，第三组为2*10），那么最终f[2]显然是最大的，所以方法二对应的代码48行那里还必须循环查找最大值，但是判的结果是AC, 0MS。。