ACM动态规划DP

最新推荐文章于 2025-12-20 17:21:30 发布

原创最新推荐文章于 2025-12-20 17:21:30 发布 · 545 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#算法

ACM 专栏收录该内容

13 篇文章

订阅专栏

本文介绍了几个编程问题的解决方案，包括数塔问题的递归解法，动态规划在免费馅饼问题、最长上升子序列和搬寝室问题中的应用，以及贪心算法在最少拦截系统中的体现。展示了如何利用动态规划的最优子结构、重叠子问题和无后效性原则解决复杂问题。

基本思想

把大问题分解成已知结果的小问题。

经典例题

数塔

解：要想求n层数塔的最优解，那么就假设从下往上的n-1层数塔的最优解已经知道，那就只需要做一次大小判断即可。以此类推到两层数塔，只需要比较一个节点的左右两支的大小就可以完成。求解时可以直接利用原数塔二维数组来动态存储，自底向上计算。

#include<iostream>
using namespace std;

int main()
{
	int testNum, height;
	cin >> testNum;
	while(testNum--)
	{
		cin >> height;
		int tower[height+1][height+1] = {0};    //注意边界情况，把表格都初始化为0可以处理边界情况
		for(int i = 1; i < height+1; i++)
			for(int j = 1; j < i+1; j++)
				cin >> tower[i][j];
		for(int i = height-1; i > 0; i--)
			for(int j = height-1; j > 0; j--)
				tower[i][j] = tower[i+1][j] >= tower[i+1][j+1] ? (tower[i][j]+tower[i+1][j]) : (tower[i][j]+tower[i+1][j+1]);
		cout << tower[1][1] << endl;
	}
	return 0;
}

免费馅饼问题

解：一个变形的数塔。

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

int tower[100001][12];

int max(int x, int y, int z)
{
	return x >= y ? (x >= z ? x : z) : (y >= z ? y : z);
}

int main()
{
	int n;
	while(scanf("%d", &n), n)
	{
		memset(tower, 0, sizeof(tower));
		int height = 0;
		for(int i = 0; i < n; i++)
		{
			int x, t;
			scanf("%d%d", &x, &t);    //第t秒有1个馅饼落在x位置，开始时身处位置5
			tower[t][x+1]++;
			if(height < t) height = t;
		}
		for(int i = height-1; i >= 0; i--)
			for(int j = 1; j < 12; j++)
				tower[i][j] = max(tower[i+1][j-1], tower[i+1][j], tower[i+1][j+1]) + tower[i][j];
		cout << tower[0][6] << endl;
	}
	return 0;
}

最长有序子序列

解：遍历数组，每次考虑以当前的数结束的最长有序子序列的长度（使用另一个数组记忆下来），即：从当前的数字往前遍历，找比自己小的数，在他最长有序子序列的长度的基础上+1，最后取最大的长度就行了。（两层循环）

动态规划特征：

最优子结构：一个大问题的最优解一定包含其子问题的最优解。
重叠子问题：有好多重复的子问题。
无后效性：求解后一种情况时不会影响到前面的情况。

硕鼠的速度（证明体重越大，速度越慢）

解：先按体重递增排序（降维），再按速度找一个最长下降子序列。

最少拦截系统

解1：（贪心算法）从头开始遍历数组，每次向后找比自己小的数，包含进来。最后就可以累加出最小导弹数。

解2：（DP）只要求最长上升子序列长度即可。（最长上升子序列中任意两个元素都不可能在同一个拦截系统中）

（Dilworth定理：对于一个偏序集，最少链的划分数就等于最长反链长度。）

#include<iostream>
#include<algorithm>
using namespace std;

int max(int x, int y)
{
	return x >= y ? x : y;
}

int main()
{
	int num;
	while(cin >> num)
	{
		int maxLength=1;
		int height[num+1] = {0};
		int dp[num+1] = {0};
		for(int i = 1; i < num+1; i++)
			cin >> height[i];
		for(int i = 1; i < num+1; i++)
		{	
			dp[i] = 1;
			for(int j = 0; j < i; j++)
				if(height[j] < height[i])
					dp[i] = max(dp[j]+1, dp[i]);
			maxLength = max(dp[i], maxLength);
		}
		cout << maxLength << endl;
	}
	return 0;
}

搬寝室（求最低疲劳度）

解：由疲劳度公式(a-b)^2，每次搬的物品一定是重量相邻的物品（画数轴证明）。首先把n个物品按照重量递增排序，再如下考虑：

假如从前2个物品选1对，就是 物品1+物品2。
假如从前3个物品选1对，要么是 物品1+物品2，要么是 物品2+物品3。
假如从前n个物品选1对，要么包含第n个物品（物品(n-1)+物品n），要么不包含（前(n-1)个物品选1对的最优解）
......
从前n个物品选m对，要么包含第n个物品（物品(n-1)+物品n+前(n-2)个物品选(m-1)对的最优解），要么不包含第n个物品（前(n-1)个物品选m对的最优解）

注意：分类要清楚；同时使用记忆数组，减少重复计算；非线性问题的线性化。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<cmath>
using namespace std;

int dp[2001][1001];

int min(int x, int y)
{
	return x <= y ? x : y;
}

int main()
{
	int n, k;
	while(cin >> n >> k)
	{
		int item[2001];
		for(int i = 1; i <= n; i++)
			cin >> item[i];
		sort(item+1, item+n+1, greater<int>());
		memset(dp, 9999999, sizeof(dp));
		for(int i = 0; i <= n; i++)
			dp[i][0] = 0;
		for(int i = 2; i <= n; i++)
			for(int j = 1; j <= i/2; j++)
				dp[i][j] = min(dp[i-1][j], dp[i-2][j-1]+pow(item[i]-item[i-1], 2));
		cout << dp[n][k] << endl;
	}
	return 0;
}