codeforces589B Layer Cake (动态规划)

首先，有一点可以很容易判断出，那就是短边一定和短边在一起，长边一定和长边在一起。

所以这里就不妨设a<=b

接下来将所有长方形按照a从大到小排序（因为长边一定不会对短边造成影响，以使得其满足无后效性）

设dp[i][j]表示最后一个放i，高度为j的最大宽度，则

dp[i][j] = min(b[i], max{dp[k][j-1]}),  k < i

事实上可以再增加一个额外的数组maxValue[j-1]来存储max{dp[k][j-1]}

这样的话，时间复杂度为O(n^2)

接下来，空间复杂度还可以进一步优化

dp[i][j] = min(b[i], maxValue[j-1])

也就是说k并没有什么用

于是便可以优化成

dp[j] = min(b[i], maxValue[j-1])

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <utility>
using namespace std;

typedef pair<long long, long long> pll;

const int MAXN = 4005;
pll p[MAXN];
long long dp[MAXN], maxValue[MAXN];

bool cmp(pll a, pll b)
{
	return a.first > b.first;
}

int main()
{
	int n; scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%I64d%I64d", &p[i].first, &p[i].second);
		if (p[i].second < p[i].first) swap(p[i].first, p[i].second);
	}
	sort(p + 1, p + n + 1, cmp);

	//dp
	long long ans = 0, wid = 0, len = 0;
	memset(dp, 0, sizeof(dp));
	memset(maxValue, 0, sizeof(maxValue));
	for (int i = 1; i <= n; i++)
	for (int j = i; j > 0; j--)
	{
		if (maxValue[j-1]) dp[j] = min(maxValue[j-1], p[i].second);
		else dp[j] = p[i].second;
		maxValue[j] = max(maxValue[j], dp[j]);
		if (p[i].first * dp[j] * j >= ans)
		{
			ans = p[i].first * dp[j] * j;
			wid = dp[j];
			len = p[i].first;
		}
	}

	printf("%I64d\n%I64d %I64d\n", ans, wid, len);
	return 0;
}