动态规划总结

最新推荐文章于 2024-10-17 21:30:25 发布
最新推荐文章于 2024-10-17 21:30:25 发布
阅读量117 收藏
点赞数 1
文章标签： 动态规划 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46391939/article/details/121087673
版权

在这里插入图片描述

矩阵链乘

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
int m;
int r[1000];
int M[1000][1000];
int n = 0;
int s[1000][1000];

void Print(int i, int j) {
	if (i == j) {
		cout << "A" << i;
	} else {
		cout << "(";
		Print(i, s[i][j]);
		Print(s[i][j] + 1, j);
		cout << ")";
	}

}

int main() {
	cin >> m;
	while (m--) {

		int a;
		while (cin >> a) {
			r[n++] = a;
			char c = cin.get();
			if (c == '\n')
				break;

		}
		n--; //5
		for (int i = 1; i <= n; i++) {
			M[i][i] = 0;
		}
		for (int l = 2; l <= n; l++) {
			for (int i = 1; i <= n - l + 1; i++) {
				int j = i + l - 1;
				M[i][j] = M[i + 1][j] + r[i - 1] * r[i] * r[j];
				s[i][j] = i;
				for (int k = i + 1; k < j; k++) {
					int t = M[i][k] + M[i + 1][j] + r[i - 1] * r[k] * r[j];
					if (t < M[i][j]) {
						M[i][j] = t;
						s[i][j] = k;
					}
				}
			}
		}
		cout << M[1][n] << endl;
		Print(1, n);
		n = 0;
	}
}

0-1背包

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
int n, W;
void knapsack();	//动态规划求值（求表）
void Opimal(vector<vector<int> > &M, vector<int> &w); //求解最优解

int main() {
	cin >> n >> W;
	knapsack();
	return 0;
}


void knapsack() {
	vector<int> v(n + 1, 0);
	vector<int> w(n + 1, 0);
	vector<vector<int> > M(n + 1, vector<int>(W + 1));

	//输入v、w
	for (int i = 1; i <= n; i++) {
		cin >> v[i];
	}
	for (int i = 1; i <= n; i++) {
		cin >> w[i];
	}
	//求表M
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= W; j++) {
			if (j < w[i])
				M[i][j] = M[i - 1][j];
			else {
				M[i][j] = max(M[i - 1][j - w[i]] + v[i], M[i - 1][j]);
			}
		}
	}
	cout << M[n][W] << endl;

	Opimal(M, w);//得到最优解
}

void Opimal(vector<vector<int> > &M, vector<int> &w) {
	vector<int> result;
	int i = n;
	int j = W;
	while (i > 0) {
		if (M[i][j] == M[i - 1][j]) {
			//没装入i
			result.push_back(0);
			i--;
		} else {
			//装入
			result.push_back(1);
			j = j - w[i];
			i--;
		}
	}
	for (int i = result.size() - 1; i >= 0; i--) {
		cout << result[i] << " ";
	}
}

在这里插入图片描述

/*
	背包问题
*/
#include <bits/stdc++.h>
using namespace std;
int n, W;
void knapsack();

int main() {
	cin >> n >> W;
	knapsack();
	return 0;
}

void knapsack() {
	vector<int> v(n + 1, 0);
	vector<int> w(n + 1, 0);
	vector<int> M(W + 1);

	//输入v、w
	for (int i = 1; i <= n; i++) {
		cin >> v[i];
	}
	for (int i = 1; i <= n; i++) {
		cin >> w[i];
	}

	//求表M
	for (int i = 1; i <= n; i++) {
		for (int j = W; j > 0; j--) {		//注意从后往前
			if (j < w[i])
				M[j] = M[j];
			else {
				M[j] = max(M[j - w[i]] + v[i], M[j]);
			}
		}
	}
	for (int j = 1; j <= W; j++) {
		cout << M[j] << " ";
	}
	cout << endl;
	cout << M[W] << endl;
}

最长递增子序列

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
/*
	a b a b c
初始1 1 1 1 1
i:b j:a1 所以b:1+1=2
i:a j:a 跳过 j:b 跳过
i:b j:a1 所以2  跳过 2和2 还是2
*/

int main() {
	int N;
	cin >> N;
	while (N--) {
		string s;
		cin >> s;
		int n = s.length();
		vector<int> M(n + 1, 1);
		for (int i = 1; i < n; i++) {
			for (int j = 0; j < i; j++) {
				if (s[j] >= s[i])
					continue;
				else {
					M[i] = max(M[i], M[j] + 1);
				}
			}
		}
		cout << M[n - 1];
	}
}

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

/*
	a b a b c
初始1 1 1 1 1
i:b j:a1 所以b:1+1=2
i:a j:a 跳过 j:b 跳过
i:b j:a1 所以2  跳过 2和2 还是2
*/
string s;
vector<int> M;
void BinaryInsert(char c, int l, int r) {
	if (l > r) {
		return ;
	}
	int mid = (r - l) / 2 + l;
	if (M[mid] == c)
		return;
	if (M[mid] < c) {
		if (M[mid + 1] > c) {
			M[mid + 1] = c;
		} else {
			BinaryInsert(c, mid + 1, r);
		}
	} else {
		if (M[mid - 1] < c) {
			M[mid] = c;
		} else {
			BinaryInsert(c, l, mid);
		}
	}
}

int main() {
	int N;
	cin >> N;
	while (N--) {
		cin >> s;
		int n = s.length();

		char c = 0;
		for (int i = 0; i < n; i++) {
			if (s[i] > c) {
				//cout << "s[i]:" << s[i] << " c:" << c << endl;
				M.push_back(s[i]);
			} else if (s[i] < c) {
				BinaryInsert(s[i], 0, M.size() - 1);
			}
			c = M[M.size() - 1];
		}
		cout << M.size() << endl;
		M.clear();
	}
}

最长公共子序列

在这里插入图片描述在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
int c[1001][1001];
int b[1001][1001];
string s1;
string s2;
void LCS(string s1, string s2, int n1, int n2);
void LCS_result(int i, int j);

int main() {
	int N;
	cin >> N;
	while (N--) {
		cin >> s1 >> s2;
		int n1 = s1.length();
		int n2 = s2.length();
		LCS(s1, s2, n1, n2);
	}
}


void LCS(string s1, string s2, int n1, int n2) {	//动态规划计算LCS的值
	for (int i = 1; i <= n1; i++) {		//从i递增，每次看完j
		for (int j = 1; j <= n2; j++) {
			if (s1[i - 1] == s2[j - 1]) {	//注意s字符串下标从0开始
				c[i][j] = c[i - 1][j - 1] + 1;
				b[i][j] = 1;
			} else {
				if (c[i - 1][j] >= c[i][j - 1]) {
					c[i][j] = c[i - 1][j];
					b[i][j] = 2;
				} else {
					c[i][j] = c[i][j - 1];
					b[i][j] = 3;
				}
			}
		}
	}
	cout << c[n1][n2] << endl;
	LCS_result(n1, n2);
	cout << endl;
}

void LCS_result(int i, int j) {	//得到最优解
	if (i == 0 || j == 0) {
		return;
	}
	if (b[i][j] == 1) {
		LCS_result(i - 1, j - 1);
		cout << s1[i - 1];
	} else if (b[i][j] == 2) {
		LCS_result(i - 1, j);
	} else {
		LCS_result(i, j - 1);
	}
}

最优二叉搜索树

#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const double INF = 99999;
int n;

double p[N];
double q[N];
double w[N][N];
double e[N][N];
int re[N][N];

int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> p[i];
	}
	for (int i = 0; i <= n; i++) {
		cin >> q[i];
	}

	for (int i = 1; i <= n + 1; i++) {
		for (int j = 0; j <= n; j++) {
			if (j == i - 1) {
				w[i][j] = q[j];
				e[i][j] = q[j];
			}
		}
	}

	for (int l = 1; l <= n; l++) {
		for (int i = 1; i <= n - l + 2; i++) {
			int j = i + l - 1;
			w[i][j] = w[i][j - 1] + p[j] + q[j];
			e[i][j] = INF;
			for (int r = i; r <= j; r++) {
				if (e[i][r - 1] + e[r + 1][j] + w[i][j] < e[i][j]) {
					e[i][j] = e[i][r - 1] + e[r + 1][j] + w[i][j];
					re[i][j] = r;
				}
			}
		}
	}
	for (int i = 1; i <= n + 1; i++) {
		for (int j = 0; j <= n; j++) {
			cout << w[i][j] << " ";
		}
		cout << endl;
	}
	for (int i = 1; i <= n + 1; i++) {
		for (int j = 0; j <= n; j++) {
			cout << e[i][j] << " ";
		}
		cout << endl;
	}
	for (int i = 1; i <= n + 1; i++) {
		for (int j = 0; j <= n; j++) {
			cout << re[i][j] << " ";
		}
		cout << endl;
	}
}
HeatLow
关注
动态规划总结与题目分类
05-17
动态规划总结与题目分类 一、简单基础dp 1、递推： 2、背包 3、LIS 4、LCS 二、区间dp 四、数位dp 五、概率(期望) dp 六、状态压缩dp 七、数据结构优化的dp 1、二进制优化 2、单调队列优化 3、斜率优化 4、四边形...
pku 动态规划 总结
10-07
这个“PKU之DP试题总结”很可能是北京大学(Peking University，简称PKU)提供的一个资源，汇总了该校涉及动态规划的编程题目，帮助学习者深入理解和掌握这一关键算法。 动态规划的核心思想是将复杂问题分解成若干...
动态规划总结.doc
12-12
动态规划是一种解决问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。在算法分析与设计中，动态规划算法扮演着至关重要的角色。以下是对动态规划算法的详细阐述，以及如何应用于矩阵连乘问题。 ...
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2384
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
C++，STL 028（24.10.11）
Erif_Liu的博客
10-12 235
利用sort排序算法来对deque容器进行排序。
如何用c++模拟创建用户（只得创建一个用户）
2301_78863827的博客
10-14 772
模拟系列，希望大家能多提意见
C语言内存函数
L73S37的博客
10-13 445
对于重叠内存，用memmove来实现。
【C语言】指针与函数：传值与传址
我的我的博客
10-17 481
函数在使用的时候，给到的形式参数属于局部变量，仅在函数体内部有效。 1. 传值，对于两个值的交换，不影响函数调用之前的数值。这个就是传值，传递的是实参。 2. 传址，如果想通过函数来改变原本两个变量的值，那么需要传递地址。 3. 另外一种方式就是定义**全局变量**，参数不进行传递。可以直接实现在自定义函数体内，改变main函数中、或者其他函数中的值。
C++文档数据保存与解析
一个大佬的博客
10-12 351
【代码】C++文档数据保存与解析。
C++ 中的自旋锁应用：SpinLockManual、SpinLockGuard 和 SpinLockTryGuard
极地星辰
10-13 342
在多线程编程中，同步机制是确保线程安全的关键。自旋锁（Spin Lock）是一种常见的同步机制，它通过忙等待（busy-waiting）的方式来实现线程间的互斥访问。在 C++ 中，我们可以使用 `std::atomic_flag` 来实现自旋锁。本文将介绍如何使用 `SpinLockManual`、`SpinLockGuard` 和 `SpinLockTryGuard` 这三个类来应用自旋锁。
learn C++ NO.23——map、set的模拟实现
sinzz的博客
10-13 1008
本篇文章以STL库为模板，模拟实现了map和set。实现了map和set的跌打器部分以及map的operator[]。通过封装一份简易版本的map和set，学习库的设计者的设计思路，以到达更好的理解map和set。
C++ 的存储类型与新的 thread_local
oRbIt 的专栏
10-14 673
存储周期只是一个概念，是程序语义范畴内的东西，但不是语法的范畴。存储类型说明符也被称为存储类型，它们是变量声明语法中类型说明符的一部分，它们和变量名的范围一起控制变量的两个独立属性，即存储周期和链接属性。
Types and Programming Languages, Benjamin C. Pierce 学习笔记（一） Introduction
ldc1513的博客
10-14 339
they compute （eg：C++里面的类型系统，通过类型检查来规避一些类型错误）.
C++菱形继承
switch_JR的博客
10-14 349
此外，还可以通过提供一个重新解释函数（如 __asTermPositions()）来安全地在不同继承路径之间转换对象指针，而不需要使用 dynamic_cast 或依赖 RTTI。这段代码是从C++头文件Terms.h中摘录的，它定义了一个纯虚函数__asTermPositions()，用于解决C++中的菱形继承问题。这段代码定义了一个用于解决菱形继承问题的纯虚函数。是一个纯虚函数声明。菱形继承问题发生在多重继承的场景中，当一个类通过两条不同的路径继承自同一个基类时，会导致基类成员的重复。
48 C 语言实战项目——客户信息管理系统
Thanks_ks的IT探秘之旅
10-12 399
本文详细阐述了一个客户管理系统的设计与实现过程。文章首先介绍了系统的需求说明，包括主菜单、添加客户、显示客户列表、修改客户、删除客户和退出等核心功能。接着，文章对各个功能的流程进行了详细分析，并绘制了相应的流程图。在代码实现部分，文章详细讲解了框架搭建、结构体与菜单页面的抽取、以及各个功能的代码实现。最后，文章展示了最终优化后的代码。本文旨在为读者提供一个完整的客户管理系统开发指南。
C++四种类型转化
2303_76580416的博客
10-15 203
2）指针转换的限制：不能转换掉const，volatile或者__unaligned属性。5）在进行下行转换时，dynamic_cast具有类型检查的功能，更加安全。内置类型在打印时，编译器看到是常性值，直接进行替换操作，无法实现修改值。说明：要求类型必须是一个指针、引用、算数类型、函数指针或者成员指针。6）动态类型转换能将对象类型转换成无类型，不能将无类型转换成对象类型。1）用于基本类型间的转换，如int->char，int->enum。下行转换是不安全的：把基类指针或引用转换成派生类时，没有动态检查。
C/C++语言基础--C++四大类型转换讲解
最新发布
weixin_74085818的博客
10-17 1184
计算机内部，他是没有类型这一概念的，汇编也没有类型这一概念，类型是高级语言自己抽象出来的，类型转换就是告诉编译器这个变量属于什么类型，这样再转化成汇编的时候就可以调用不同类型的汇编指令了，当然还有很多要注意的，都可由static_cast显示完成，编译器隐式：编译器再编译的时候自动帮我们操作，所以我们需要保证再写的时候需要保证可以转换，这个就得看经验积累了，完成的，不提供动态类型检查，所以再我们写的时候就需要经量保证这个类型之间是可以转换的，防止出现。修改变量a的值，然后输出，通过输出发现，
高效排序c++
qq_37755459的博客
10-11 410
4种高效排序算法，快速排序，归并排序，堆排序，希尔排序。
"ACM经典题型解析：动态规划总结与Pku acm 1163题解
ACM动态规划总结 动态规划（Dynamic Programming, DP）是一种通过将问题分解为重叠子问题并使用子问题的解来求解原问题的方法。在ACM竞赛中，动态规划经常被用来解决一些复杂的问题，其核心思想是将大问题划分为小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值