UVA 10154 Weights and Measures

最新推荐文章于 2021-05-06 00:13:58 发布

原创最新推荐文章于 2021-05-06 00:13:58 发布 · 650 阅读

0 ·

CC 4.0 BY-SA版权

UVA 专栏收录该内容

86 篇文章

订阅专栏

本文针对乌龟堆叠问题，采用动态规划的方法进行解决。首先将乌龟按力量大小排序，并通过状态转移方程计算出堆叠到各层的最小重量。最终输出能够实现的最大堆叠层数。

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

大意不再赘述。

思路：一开始以为是DAG单源最长路径，后来WA，思考了很久，没有个头绪，主要是重量叠加问题比较难处理。

这里有几个问题比较难处理。

1、这里的乌龟是无序状态。

2、对于每一个乌龟来说重量是叠加的。

对于1，动态规划的本质就是有序的多阶段决策问题，根据题意，我们可以按照力量从小到大排一次序，这样方便规划方程的建立于求解。

对于2，由于乌龟的重量是叠加的，而且它们的力量是递增的，所以我们可以写出规划方程d[i][j] = min(d[i-1][j], d[i-1][j-1]+wi) 1 <= j <= i;

规划方程d[i][j]表示前i个乌龟能够叠加到j层的最小重量，这样即可保证重量是叠加的，而且子问题是最优解。

当前决策，选乌龟i叠加到j层或者不选乌龟i叠加到j层，不选乌龟i，那么d[i][j] = d[i-1][j]，选了说明第j层的乌龟就是i，即d[i-1][j-1]+wi。

状态转移是取最优解，所以规划方程是：d[i][j] = min(d[i-1][j], d[i-1][j-1]+wi) 1 <= j <= i;

边界情况：d[i][0] = 0 (i = 1, 2, 3...n)，表示叠加0层时，最小重量是0。

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

const int MAXN = 5670;
const int INF = 0x3f3f3f3f;

struct node
{
	int w, v;
	bool operator < (const node a) const
	{
		return v < a.v;
	}
}A[MAXN];

int n;

int d[MAXN][MAXN];

void init()
{
	memset(d, INF, sizeof(d));
	for(int i = 0; i <= n; i++) d[i][0] = 0;
}

int dp()
{
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= i; j++)
		{
			d[i][j] = d[i-1][j];
			if(d[i-1][j-1] != INF && A[i].v >= d[i-1][j-1] + A[i].w)
			{
				d[i][j] = min(d[i][j], d[i-1][j-1]+A[i].w);
			}
		}
	}
	for(int i = n; i >= 1; i--) if(d[n][i] != INF) return i;
}

void read_case()
{
	n = 1;
	while(~scanf("%d%d", &A[n].w, &A[n].v) && A[n].w) n++;
	--n;
	sort(A+1, A+1+n);
}

void solve()
{
	read_case();
	init();
	int ans = dp();
	printf("%d\n", ans);
}

int main()
{
	solve();
	system("pause");
	return 0;
}