HDU ~ 1069 ~ Monkey and Banana （矩形嵌套（LIS））

本文链接：https://blog.youkuaiyun.com/ZscDst/article/details/80632835

本文探讨了一种经典的算法问题——长方体堆叠。通过处理无限数量的不同尺寸的长方体，寻找最高的堆叠组合，同时确保下层长方体的长和宽大于上层。采用六种可能的长方体旋转方式，并使用动态规划中的最长递增子序列（LIS）方法求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：多组测试数据，给你一个n，然后给你n种长方体的长宽高，每种长方体有无限个，长方体可以任意旋转，问将这些长方体叠放起来，最多能叠多高，要求在下面的长方体的长和宽要比在上面的大。

思路：对于每个长方体的旋转，最多有六种情况，我们把六种情况都处理出来存一下。我们肯定让最下面的那个长方体的长和宽最大，所以我们先按照长和宽排个序，然后就是单调递增子序列（LIS）问题了，要求x和y都严格递增。
这个问题其实也是矩形嵌套问题的一个小变形。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 180+5;
const int INF = 0x3f3f3f3f;
struct Node
{
    int x, y, h;
    Node (int x, int y, int h): x(x), y(y), h(h) {}
    bool operator < (const Node& that) const
    {
        if (x != that.x) return x < that.x;
        return y < that.y;
    }
};
int n, dp[MAXN];
int main()
{
    int CASE = 1;
    while (~scanf("%d", &n) && n)
    {
        vector<Node> v;
        for (int i = 0; i < n; i++)
        {
            int x, y, z; scanf("%d%d%d", &x, &y, &z);
            v.push_back(Node(x, y, z));
            v.push_back(Node(x, z, y));
            v.push_back(Node(y, x, z));
            v.push_back(Node(y, z, x));
            v.push_back(Node(z, x, y));
            v.push_back(Node(z, y, x));
        }
        sort(v.begin(), v.end());
        int ans = 0;
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < v.size(); i++)
        {
            dp[i] = v[i].h;
            for (int j = 0; j < i; j++)
            {
                if (v[j].x < v[i].x && v[j].y < v[i].y)
                    dp[i] = max(dp[i], dp[j]+v[i].h);
            }
            ans = max(ans, dp[i]);
        }
        printf("Case %d: maximum height = %d\n", CASE++, ans);
    }
    return 0;
}
/*
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
*/