动态规划例题汇总

最新推荐文章于 2023-07-17 21:27:23 发布
原创 最新推荐文章于 2023-07-17 21:27:23 发布 · 1.4k 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博客介绍了用动态规划解决多个经典算法问题。包括最长公共子序列，其有状态转移方程；还涉及用动态规划思想为杂交水果取名，以及迷宫问题、最长递增子串、0/1背包问题和整数拆分问题等，整数拆分问题有递归和备忘录递归写法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最长公共子序列：

状态转移方程：
在这里插入图片描述

#include "stdafx.h"
#include <stdio.h>
#include <string>
#include<iostream>
#include <vector>
#include<algorithm>
#define MAX 51
using namespace std;

int m, n;
string a,b;//求解结果
int dp[MAX][MAX];//动态规划数组
vector<char>subs;//存放最长公共子序列

void LCSlength() {
	int i, j;
	for ( i = 0; i <= m; i++)
		dp[i][0] = 0;
	for ( j = 0; j <= n; j++)
		dp[0][j] = 0;
	for(i=1;i<=m;i++)
		for (j = 1; j <= n; j++) {
			if (a[i - 1] == b[j -1])
				dp[i][j] = dp[i - 1][j - 1] + 1;
			else
				dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
		}
}

void Buildsubs() {
	int k = dp[m][n];//k为最长公共子串
	int i = m;
	int j = n;
	while (k > 0)
		if (dp[i][j] == dp[i - 1][j])
			i--;
		else if (dp[i][j] == dp[i][j - 1])
			j--;
		else {
			subs.push_back(a[i - 1]);
				i--; j--; k--;
		}

}

int main()
{
	
	cin >> m >> n;
	cin >> a;
	cin >> b;
	LCSlength();
	Buildsubs();
	for (int i = 0; i < subs.size(); i++) {
		cout << subs[i] << " ";
	}
	return 0;
}

最长公共子序列扩展——水果取名

两种水果杂交出一种新水果，现在给新水果取名，要求这个名字中包含以前两种水果的字母，且名字尽量短，即：以前的水果名字arr1、arr2是新水果名arr的子序列，使用动态规划的思想设计算法得到新水果名arr。

#include<cstdio>
#include<cstring>
using namespace std;
int mark[105][105];
char s1[105],s2[105];
void print(int a,int b)
{
	if(a==0&&b==0)
		return ;
	else if(a==0)
	{
		print(a,b-1);
		printf("%c",s2[b-1]);
	}
	else if(b==0)
	{
		print(a-1,b);
		printf("%c",s1[a-1]);
	}
	else if(mark[a][b]==1)
	{
		print(a-1,b-1);
		printf("%c",s1[a-1]);
	}
	else if(mark[a][b]==2)
	{
		print(a-1,b);
		printf("%c",s1[a-1]);
	}
	else
	{
		print(a,b-1);
		printf("%c",s2[b-1]);
	}
}
int main()
{
	int len1,len2,i,j;
	int dp[105][105];
	while(~scanf("%s%s",&s1,&s2))
	{
		memset(dp,0,sizeof(dp));
		memset(mark,0,sizeof(mark));
		len1=strlen(s1);
		len2=strlen(s2);
		for(i=1;i<=len1;i++)
			for(j=1;j<=len2;j++)
			{
				if(s1[i-1]==s2[j-1])
				{
					dp[i][j]=dp[i-1][j-1]+1;
					mark[i][j]=1;
				}
				else if(dp[i-1][j]>dp[i][j-1])
				{
					dp[i][j]=dp[i-1][j];
					mark[i][j]=2;	
				}
				else
				{
					dp[i][j]=dp[i][j-1];
					mark[i][j]=3;
				}
			}
		print(len1,len2);
		printf("\n");
	}
	return 0;
}

迷宫问题

从网格（0，0）开始 到（m，n）只能上和右，几种走法？：
递归：

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

int ans=0;
int a[100][100];
int vis[100][100];


void dfs(int i,int j,int m,int n){
	if(i==m-1&&j==n-1){//注意这里出口是m-1和n-1 
		ans++;
		return;
	}
	vis[i][j]=1;
	{
	
	if(i+1<=m&&vis[i+1][j]==0)dfs(i+1,j,m,n);
	if(j+1<=n&&vis[i][j+1]==0)dfs(i,j+1,m,n);
    }
	vis[i][j]=0;
}


int main(){  
	int m,n;
	while(cin>>m>>n){
		memset(vis,0,sizeof(vis));
		dfs(0,0,m,n);
		cout<<ans<<endl;
	}
	return 0;  
}

动态规划：

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



int a[100][100];
int main(){  
	int m,n;
	while(cin>>m>>n){
		int i,j;
		for( i=0;i<=m;i++){
			a[i][0]=1;
		}
		for( j=0;j<=n;j++){
			a[0][j]=1;
		}
		for( i=1;i<=m;i++){
			for( j=1;j<=n;j++){
				a[i][j]=a[i-1][j]+a[i][j-1];
			}
		}
		cout<<a[m-1][n-1];
	}
	return 0;  
}

最长递增字串：
状态转移方程：
在这里插入图片描述

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

#define MAX 100

int a[]={2,1,5,3,6,4,8,9,7};
int n=sizeof(a)/sizeof(a[0]);

int ans=0;
int dp[MAX];

int main(){  
	int i,j;
	for(i=0;i<n;i++){
		dp[i]=1;
		for(j=0;j<i;j++){
			if(a[i]>a[j])
				dp[i]=max(dp[i],dp[j]+1);
		}
	}
	ans=dp[0];
	for(i=1;i<n;i++)
		ans=max(ans,dp[i]);
	return 0;  
}

0/1背包问题

在这里插入图片描述


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

#define MAXN 100
//dp[i][r]表示背包剩余容量为r，已考虑物品1，2，，，i时背包装入物品的最优值
int n=5,W=10;//
int w[MAXN]={0,2,2,6,5,4};
int v[MAXN]={0,6,3,5,4,6};

int dp[MAXN][MAXN];
int x[MAXN];
int maxv;

void Knap(){
	int i,r;
	for(i=0;i<=n;i++)
		dp[i][0]=0;
	for(r=0;r<=W;r++)
		dp[0][r]=0;
		
	for(i=1;i<=n;i++){
		for(r=1;r<=W;r++){
			if(r<w[i])dp[i][r]=dp[i-1][r];
			else dp[i][r]=max(dp[i-1][r],dp[i-1][r-w[i]]+v[i]);
		}
	}
}

void Buildx(){
	int i=n,r=W;
	maxv=0;
	while(i>=0){
		if(dp[i][r]!=dp[i-1][r]){
			x[i]=1;
			maxv+=v[i];
			r=r-w[i];
		}
		else {
			x[i]=0;
		}
		i--;
	}
}

int main(){  
	Knap();
	Buildx();
	for(int i=0;i<=n;i++){
		cout<<x[i];
	}
	return 0;  
}

求解整数拆分问题

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

int dp[MAXN][MAXN];
void Split(int n,int k){
	for(int i=1;i<=n;i++)
		for(int j=1;j<=k;j++){
			if(i==1||j==1)
				dp[i][j]=1;
			else if(i<j)
				dp[i][j]=dp[i][i]
			else if(i==j)
				dp[i][j]=dp[i][j-1]+1
			else 
				dp[i][j]=dp[i-j][j]+dp[i][j-1];
		}
}

递归写法：

int digui(int n,int k){
	if(n==1||k==1)return 1;
	else if(n<k)
		return digui(n,n);
	else if(n==k)
		return digui(n,k-1)+1;
	else
		return digui(n,k-1)+digui(n-k,k);
}

备忘录递归
所谓备忘录就是用一个数组保存每一次递归的状态值，然后再所有判断开始前先判断状态在不在此备忘数组中，如果在，就不用进行后续判断直接返回

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

#define MAXN 100

int dp[MAXN][MAXN]={0};

int dpf(int n,int k){
	if(dp[n][k]!=0)return dp[n][k];
	if(n==1||k==1){
		dp[n][k]=1;
		return dp[n][k];
	}
	else if(n<k){
		dp[n][k]=dpf(n,n);
		return dp[n][k];
	}
	else if(n==k){
		dp[n][k]=dpf(n,k-1)+1;
		return dp[n][k];
	}
	else{
		dp[n][k]=dpf(n,k-1)+dpf(n-k,k);
		return dp[n][k];
	}
} 



int main(){  
	int i=dpf(5,5);
	cout<<i<<endl;
	return 0;  
}
动态规划问题经典例题
dddddrrrzz的博客
02-23 8061
DP（Dynamic Programming）定义： 动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。 动态规划具备了以下三个特点： 把原来的问题分解成了几个相似的子问题。 所有的子问题都只需要解决一次。 储存子问题的解 动态规划的本质，是对问题状态的定义和状态转移方程的定义(状态以及状态
动态规划——例题
a123321a1233211的博客
09-07 240
动态规划解题思路： 总共分为四步： 1 建立一个新的一维数组或二维数组，根据题意即给出的变量来决定建立的数组类型。 2若是一维数组，确定数组第一个元素的取值。 若是二维数组，则确定数组第一行和第一列的值。 3找出状态转换方程式。 4返回结果。 例题1：求最大不连续子序列 设L=<a1,a2,…,an>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<aK1,ak2,…,akm>，其中k1<k2<…<km且aK1<ak2<…<akm。求
动态规划的简单例题（2）
qq_41706331的博客
01-28 576
上一篇：动态规划的简单例题（1） 题目： D点有一个过河卒，需要走到目标B点。卒行走规则：可以向下、或者向右。同时在棋盘上的任一点有一个对方的马（如下图的C点），该马所在的点和所有跳跃一步可达的点称为对方马 的控制点，例如下图的C点上的马可以控制9个点（图中的P1，P2，……P8和C），卒不能通过对方马的控制点。 棋盘用坐标表示，A点（0,0）、B点（n,m）C点（Cx,Cy）(0<C...
动态规划例题
曹世宏的博客
03-30 672
动态规划算法简介：动态规划算法 背包问题： 有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过W的物品，求所有挑选方案中价值总和的最大值。 1≤n≤100 1≤wi，vi≤100 1≤W≤10000 输入： n=4 (w,v)={(2,3),(1,2),(3,4),(2,2)} W=5 输出： 7（选择第0，1，3号物品） 因为对每个物品只有选和不选两种情况，所以这...
动态规划经典例题
weixin_46271002的博客
06-14 964
恰好 和 不超过 切割次数不超过k次和恰好切割k次的区别仅仅在于dp[i][j],j>=i时的定义不同，一个是无效值，一个是有效值（有点像背包要求装满或不要求转满时的最优解） 所以装满和不要求装满，恰好k次和不超过k次的 主要递推式其实是一样的，区别只在于初始化时，对相关变量的赋值不同 如果是恰好切割k次，则对于j>=i，即长度为i的钢管一定切不了大于长度i的j次，所以它是一个无效解，且因为要求价值最大，所以赋值无效值为-inf 如果是切割次数不超过k次，则对于j>=i，即长度为i的钢管
动态规划习题
dongqing0812的专栏
07-23 969
涉及题目：
动态规划题目汇总（持续更新）
weixin_43954951的博客
05-25 5251
动态规划题目汇总（持续更新）
动态规划法经典例题
jx6999的博客
09-08 889
/** * 动态规划法求解在矩阵中行走的最短路径问题 *有一个矩阵，它每个格子有一个权值。从左上角的格子开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。 * 给定一个矩阵返回最小路径和。 * 测试样例： * [[1,2,3],[1,1,1]],2,3 * 返回：4 * @param a 矩阵 * @return ...
动态规划习题(一)
Amxrjgcs的博客
06-17 243
假设有排成一行的N个位置记为1~N，N一定大于或等于2 开始时机器人在其中的start位置上(start一定是1~N中的一个) 如果机器人来到1位置，那么下一步只能往右来到2位置； 如果机器人来到N位置，那么下一步只能往左来到N-1位置； 如果机器人来到中间位置，那么下一步可以往左走或者往右走； 规定机器人必须走K步，最终能来到aim位置(P也是1~N中的一个)的方法有多少种 给定四个参数 N，start，aim，K 返回能走到的方法数.........
动态规划练习题
define_us的专栏
01-08 273
题目内容 Given exact k steps, how many ways to move a point from start point to destination? Point can move for eight directions(horizontally, vertically, diagonally, anti-diagonally). 答案 public class Te...
动态规划---练习题
LaMole_Ryouji的博客
04-15 539
动态规划—练习题 连续子数组的最大和 题目 输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 要求时间复杂度为O(n)。 示例1: 输入: nums = [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 提示： 1 <= arr.length <= 10^5 -100 <= arr[i] <= 100 答案 class Solution { public
动态规划例题解析
qq_73643549的博客
07-17 474
动态规划什么时候用？怎么用？这里有快速判断的方式方法，弱相关，记录状态，不同角度设计转移方程，优化转移方程。一气呵成，这是一份简单的入门指引
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值