动态规划模板题合集

最新推荐文章于 2022-07-04 23:33:17 发布
最新推荐文章于 2022-07-04 23:33:17 发布
阅读量363 收藏 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
    评论
专栏目录
Hie with the Pie 动态规划的模板题
CutieDeng的博客
02-13 409
Hie with the Pie Problem Description The Pizazz Pizzeria prides itself in delivering pizzas to its customers as fast as possible. Unfortunately, due to cutbacks, they can afford to hire only one driv...
动态规划模板
qq_41706331的博客
05-15 440
01背包问题： 无优化 for(int i=1;i<=n;i++) { for(int c=0;c<=m;c++) { if(c<w[i]) f[i][c]=f[i-1][c]; else f[i][c]=max(f[i][c],f[i-1][c-w[i]]+v[i]); } } 一维数组优化： for(int ...
动态规划DP模板题汇总
磊哥哥讲算法
07-04 834
动态规划模板题，详细分析了思路和基础模板，也将每种类型的DP以题目和题解分开讲述，以加深理解
刷题模板 | 动态规划
Nichole_sss进击之路
12-09 165
动态规划的关键： 就是可以保存之前的结果并在之后的计算中用到。 即把大问题拆成小问题，且这些小问题在之后的运算中可以被重复利用！ 以下引自：https://blog.csdn.net/zw6161080123/article/details/80639932 能用动规解决的问题的特点 能采用动态规划求解的问题的一般要具有3个性质： (1) 最优化原理：如果问题的最优解所包...
动态规划经典题-2
12-07
在编程世界中，动态规划是一种强大的算法思想，它在解决许多复杂问题时有着广泛的应用。本资料包聚焦于动态规划的经典题目，旨在帮助学习者深入理解这一算法，并提高解决实际问题的能力。以下是对每个文件中涉及知识...
算法面试通关40讲完整课件 44-53 动态规划
07-06
动态规划是一种重要的算法思想，广泛应用于解决复杂的问题，如求职面试中的算法题。它通过将问题分解为子问题，然后逐步构建出整个问题的最优解。动态规划的主要特点包括避免重复计算、寻找最优子结构以及状态转移...
某国一python算法做题笔记-算法模板
最新发布
03-28
书中详细介绍了各种常见的算法模板，包括排序、搜索、图论、动态规划等多个方面，每个模板都提供了清晰的Python代码实现和详细的解析，使读者能够轻松理解并掌握算法的原理和应用。此外，本书还注重实战应用，通过...
题面模板1
08-08
标题中的"题面模板1"和描述中的"题面模板1"没有提供具体的IT知识点，因此我们将基于标签"doc文档"以及部分内容来分析并生成相关的IT知识点。 这是一道计算机科学与编程竞赛的问题，涉及到的主要知识点是二进制操作...
蓝桥杯Java 算法模板题+真题训练
04-08
【蓝桥杯Java算法模板题+真题训练】是一系列针对Java编程者设计的算法练习题目，涵盖了排序、动态规划、广度搜索、深度搜索、并查集等基础算法，旨在帮助参赛者提升算法能力，适应蓝桥杯比赛的要求。这些题目来源于...
数值分析python实验贪心，动态规划算法等江大lyy实验
05-10
学习过程中的python数值分析实验，例如动态规划01背包，哈弗曼编码，矩阵连乘，最长公共子序列，拉格朗日，牛顿插值等等
51NOD 1006 最长公共子序列 Lcs 动态规划 DP 模板题 板子
日拱一卒,功不唐捐
08-21 2558
给出两个字符串A B，求A与B的最长公共子序列（子序列不要求是连续的）。 比如两个串为： abcicba abdkscab ab是两个串的子序列，abc也是，abca也是，其中abca是这两个字符串最长的子序列。 收起 输入 第1行：字符串A 第2行：字符串B (A,B的长度 <= 1000) 输出 输出最长的子序列，如果有多个，随意输出1个。 输入样例...
【算法模板】动态规划（基础背包篇）—附习题
小宝的博客
04-05 1880
物理试卷被风轻拖，岁月蹉跎，都不如，如昨！
【模板题】动态规划 POJ 1768:最大子矩阵
Always_ease的博客
05-28 413
点击打开链接很巧妙的一道题！尤其需要注意子函数中求max的部分！！#include&lt;iostream&gt; #include&lt;string.h&gt; using namespace std; int n; int maxsub(int * a) { /*m只是代表到a[i]为止的最大序列和 假如数组为 5，-1,1,2,1 则m为4而结果应为5！！ */ int i; int ...
石子合并 区间动态规划模板题
CutieDeng的博客
02-12 423
石子合并 Problem Description 在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。 试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分. Input 数据的第1行试正整数N,1≤N≤100,表示有N堆石子.第2行有N个数,分别表示每堆石子的个数. Output 输出共2...
算法笔记_面试题_18.动态规划_模板及示例十几道(上)
惊鸿一博
11-13 631
目录 1. 引例 例1.数字三角形最小路径和 代码1_ traverse法 代码2_ 分治法DC 代码3_动态规划DP_记忆化搜索（分治法DC + 记忆化） 代码4_动态规划DP_多重循环（本文重点，重点记忆） 动态规划方法对比：记忆化搜索 对比 多重循环 2. 动态规划的套路 2.1 动态规划的四点要素 2.2什么情况下使用动态规划？ 2.3什么情况下不使用动态规划？ 2.4面试中常见的动态规划类型 参考：九章算法 lintocde leetcode 代码随想录carl ...
动态规划的几个模板
诗意的栖居
09-05 558
错排公式 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; ...
Bugs公司动态规划题集：挑战高科技芯片嵌入
"Bugs公司-45道动态规划题目分析" 这是一份关于动态规划的练习集，主要来源于各种在线编程竞赛，如POJ、SPOJ、AOA、UVa等...每道题都提供了深入理解和应用动态规划的机会，有助于提升程序员的算法设计和问题解决能力。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值