动态规划模板题合集

最新推荐文章于 2023-04-29 14:07:41 发布
最新推荐文章于 2023-04-29 14:07:41 发布
阅读量359 收藏 5
点赞数
分类专栏： 模板 DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34682765/article/details/118601685
版权
DP 同时被 2 个专栏收录
31 篇文章 0 订阅
订阅专栏
模板
4 篇文章 0 订阅
订阅专栏

背包DP

01背包

原题链接
在这里插入图片描述
思路
用前i个物品，体积为j时的最大值

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int v[N], w[N], f[N];
int main()
{
    int n, V;
    
    cin >> n >> V;
    for (int i = 1; i <= n; i ++ )
    {
        cin >> v[i] >> w[i];
        for (int j = V; j >= v[i]; j -- )
        {
            f[j] = max(f[j - v[i]] + w[i], f[j]);
        }
    }
    cout << f[V] <<endl;
    return 0;
}

完全背包

原题链接
在这里插入图片描述
思路
用前i个物品，体积为j时，的最大价值，j从小到大枚举，因为是在同一层，看体积为j时，用物品i的最大价值。
代码

//********简化版
// #include <iostream>
// #include <cstring>
// #include <algorithm>
// using namespace std;
// const int N = 1010;
// int v[N], w[N], f[N];
// int main()
// {
//     int n, V;
    
//     cin >> n >> V;
//     for (int i = 1; i <= n; i ++ )
//     {
//         cin >> v[i] >> w[i];
//         for (int j = v[i]; j <= V; j ++)//for (int j = 0; j <= V; j ++)
//         {    //f[j] = f[j];
//              //if(j >= v[i)
//             f[j] = max(f[j - v[i]] + w[i], f[j]);
//         }
//     }
//     cout << f[V] <<endl;
//     return 0;
// }
//***************朴素版
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, V, v[N], w[N], f[N][N];
int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; i ++)
    {
        cin >> v[i] >> w[i];
        for(int j = 0; j <= V; j ++)
        {
            f[i][j] = f[i - 1][j];//之前放不进去的时候就不放，就是i - 1 时的价值
            if(j >= v[i])//有可能不存在所以需要判断
            {
                f[i][j] = max(f[i][j], f[i][j-v[i]] + w[i]);//一一枚举物品，能往里加就往里加，同一个物品，i不减1意思是在同一层上
            }
            
        }
    }
    cout << f[n][V] << endl;
    return 0;
}

多重背包1

原题链接在这里插入图片描述
思路
前i个物品，体积为j，用k个物品i时的最大价值

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int v, w, s, f[N];//只能开一维，二维会错
int main()
{
    int n, w, V;
    cin >> n >> V;
    for (int i = 1; i <= n; i ++ )//枚举前i个
    {
        cin >> v >> w >> s;
        for (int j = V; j >= v; j -- )//01背包的扩展，所以从大到小
        {
            for (int k = 0; k <= s && v*k <= j; k ++ )//需要加一个v * s <= j，防止背包爆掉
            {
                f[j] = max(f[j], f[j - v * k] + w * k);
            }
        }
    }
    cout << f[V] << endl;
    return 0;
}

多重背包2（二进制优化版）

原题链接
在这里插入图片描述
思路
每个物品有自己的个数，那么就用2的1, 1 * 2, 1 * 2 * 2…为个数打包物品，也就是说每组有2的n次方个物品，剩下的物品也为一组，然后就变成了每种物品的个数有n组，然后就枚举每种物品以每组物品为种数，然后枚举体积，做01背包操作即可。

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 25000;
int n, V, v[N], cnt, w[N], k, f[N];
int main()
{
	cin >> n >> V;
	
	for(int i = 1; i <=n ; i ++)
	{
		int a, b, c;
		
		cin >> a >> b >> c;//体积，价值，数量 
		
		int k = 1;//从一开始 
		
		while(k <= c)//一共只有c个 
		{
			cnt ++;
		
			v[cnt] = k * a;//k个为一组 
		
			w[cnt] = k * b;//k个为一组 
		
			c -= k; //-k 
		
			k *= 2;//二进制优化，所以乘二 
		}
		if(c > 0)//如果没有用完，剩余的也打包放进数组 
		{
			cnt ++;
		
			v[cnt] = c * a;
		
			w[cnt] = c * b;
		}
	}
	n = cnt;//一共有cnt个包 
	
	//开始01背包的操作 
	for(int i = 1; i <= n; i ++)
	{
		for(int j = V; j >= v[i]; j --)
		{
			f[j] = max(f[j], f[j - v[i]] + w[i]);
		}
	}
	cout << f[V] << endl;
	
	return 0;
}

二位费用背包

原题链接
在这里插入图片描述
思路
两个限制条件就变成二维数组，三种循环，前i个物品，体积不超过V，重量不超过M，的所有选法，取最大值。

代码

#include<bits/stdc++.h> 
using namespace std;
const int N = 1010;
int n, V, f[N][N], v, w, m, M;
int main()
{
	cin >> n >> V >> M;
	for(int i = 1; i <= n; i ++)
	{
		cin >> v >> m >> w;
		for(int j = V; j >= v; j --)//体积 
		{
			for(int k = M; k >= m; k --)//重量 
			{
				f[j][k] = max(f[j][k], f[j- v][k - m] + w);
			}
		}
	}
	cout << f[V][M] << endl;
	return 0;
}

分组背包

原题链接

在这里插入图片描述

思路
先输入，用二维数组存体积和价值 例： v [ 组别 ] [ 第几个] = 体积；

然后就用01背包的方法，三重循环，前i个物品，体积为j时，用第k个 的最大体积。

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int f[N], v[N][N], w[N][N], s[N], maxn = 0;
int n, V;
int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; i ++)
    {
        cin >> s[i];
        for (int j = 1; j <= s[i]; j ++ )
        {
            cin >> v[i][j] >> w[i][j];
        }
    }
    for(int i = 1; i <= n; i ++)
    {
        for(int j = V; j >= 0; j --)
        {
            for(int k = 0; k <= s[i]; k ++)
            {
                if(j >= v[i][k])
                {
                    f[j] = max(f[j], f[ j - v[i][k] ] + w[i][k] );
                }
                
            }
        }
    }
    cout << f[V] << endl;
    return 0;
}

线性DP

数字三角形

https://www.acwing.com/problem/content/900/

在这里插入图片描述
思路
每一层每个数和它上面的左右两个数取最大值，维护每一层每个点的最大值，最后一层找最大值就是最大路径。

代码

#include <iostream>
#include <cstring>
#include <algorithm>
#define int long long
using namespace std;
const int N = 1005;
signed main()
{
    int n, num[N][N]={0}, f[N][N] = {-0x3f3f3f};
    cin >> n;
    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= i; j ++ )
        {
            cin >> num[i][j];
        }
    }
    for (int i = 0; i <= n; i ++ )
    {
        for (int j = 0; j <= n; j ++ )
        {
            f[i][j] = -0x3f3f3f;
        }
    }
    f[0][1]=0;
    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= i; j ++ )
        {
            f[i][j] = max(f[i - 1][j] + num[i][j], f[i - 1][j - 1] + num[i][j]);
        }
    }
    int maxn = -0x3f3f3f3f;
    for (int i = 1; i <= n; i ++ )
    {
        maxn = max(f[n][i], maxn);
    }
    cout << maxn <<endl;
    return 0;
}

最长上升子序列

https://www.acwing.com/problem/content/897/
在这里插入图片描述

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;

int n;
int a[N], f[N];

int main()
{
	cin >> n;
	for(int i = 1; i <= n; i ++ )
	{
		cin >> a[i];
	}
	for(int i = 1; i <= n; i ++ )
	{
		f[i] = 1;//自己本身算一个 
		for(int j = 1; j < i; j ++ )
		{
			if(a[j] < a[i])//如果f[j]后面可以放f[i] ;
			{
				f[i] = max(f[j] + 1, f[i]);//是它本身现有的子序列大（有可能已经被赋过值）还是 当前的以f[j]结尾的子序列 
			}
		}
	}
	int ans = -0x3f3f3f3f;
	for(int i = 1; i <= n; i ++ )
	{
		ans = max(f[i], ans);
	} 
	cout << ans;
	return 0;
}

求最长子序列是什么（把子序列输出来）

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;

int n;
int a[N], f[N], g[N];

int main()
{
	cin >> n;
	for(int i = 1; i <= n; i ++ )
	{
		cin >> a[i];
	}
	for(int i = 1; i <= n; i ++ )
	{
		f[i] = 1;//自己本身算一个 
		for(int j = 1; j < i; j ++ )
		{
			if(a[j] < a[i])//如果f[j]后面可以放f[i] ;
			{
				//f[i] = max(f[j] + 1, f[i]);//是它本身现有的子序列大（有可能已经被赋过值）还是 当前的以f[j]结尾的子序列 
				if(f[i] < f[j] + 1)
				{
					f[i] = f[j] + 1;
					g[i] = j;//记录是从哪个状态转移来的 ，记下来的一定是最大的，因为到最大的，其他的就不会更新了 
					//以上一层值为下标，记录下一层的下标				
				}				
			}
		}
	}
	int ans = -0x3f3f3f3f, k = 1;
	for(int i = 1; i <= n; i ++ )
	{
		if(f[k] < f[i])
		{
			k = i;
		}
	} 
	cout << f[k];
	for(int i = 0 ; i < f[k]; i ++ )
	{
		cout << a[k] << " ";
		
		k = g[k];//一层一层向上找该子序列的上一个数 
	} 
	return 0;
}

最长公共子序列

https://www.acwing.com/problem/content/899/

在这里插入图片描述

思路在这里插入图片描述
代码

#include<bits/stdc++.h> 
using namespace std;
const int N = 1005;

int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
	cin >> 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 - 1][j], f[i][j - 1]);
			if(a[i] == b[j])
			{
				f[i][j] = max(f[i - 1][j - 1] + 1, f[i][j]);
			}
		}
	}
	cout << f[n][m] << endl;
	return 0;
}

最短编辑距离

https://www.acwing.com/problem/content/904/

思路
这题其实还不是那么明白
//就是把三种情况都枚举一遍 ，然后每一步都取最小值记录一下，维护每一步都是最小值，枚举每个子串的情况，一步一步累加到最后一步

在这里插入图片描述
代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
	scanf("%d%s", &n, a + 1);
	scanf("%d%s", &m, b + 1);
	
	for(int i = 0; i <= m; i ++ )
	{
		f[0][i] = i;
	}
	for(int i = 0; i <= n; i ++ )
	{
		f[i][0] = i;
	}
	
//就是把三种情况都枚举一遍 ，然后每一步都取最小值记录一下，维护每一步都是最小值，枚举每个子串的情况，一步一步累加到最后一步 
	for(int i = 1; i <= n; i ++ )
	{
		for(int j = 1; j <= m; j ++ )
		{
			f[i][j] = min(f[i - 1][j] + 1, f[i][ j - 1] + 1);
			if(a[i] == b[j])
			{
				f[i][j] = min(f[i][j], f[i - 1][j - 1]);
			}
			else
			{
				f[i][j] = min(f[i][j], f[i - 1][ j - 1 ] + 1);
			}
			//cout <<"i == "<< i << " j == "<<j<<"  "<< f[i][j] <<endl;
		} 
	}
	
	cout << f[n][m] << endl;
	return 0;
}

编辑距离

https://www.acwing.com/problem/content/description/901/

在这里插入图片描述
思路
同上 最短编辑距离

代码

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

int n, m, f[1005][1005];
char a[1005][1005];

int solved(char a[], char b[])
{
	int lena = strlen (a + 1);
	int lenb = strlen (b + 1);
	
	for(int i = 0; i <= lena; i ++ )
	{
		f[i][0] = i;
	}
	for(int i = 0; i <= lenb; i ++ )
	{
		f[0][i] = i;
	}
	
	for(int i = 1; i <= lena; i ++ )
	{
		for(int j = 1; j <= lenb; j ++ )
		{
			f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
	
			if(a[i] == b[j])
			{
				f[i][j] = min(f[i - 1][j - 1], f[i][j]);
			} 
			else
			{
				f[i][j] = min(f[i - 1][j - 1] + 1, f[i][j]);
			}
		}
	}
	return f[lena][lenb];
} 
int main()
{
	
	cin >> n >> m;
	
	for(int i = 1; i <= n; i ++ )
	{
		scanf("%s", a[i] + 1);
	}
	while(m -- )
	{
		int flag = 0, ans = 0;
		char b[1005];
		
		scanf("%s%d", b + 1, &flag);
		
		for(int i = 1; i <= n; i ++ )
		{
			if(solved(a[i], b) <= flag )
			{
				ans ++ ;
			}	
		}
		cout << ans <<endl;
	}
	return 0;
}

区间DP

石子合并

https://www.acwing.com/problem/content/284/

在这里插入图片描述
思路
以最后一步进行分类，最后一步合并哪两个石子进行分类，枚举每个区间枚举每两部分石子，然后求MIN还不太懂，过几天取再复习一遍。

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 310;
int n;
int s[N]; 
int f[N][N];

int main()
{
	cin >> n;
	for(int i = 1; i <= n; i ++ )
	{
		cin >> s[i];
		//s[i] = s[i - 1] + s[i];
	}
	
	for(int i = 1; i <= n; i ++ )
	{
		//cin >> s[i];
		s[i] += s[i - 1];
	}
	//memset(f, 999999, sizeof f);
	for(int len = 2; len <= n; len ++ )
	{
		for(int i = 1; i + len - 1 <= n; i ++ )
		{
			int l = i; int r = i + len - 1;
			f[l][r] = 1e9;
			for(int k = l ; k < r; k  ++ )
			{
				f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
			}
		}
	}
	cout << f[1][n] << endl;
	return 0;
}
x-d-xxh
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划模板总结
独钓门前月
08-06 4793
动态规划： 通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 试用情况： 最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索。 无后效性。即子问题的解一旦确定，就不再...
动态规划模板
wdg0809的博客
07-28 63
动态规划 动态规划的思想 动态规划的思想是将待求解问题分解为若干个子问题。 动态规划的过程：每次决策依赖于当前状态，又随即引起状态的转移。 动态规划使用场景 1、最优子结构：假设该问题的最优解包括的子问题的解也是最优的，成为最优子结构问题。 2、无后效性：即某个阶段的状态一旦确定，就不收这个状态以后的决策的影响。 3、有重叠子问题：子问题之间是不独立的 动态规划解题步骤 1、状态定义：每个状态的决策，存放每个状态的变量 2、状态转移方程：当前状态和上一个状态之间的关系 3、初始状态：初始状态或者边界条件
动态规划DP模板题汇总
磊哥哥讲算法
07-04 826
动态规划模板题，详细分析了思路和基础模板，也将每种类型的DP以题目和题解分开讲述，以加深理解
C++动态规划模板汇总大全
m0_54615144的博客
04-29 1531
1.背包模型2.状态机模型3.状态压缩DP4.区间DP5.树形DP6.数位DP7.单调队列优化DP8.斜率优化DP（因为我还没学，所以暂时不更新，请见谅）
AcWing算法提高课-动态规划-模板习题
qq_64403486的博客
08-03 830
AcWing算法提高课-动态规划-模板习题
动态规划经典题-2
12-07
在编程世界中，动态规划是一种强大的算法思想，它在解决许多复杂问题时有着广泛的应用。本资料包聚焦于动态规划的经典题目，旨在帮助学习者深入理解这一算法，并提高解决实际问题的能力。以下是对每个文件中涉及知识...
算法面试通关40讲完整课件 44-53 动态规划
07-06
动态规划是一种重要的算法思想，广泛应用于解决复杂的问题，如求职面试中的算法题。它通过将问题分解为子问题，然后逐步构建出整个问题的最优解。动态规划的主要特点包括避免重复计算、寻找最优子结构以及状态转移...
某国一python算法做题笔记-算法模板
最新发布
03-28
书中详细介绍了各种常见的算法模板，包括排序、搜索、图论、动态规划等多个方面，每个模板都提供了清晰的Python代码实现和详细的解析，使读者能够轻松理解并掌握算法的原理和应用。此外，本书还注重实战应用，通过...
题面模板1
08-08
标题中的"题面模板1"和描述中的"题面模板1"没有提供具体的IT知识点，因此我们将基于标签"doc文档"以及部分内容来分析并生成相关的IT知识点。 这是一道计算机科学与编程竞赛的问题，涉及到的主要知识点是二进制操作...
数值分析python实验贪心，动态规划算法等江大lyy实验
05-10
学习过程中的python数值分析实验，例如动态规划01背包，哈弗曼编码，矩阵连乘，最长公共子序列，拉格朗日，牛顿插值等等
蓝桥杯Java 算法模板题+真题训练
04-08
【蓝桥杯Java算法模板题+真题训练】是一系列针对Java编程者设计的算法练习题目，涵盖了排序、动态规划、广度搜索、深度搜索、并查集等基础算法，旨在帮助参赛者提升算法能力，适应蓝桥杯比赛的要求。这些题目来源于...
XYNUOJ 1414 集装箱装载
Dear_Jia的博客
03-22 1403
1414: 集装箱装载时间限制: 1 Sec  内存限制: 128 MB提交: 21  解决: 13[提交][状态][讨论版]题目描述有一批共n个集装箱要装上艘载重量为c的轮船，其中集装箱i的重量为wi。找出一种最优装载方案，将轮船尽可能装满，即在装载体积不受限制的情况下，将尽可能重的集装箱装上轮船。输入第一行有2个正整数n和c。n是集装箱数，c是轮船的载重量。第2行中有n个正整数，表示集装箱的重...
动态规划的几个模板
诗意的栖居
09-05 556
错排公式 dp[1]=0; dp[2]=1; for(int i=3;i&lt;=20;i++) { dp[i]=(i-1)*dp[i-1]+(i-1)*dp[i-2]; } cin&gt;&gt;n; cout&lt;&lt;dp[n]&lt;&lt;endl; 最长递增子序列 LIS for(int i=1;i&lt;=n;i++) { int tmax=1; ...
石子合并 区间动态规划模板题
CutieDeng的博客
02-12 423
石子合并 Problem Description 在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。 试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分. Input 数据的第1行试正整数N,1≤N≤100,表示有N堆石子.第2行有N个数,分别表示每堆石子的个数. Output 输出共2...
【算法模板】动态规划（基础背包篇）—附习题
小宝的博客
04-05 1876
物理试卷被风轻拖，岁月蹉跎，都不如，如昨！
动态规划练习题
cp0328的博客
02-19 4879
定义 动态规划就是将一类多阶段问题的特点，把多阶段决策问题变成一系列互相联系的单阶段问题，然后逐个加以解决。动态规划就是解决这类问题的方法，动态规划算法通常用于求解具有某种最优性质的问题。 组成部分 1.阶段 2.状态 3.决策 4.状态转化方程 5.策略 过程 动态规划最重要的就是构表和转化方程 我们的第一步是先描述事物，一个好的描述等于成功了一半，描述的时候我们先不必管我们使用空间...
Bugs公司动态规划题集：挑战高科技芯片嵌入
"Bugs公司-45道动态规划题目分析" 这是一份关于动态规划的练习集，主要来源于各种在线编程竞赛，如POJ、SPOJ、AOA、UVa等...每道题都提供了深入理解和应用动态规划的机会，有助于提升程序员的算法设计和问题解决能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值