动态规划DP

最新推荐文章于 2024-07-23 17:36:37 发布
最新推荐文章于 2024-07-23 17:36:37 发布
阅读量363 收藏 8
点赞数 5
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80469100/article/details/136396059
版权

文章目录

背包问题

01背包问题

在这里插入图片描述
二维

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;//n表示所有物品个数,m表示背包容量
int v[N], w[N];//v表示物品体积,w表示物品价值
int f[N][N];//f表示状态
//f[i][j]表示在前i给物体中,体积不超过j所能装下的最大价值

int main() {
	cin >> n >> m;//读入物品个数和背包容量
	for (int i = 1; i <= n; i++)//读入所有物品
		cin >> v[i] >> w[i];

	//状态计算-集合划分
//	将集合划分为选法不含i和选法含i的两个集合
	for (int i = 1; i <= n; i++)//枚举所有物品
		for (int j = 1; j <= m; j++) {//枚举所有体积
			f[i][j] = f[i - 1][j];//1.选法不含i
//			2.选法含i
			if (j >= v[i])//保证j>=v[i]才存在
				f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
		}
	cout << f[n][m] << endl;
	return 0;
}

一维

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N];

int main() {
	cin >> n >> m;
	for (int i = 1; i < n; i++)
		cin >> v[i] >> w[i];
	for (int i = 1; i <= n; i++)
		for (int j = m; j >= v[i]; j--)
			f[j] = max(f[j], f[j - v[i]] + w[i]);
	cout << f[m] << endl;
	return 0;
}

完全背包问题

在这里插入图片描述
//状态划分:第i个物品选k个,要满足k*v[i]<=j

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N][N];

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		cin >> v[i] >> w[i];
	for (int i = 1; i <= n; i++)//时间复杂度高
		for (int j = 0; j <= m; j++)
			for (int k = 0; k * v[i] <= j; k++)
				f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + w[i] * k);

	cout << f[n][m] << endl;
	return 0;
}

优化

#include <iostream>
#include <algorithm>
using namespace std;
int n, m;
int v[N], w[N];
int f[N][N];

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		cin >> v[i] >> w[i];

	for (int i = 1; i <= n; i++)//时间复杂度低
		for (int j = 1; j <= m; j++) {
			f[i][j] = f[i - 1][j]; //搭配不含i
			if (j >= v[i])//搭配含i
				f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
		}
	cout << f[n][m] << endl;
	return 0;
}

一维

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N];

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		cin >> v[i] >> w[i];
	for (int i = 1; i <= n; i++)
		for (int j = v[i]; j <= m; j++)
			f[j] = max(f[j], f[j - v[i] + w[i]]);
	cout << f[m] << endl;
	return 0;
}

多重背包问题

在这里插入图片描述多重背包的暴力写法
数据范围:100

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int n, m;
int v[N], w[N], s[N];
int f[N][N];

int main() {
	cin >> n >> m;

	for (int i = 1; i <= n; i++)
		cin >> v[i] >> w[i] >> s[i];

	for (int i = 1; i <= n; i++)
		for (int j = 0; j <= m; j++)
			for (int k = 0; k <= s[i] && k * v[i] < j; k++)
				f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + w[i * k]);

	cout << f[n][m] << endl;
	return 0;
}

优化
数据范围:2000

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 25000, M = 2010;//2000*log2000
int n, m;
int v[N], w[N];
int f[N];

int main() {
	cin >> n >> m;

	int cnt = 0;//表示所有新的物品的编号
	for (int i = 1; i <= n; i++) {
		int a, b, s;
		cin >> a >> b >> s;//表示当前第i个物品的体积,价值和个数
		int k = 1; //从1开始分
		while (k <= s) {
			cnt++;//当前物品的编号++
			v[cnt] = a * k;
			w[cnt] = b * k;
			s -= k;
			k *= 2;//k是1,2,4,8,16,...,
		}
		if (s > 0) {//说明还剩下一些需要补上
			cnt++;
			v[cnt] = a * s;
			w[cnt] = b * s;
		}
	}

	n = cnt;

	for (int i = 1; i <= n; i++)
		for (int j = m; j >= v[i]; j--)
			f[j] = max(f[j], f[j - v[i] + w[i]]);

	cout << f[m] << endl;
	return 0;
}

分组背包问题

在这里插入图片描述

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int n, m;
int v[N][N], w[N][N], s[N];
int f[N];

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> s[i]; //读入每组
		for (int j = 0; j < s[i]; j++)
			cin >> v[i][j] >> w[i][j]; //读入第i组的第j个物品的体积与价值
	}
	for (int i = 1; i <= n; i++)//从前往后枚举每一组
		for (int j = m; j >= 0; j--)//从大到小枚举所有体积
			for (int k = 0; k < s[i]; k++)//枚举所有选择
				if (v[i][k] <= j)
					f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
	cout << f[m] << endl;
	return 0;
}

线性DP

数字三角形

在这里插入图片描述

//线性DP
//数字三角形
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, INF = 1e9;
int n;
int a[N][N];//表示数字三角形的每个点
int f[N][N];//f表示状态

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= i; j++)
			scanf("%d", &a[i][j]);

	for (int i = 0; i <= n; i++)
		for (int j = 0; j <= i + 1; j++) //边界点的左上和右上也要取成负无穷
			f[i][j] = -INF;

	f[1][1] =  a[1][1];
	for (int i = 2; i <= n; i++)
		for (int j = 1; j <= i; j++)
			f[i][j] = max(f[i - 1][j - 1] + a[i][j], f[i - 1][j] + a[i][j]);

	int res = -INF;
	for (int i = 1; i <= n; i++)
		res = max(res, f[n][i]);
	printf("%d", res);
	return 0;
}

最长上升子序列

//线性DP
//最长上升子序列I
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 5010;
int  n;
int a[N], f[N];
//f[i]是所有以第i个数结尾的上升子序列长度的最大值

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
	for (int i = 1; i <= n; i++) { //从前往后计算每一个状态
		f[i] = 1;//以i为结尾的上升子序列的长度是1,只有a[i]一个数
		for (int j = 1; j < i; j++)//从1开始枚举上一个数是那个数
			if (a[j] < a[i])
				f[i] = max(f[i], f[j] + 1);
	}
	int res = 0;
	for (int i = 1; i <= n; i++)//枚举所有终点
		res = max(res, f[i]);
	printf("%d\n", res);

	return 0;
}

最长公共子序列

//线性DP
//f[i][j]表示所有在第一个序列的前i个字母中出现,
//且在二个序列的前j个字母中出现的子序列的长度的最大值
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
char a[N], b[N];
int f[N][N];

int main() {
	scanf("%d%d", &n, &m);
	scanf("%s%s", a + 1, b + 1);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++) {
			f[i][j] = max(f[i][j - 1], f[i - 1][j]);//a[i]和b[j]出现一个
			if (a[i] == b[j])//a[i]和b[j]都出现且相等
				f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);//都不出现的情况+1
		}
	printf("%d\n", f[n][m]);
	return 0;
}

区间DP

石子合并

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 310;
int n;
int s[N];
int f[N][N];

//状态表示:所有将第i堆石子到第j堆石子合并成一堆石子的合并方式
int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		scanf("%d", &s[i]);

	for (int i = 1; i <= n; i++) //处理前缀和
		s[i] += s[i - 1];

	//区间长度是1,只有一堆石子,合并不需要代价
	for (int len = 2; len <= n; len++)//长度从小到大枚举所有状态
		for (int i = 1; i + len - 1 <= n; i++) {//枚举起点i
			int l = i, r = i + len - 1;//左右端点
			f[l][r] = 1e8;
			for (int k = l; k < r; k++) //枚举l~r-1
				f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
		}
	printf("%d\n", f[1][n]);
	return 0;
}

数位统计DP

计数问题

//计数问题
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int get(vector<int>num, int l, int r) { //求num这个数在r到l中出现了几次
	int res  = 0;
	for (int i  = l; i >= r; i--)
		res  = res * 10 + num[i];
	return res;
}

int power10(int x) {
	int res = 1;
	while (x--)
		res *= 10;
	return res;
}

int count(int n, int x) { //求1-n中x出现了几次
	if (!n)
		return 0;

	vector<int>num;
	while (n) {
		num.push_back(n % 10);
		n /= 10;
	}

	n = num.size();

	int res = 0;
	for (int i = n - 1 - !x; i >= 0; i--) {
		if (i < n - 1) {
			res += get(num, n - 1, i + 1) * power10(i);
			if (!x)
				res -= power10(i);
		}
		if (num[i] == x)
			res += get(num, i - 1, 0) + 1;
		else if (num[i] > x)
			res += power10(i);
	}
	return res;
}

int main() {
	int a, b;
	while (cin >> a >> b, a || b) {
		if (a > b)
			swap(a, b);
		for (int i = 0; i < 10; i++)
			cout << count(b, i) - count(a - 1, i) << ' ';
		cout << endl;
	}
	return 0;
}

状态压缩DP

蒙德里安的梦想

在这里插入图片描述

//DP后面没写完注释
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 12, M = 1 << N;
int n, m;//矩形的行数和列数
long long f[N][M]; //状态转移的方程
bool st[M];

int main() {
	int n, m;
	while (cin >> n >> m, n || m) {//只要n或m不等于0,就一直进行
		memset(f, 0, sizeof f);
		//预处理所有状态是不是不存在连续奇数个0
		for (int i = 0; i < 1 << n; i++) {
			st[i] = true;//假设当前该状态存在
			int cnt = 0;//cnt存储当前连续0的个数
			for (int j = 0; j < n; j++)
				if (i >> j & 1) {//当前这一位是1,说明上一段已经截至了
					if (cnt & 1)//判断上一段的0是否有连续奇数个
						st[i] = false;//0有奇数个,说明第i个状态不合法
					cnt = 0;//上一段连续0已经结束了,cnt清成0
				} else//如果当前这一位是0
					cnt++;
			if (cnt & 1)//如果最后一段0的个数是奇数的话
				st[i] = false;//说明第i个状态不合法
		}
		//DP过程
		f[0][0] = 1;
		for (int i = 1 ; i <= m; i++)
			for (int j = 0; j < 1 << n; j++)
				for (int k = 0; k < 1 << n; k++)
					if ((j & k) == 0 && st[j | k])
						f[i][j] += f[i - 1][k];
		cout << f[m][0] << endl;
	}
	return 0;
}

最短Hamilton路径

hamilton路径定义:从0到n-1不重不漏地经过每个点恰好一次
f[i][j]表示:所有从0走到j,走过的所有点是i的所有路径长度的最小值
在这里插入图片描述

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 20, M = 1 << N;
int n;
int w[N][N];
int f[M][N];
//f[i][j]所有从0走到j,走过的所有点是i的所有路径长度的最小值

int main() {
	cin >> n;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			cin >> w[i][j];
	memset(f, 0x3f, sizeof f);
	f[1][0] = 0;
	//从0走到0,走过的所有点只有0一个点,也就是第0位上是1,其余所有位是0
	for (int i = 0; i < 1 << n; i++)//i和j枚举所有状态
		for (int j = 0; j < n; j++)
			if (i >> j & 1)//从0走到j,说明i里面一定要包含j
				for (int k = 0; k < n; k++)//枚举从那个点转移过来
					if ((i - (1 << j)) >> k & 1)//i除去j点后,一定要包含k点
//					第k位一定是1,才可以走到第k位
						f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
	cout << f[(1 << n) - 1][n - 1] << endl;
	//走完了所有点,n个1,每一位上都是1
	return 0;
}

树形DP

没有上司的舞会

  1. f[u][0]所有从以u为根的子树中选择,并且不选u这个点的方案
  2. f[u][1]所有从以u为根的子树中选择,并且选择u这个点的方案
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 6010;
int n;
int happy[N];//每个点的高兴度
int h[N], e[N], ne[N], idx;//邻接表
int f[N][2];
//f[u][0]所有从以u为根的子树中选择,并且不选u这个点的方案
//f[u][1]所有从以u为根的子树中选择,并且选择u这个点的方案
bool has_father[N];//判断一下每个点是否有父节点

void add(int a, int b) {
	e[idx]  = b;
	ne[idx] = h[a];
	h[a] = idx++;
}

void dfs(int u) {//递归求一下每个状态
	f[u][1] = happy[u];//选择u这个点,需要先加上它的高兴度
	for (int i = h[u]; i != -1; i = ne[i]) {//枚举一下u的所有儿子
		int j = e[i];//j表示u的每一个儿子
		dfs(j);
		f[u][0] += max(f[j][0], f[j][1]);
		f[u][1] += f[j][0];
	}
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)//先读入所有点的高兴度
		scanf("%d", &happy[i]);

	memset(h, -1, sizeof h);
	for (int i  = 0; i < n - 1; i++) {
		int a, b;
		scanf("%d%d", &a, &b);//表示b是a的父节点
		has_father[a] = true;//a就有父节点b了
		add(b, a);
	}

	int root = 1;
	while (has_father[root])//当当前枚举的这个点有父节点,就看下一个点
		root++;//直到没有父节点为止
	dfs(root);
	printf("%d\n", max(f[root][0], f[root][1]));//两种情况取最大值
	return 0;
}

记忆化搜索

滑雪

f[i][j]:所有从(i,j)开始滑的路径的长度最大值

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 310;

int n, m;
int h[N][N];//表示每个点的高度
int f[N][N];//状态

int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};//偏移量
int dp(int x, int y) {
	int &v = f[x][y];//引用,所有写v的地方等价于写成f[x][y]
	if (v != -1)//如果v!-1表示v已经算过了
		return v;

	v = 1;
	for (int i = 0; i < 4; i++) {//枚举四个方向
		int a = x + dx[i], b = y + dy[i];
		//枚举的状态在界限内,并且要走过去的高度小于当前这个点的高度
		if (a >= 1 && a <= n && b >= 1 && b <= m && h[a][b] < h[x][y])
			v = max(v, dp(a, b) + 1);
	}
	return v;
}

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)//读入每个点的高度
		for (int j = 1; j <= m; j++)
			scanf("%d", &h[i][j]);

	memset(f, -1, sizeof f);//表示每个点都没有算过

	int res = 0;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			res = max(res, dp(i, j));
//	dp[i][j]是求出这个状态的路径长并且返回
	printf("%d\n", res);
	return 0;
}
`
Yuzhee
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
动态规划DP资料
09-25
动态规划（Dynamic Programming，简称DP）是计算机科学中一种强大的算法思想，主要应用于解决最优化问题，通过将复杂问题分解成子问题来求解。它在编程竞赛（如ACM/ICPC）和实际工程中都有广泛的应用。下面将详细...
动态规划dp（常用算法）
07-29
动态规划dp（常用算法） 动态规划是一种非常重要的算法思想，它可以解决具有重叠子问题和最优子结构性质的问题。动态规划的关键是将原问题划分为若干个子问题，然后通过解决子问题来获得原问题的解。 在解决动态...
动态规划 dp 状态转移方程
11-03
动态规划 dp 状态转移方程。 ACM\信息学奥赛精品资料。
动态规划dp
02-27
动态规划是一种解决最优化问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。本文将深入探讨动态规划的概念、原理及其在实际问题中的应用。 动态规划的核心在于通过分解问题为一系列相互关联的子...
斜率优化动态规划DP
01-11
斜率优化DP
【18】输出字符菱形
2301_78786609的博客
07-19 410
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 355
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 584
AtCoder Beginner Contest 363 ABCDE
算法题目整合5
最新发布
qq_62571233的博客
07-23 659
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 172
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
2024.7.19 刷题总结
TheJustice_的博客
07-19 266
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 473
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 278
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 362
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 197
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 1461
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1148
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
算法——滑动窗口（day5）
fax_player的博客
07-20 833
（上一题是通过缩小窗口来求长度最小，所以每一次缩小都有可能得到最小长度）（而本题是求最大连续长度，只需要在去除所有重复项后计算就行了）
Java实现七大排序（二）
lllsure的博客
07-23 372
冒泡排序、快速排序、归并排序
动态规划dp算法原理
07-29
动态规划（Dynamic Programming，简称DP）是一种用来解决多阶段决策最优化问题的算法思想。其原理可以概括为"将一个问题拆分成多个子问题，并保存子问题的解，以便重复利用"。 动态规划通常适用于具有重叠子问题和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值