基本的算法设计技术——动态规划法

最新推荐文章于 2023-03-04 10:36:38 发布
最新推荐文章于 2023-03-04 10:36:38 发布
阅读量432 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44342332/article/details/106496871
版权

1.数塔问题
完整代码：

#include<iostream>
#define n 5
using namespace std;
int DataTower(int d[n][n])
{
	int maxAdd[n][n]={0},path[n][n]={0};
	int i,j;
	for(j=0;j<n;j++)
		maxAdd[n-1][j]=d[n-1][j];	
	for(i=n-2;i>=0;i--)
	{
		for(j=0;j<=i;j++)
		{
			if(maxAdd[i+1][j]>maxAdd[i+1][j+1])
			{
				maxAdd[i][j]=d[i][j]+maxAdd[i+1][j];
				path[i][j]=j;	
			}	
			else
			{
				maxAdd[i][j]=d[i][j]+maxAdd[i+1][j+1];
				path[i][j]=j+1;
			}
		}	
	} 	
	printf("路径为：%d", d[0][0]);         //输出最顶层数字
	j = path[0][0];        //顶层决策是选择下一层列下标为path[0][0]的元素
	for (i = 1; i < n; i++)
	{
		printf("-->%d", d[i][j]);    
		j = path[i][j];        //本层决策是选择下一层列下标为path[i][j]的元素
	}
	printf("\n最大数值和为：");
	return maxAdd[0][0];              //返回最大数值和，即最终的决策结果
}
int main()
{
	int	d[n][n]={{8},{12,15},{3,9,6},{8,10,5,12},{16,4,18,10,9}};
	int max=DataTower(d);
	cout<<max<<endl;
	return 0;
}

运行结果：
在这里插入图片描述
2.图问题中的动态规划法
1>多段图的最短路径问题
完整代码：

#include<iostream>
using namespace std;
const int N = 20;
const int MAX=1000;
int arc[N][N]; 
int CreatGraph()
{
	int i,j,k;
	int weight;
	int vnum,arcnum;
	cout<<"请输入顶点和边的个数："<<endl;
	cin>>vnum>>arcnum;
	for(i=0;i<vnum;i++)
	{
		for(j=0;j<vnum;j++)
		{
			arc[i][j]=MAX;
		}		
	}	
	for(k=0;k<arcnum;k++)
	{
		cout<<"请输入边的两个顶点和权值"<<endl;
		cin>>i>>j>>weight;
		arc[i][j]=weight;
	}
	return vnum;
} 

int BackPath(int n)
{
	int i,j,temp;
	int cost[N],path[N];
	for(i=1;i<n;i++)
	{
		cost[i]=MAX;
		path[i]=-1;
	}
	cost[0]=0;
	path[0]=-1;
	for(j=1;j<n;j++)
	{
		for(i=j-1;i>=0;i--)
		{
			if(arc[i][j]+cost[i]<cost[j])
			{
				cost[j]=arc[i][j]+cost[i];
				path[j]=i;
			}
		}
	}
	cout<<n-1;
	i=n-1;
	while(path[i]>=0)
	{
		cout<<"<-"<<path[i];
		i=path[i];
	}
	return cost[n-1];
}
int main()
{
	int n=CreatGraph();
	BackPath(n);
}

运行结果：
在这里插入图片描述
2>多源点最短路径问题
完整代码：

#include <iostream>
using namespace std;
const int MAX = 100;
const int n=3;//假设图中最多顶点个数
void Floyd(int arc[n][n],int dist[n][n])
{
	int i,j,k;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			dist[i][j]=arc[i][j];
		}
	}	
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			for(k=0;k<n;k++)
			{
				if(dist[i][k]+dist[k][j]<dist[i][j])
				{
					dist[i][j]=dist[i][k]+dist[k][j];
				}
			}
		}
	}
} 
int main()
{
	int arc[n][n]={{0,4,11},{6,0,2},{3,MAX,0}};
	int dist[n][n];
	Floyd(arc,dist);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
			cout<<dist[i][j]<<"  ";
		cout<<endl;
	}
	return 0;
}

运行结果：
在这里插入图片描述
3>TSP问题

3.组合问题中的动态规划法
1>最长递增子序列问题
完整代码：

#include<iostream>
using namespace std; 
int IncreaseOrder(int a[ ],int n)
{
	int i,j,k,index;
	int L[10],x[10][10];//L[i]表示元素序列a[0]-a[i]的最长递增子序列的长度，x[n][n]储存对应的最长递增子序列 
	for(i=0;i<n;i++)
	{
		L[i]=1;
		x[i][0]=a[i];
	}
	for(i=1;i<n;i++)//依次计算a[0]-a[i]的最长递增子序列 
	{
		int max=1;//初始化递增子序列长度的最大值 
		for(j=i-1;j>=0;j--) 
		{
			if((a[j]<a[i])&&(max<L[j]+1))//max<L[j]+1是当L[j]加1(a[i]的长度)大于目前的最大递增子序列才执行if语句，除去下列情况：i=5,max=3,j减小到0,a[0]<a[5]且L[0]=1，max>L[0]+1,因此不执行if语句 
			{
				max=L[j]+1;//前一个序列的最大子序列L[j]加1(a[i]的长度) 
				L[i]=max;//当前序列的最大子序列 
				for(k=0;k<max-1;k++)
				{
					x[i][k]=x[j][k];//将前一个最大子序列赋值给当前最大子序列(除最后一个元素)	
				} 
				x[i][max-1]=a[i];//当前最大子序列的最后一个元素是a[i] 
			}
		}
	}
	for(index=0,i=1;i<n;i++)
	{
		if(L[index]<L[i])//遍历L[0]-L[n-1],与当前最大子序列长度比较，若大于当前最大子序列则替换index 
			index=i; 
	}
	cout<<"最长公共子序列是：";
	for(i=0;i<L[index];i++)
		cout<<x[index][i]<<" ";
	return L[index]; 
} 
int main()
{
	int a[]={5,2,8,6,3,6,9,7};
	int len = IncreaseOrder(a, 8);
	cout<<"最长递增子序列的长度是："<<len<<endl;
	return 0;
}

运行结果：
在这里插入图片描述
2>最长公共子序列问题
完整代码：

#include<iostream>
using namespace std;
int L[10][10],S[10][10];
int CommonOrder(char x[ ],int m,char y[ ],int n,char z[ ])
{
	int i,j,k;
	for(i=0;i<=m;i++)
		L[i][0]=0;
	for(j=0;j<=n;j++)
		L[0][j]=0;
	for(i=1;i<=m;i++)
	{
		for(j=1;j<=n;j++)
		{
			if(x[i-1]==y[j-1])
			{
				L[i][j]=L[i-1][j-1]+1;
				S[i][j]=1;	
			}
			else if(L[i][j-1]>L[i-1][j])
			{
				L[i][j]=L[i][j-1];
				S[i][j]=2;	
			}
			else
			{
				L[i][j]=L[i-1][j];
				S[i][j]=3;	
			}
		}
	}
	i=m;j=n;k=L[m][n];
	while(i>0&&j>0)
	{
		if(S[i][j]==1)
		{
			z[k]=x[i-1];
			k--;
			i--;
			j--;
		}
		else if(S[i][j]==2)
		{
			j--;
		}
		else
		{
			i--;
		}
	}
	for(k=1;k<=L[m][n];k++)
		cout<<z[k]<<" ";
	return L[m][n];
}
int main()
{
	char x[]={'a','b','c','b','d','b'};
	char y[]={'a','c','b','b','a','b','d','b','b'};
	char z[10];
	cout<<"长度为："<<CommonOrder(x,6,y,9,z)<<endl;
	return 0;
}

运行结果：
在这里插入图片描述
3>0/1背包问题

#include <iostream>
using namespace std;
int V[6][11];
int x[5];
int KnapSack(int w[ ],int v[ ],int n,int C)
{
	int i,j;
	for(i=0;i<=n;i++)//将i个物品装入容量为0的背包
		V[i][0]=0;
	for(j=0;j<=C;j++)//将0个物品装入容量为i的背包
		V[0][j]=0;
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=C;j++)
		{
			if(j<w[i-1])
				V[i][j]=V[i-1][j];
			else
			{
				if(V[i-1][j]>(V[i-1][j-w[i-1]]+v[i-1]))
					V[i][j]=V[i-1][j];
				else
					V[i][j]=V[i-1][j-w[i-1]]+v[i-1];
			}	
		}	
	} 
	for(j=C,i=n;i>0;i--)
	{
		if(V[i][j]>V[i-1][j])
		{
			x[i-1]=1;
			j=j-w[i-1];	
		}	
		else
			x[i-1]=0;
	} 
	return V[n][C];
}
int main()
{
	int w[]={2,2,6,5,4};
	int v[]={6,3,5,4,6};
	cout<<"背包获得的最大价值是："<<KnapSack(w,v,5,10)<<endl;
	cout<<"装入背包的物品是：";
	for(int i=0;i<5;i++)
		if (x[i] == 1) cout<<"物品"<<i+1<<"  ";
	cout<<endl;
	return 0;
}

在这里插入图片描述
4.查找问题中的动态规划法
1>最优二叉查找树
完整代码：

#include<iostream>
#include<iomanip>
#define N 5
using namespace std;
double C[N+1][N+1];
int R[N+1][N+1];
double OptimalBST(double p[ ], int n);
int main()
{
	int i,j;
	double p[]={0.1, 0.2, 0.4, 0.3}; 
    cout<<OptimalBST(p,4)<<endl;
    cout<<"矩阵C:"<<endl;
	for(i=1;i<6;i++)
	{
		for(j=0;j<5;j++)
		{
			cout<<C[i][j]<<"\t";
		}
		cout<<endl;
	}
	cout<<endl;
	cout<<"矩阵R:"<<endl;
	for(i=1;i<6;i++)
	{
		for(j=0;j<5;j++)
		{
			cout<<R[i][j]<<"\t";
		}
		cout<<endl;
	}
	return 0;
}
double OptimalBST(double p[ ], int n)
{
	int i, j, k, d, mink;
	double min, sum;
	for(i=1;i<=n;i++)                //初始化主对角线和第一条次对角线
	{
        C[i][i-1] = 0;
        C[i][i] = p[i-1]; R[i][i] = i;
	}
	C[n][n-1] = 0;
	for(d=1;d<n;d++)  
	{              //按对角线逐条计算
		for(i=1;i<=n-d;i++)
		{
			j=i+d;
			min=1000; mink=i; sum=0;     //假设1000为最大值
			for(k=i;k<=j;k++)
			{
				sum=sum+p[k-1];
				if(C[i][k-1]+C[k+1][j]<min) 
				{
					min = C[i][k-1] + C[k+1][j];
					mink = k;
				}
			}
			C[i][j] = min + sum;
			R[i][j] = mink;
		}
	}
    return C[1][n];
}

运行结果：
在这里插入图片描述
2>近似串匹配问题
完整代码：

#include<iostream>
#include<iomanip>
using namespace std;
int D[6][9];
int ASM(char P[ ], char T[ ], int m, int n);
int main()
{
	char P[]="happy";
	char T[]="hsppay";
	cout<<"K-近似匹配求解过程:"<<endl; 
	cout<<ASM(P,T,5,6)<<endl;
	return 0;
}
int min(int x,int y,int z)
{
	int min;
	if (x < y) min = x;
	else min = y;
	if (z < min)
		min = z;
	return min;
}
int ASM(char P[ ], char T[ ], int m, int n)
{
	int i, j;
	for (j = 1; j <= n; j++)                     //初始化第0行
		D[0][j] = j;
	for (i = 0; i <= m; i++)                    //初始化第0列
		D[i][0] = i;
	for (j = 1; j <= n; j++)                    //根据递推式依次计算每一列
	{
		for (i = 1; i <= m; i++)
		{
			if (P[i-1] == T[j-1]) 
				D[i][j] =min(D[i-1][j-1], D[i-1][j]+1, D[i][j-1]+1);
			else
				D[i][j] = min(D[i-1][j-1]+1, D[i-1][j]+1, D[i][j-1]+1);
		}
		for (i = 1; i <= m; i++)
			cout<<D[i][j]<<"  ";
		cout<<endl;
	}
	cout<<"最小差别数是："; 
	return D[m][n];
}

运行结果：
在这里插入图片描述

迪丽娜扎
关注
近似串匹配的动态规划算法
08-04
经典 精典 精点 啊 算法太巧妙啦 介绍给大家看看 （C语言源程序），希望大家下载给我加点分啦。
算法设计之动态规划
FairLikeSnow的博客
01-30 337
这里写目录标题标题动态规划一、基本思想案例：最长公共子序列问题1.子序列和子串的定义：2.两者之间的关系：二、算法分析1.分析问题的最优子结构2.建立递推公式:3.代码:4.测试结果: 标题动态规划     通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。 一、基本思想     一般来说，只要问题可以划分成规模更小的子问题，并且原问题的最优解中包含了子问题的最优解
算法设计 --- 动态规划详解
Celine921的博客
03-12 669
这一次彻底理解动态规划
近似串匹配问题（动态规划）
失眠的树的博客
09-28 1753
近似串匹配
动态规划算法（详细解析）
weixin_43556670的博客
04-29 2367
转载：https://blog.csdn.net/qq_37763204/article/details/79394397?utm_source=distribute.pc_relevant.none-task-blog-baidujs-5 一、基本概念    动态规划是运筹学中用于求解决...
五大常用算法——动态规划算法详解及经典例题，算法数据结构
04-07
动态规划算法是一种强大的算法设计技术，主要用于解决多阶段决策过程中的最优化问题。它的核心思想是通过将复杂问题分解为相互关联的子问题，并利用子问题的最优解来构建原问题的最优解。动态规划强调的是“空间换...
背包问题的动态规划法算法(c++).rar_knapsack dynamic_动态规划法_算法设计与分析_背包问题
09-21
“动态规划法”是解决问题的关键技术，它通过将复杂问题分解为更小的子问题，然后逐个求解，最后组合得到原问题的解。动态规划特别适合解决有重叠子问题和最优子结构的问题，背包问题就具有这样的特性。 “算法设计...
经典算法——动态规划教程
01-30
动态规划是一种强大的算法设计技术，尤其适用于解决最优化问题。其核心思想是将复杂问题分解成相互关联的子问题，并逐步构建全局最优解。动态规划并非一个通用算法，而是针对不同问题采用特定策略来实现最优决策的...
算法分析与设计实验报告（贪心法，动态规划法）
09-19
本次实验主要聚焦于算法设计与分析的核心技术——贪心法与动态规划法，通过对经典问题如背包问题、汽车加油问题以及排序算法的研究与实现，加深学生对这两种算法的理解与应用能力。所有算法均采用C++语言编写，旨在...
近似串匹配问题 动态规划法——C++代码
06-08
课程的随堂作业，C语言的，用dev就能运行，萌新代码，勿喷，仅仅帮助不想写作业的朋友方便一下，反正老师也不会仔细检查的
第1-5课：算法设计常用思想之动态规划法
oRbIt 的专栏
09-22 757
上一课我们介绍了迭代法， 这一课来介绍算法设计思想（模式）中最飘逸的动态规划法，说它飘逸的原因是因为这种算法思想的原理很简单，但是落地（实现）困难。所谓落地困难是因为子问题的分解和决策状态的定义需要有相当的经验，而这种经验需要大量的实践之后才能建立起来。动态规划既不是阳春白雪般的高大上，但也不是那么就能掌握的技能，这一课我们先简单介绍一下动态规划，随后的课程里会有一系列的内容来介绍各种类型的动态规...
算法设计与分析入门篇----动态规划 2
u014671334的专栏
05-17 631
正在网易云课堂学习王宏志老师的算法设计与分析入门篇课程视频，将学习中的作业问题发上来与大家一同讨论。这篇是对第四周的作业第二题个人的一些思路，希望与大家一同学习。2括号子序列 - A（10分）题目内容： 一段括号序列被称为平衡的，如果对于任意前缀，左括号的数目都不小于右括号。 给定一段括号序列，问有多少括号子序列是平衡的。（内容相同但位置不同的算两种。）输入格式: 多组测试数据，每组测试数据包
【算法】近似串匹配问题（动态规划）
C_xixixixi的博客
04-29 3541
#include<iostream> using namespace std; int D[20][20]; // 填表矩阵设置为全局变量 int min(int a,int b,int c) { if(a<b && a<c) return a; else if(b<a && b<c) return b; e...
利用动态规划解决-字符串的匹配问题
chengxiang89228的博客
09-20 2649
也可以找字符串的最大子序列，然后相减即可，但没有验证过。    int main () {      string s1,s2;     while( cin>>s1>>s2)     {         int len1 = s1.size();         int len2 = s2.size();         vector> dp(len1+1, vector(le
动态规划(03查找问题)最优二叉查找树和近似串匹配问题
最新发布
weixin_45939614的博客
03-04 297
动态规划 查找问题
动态规划法
weixin_40273937的博客
05-29 274
一、基本思想 1.将待求问题分解为若干个子问题，先求子问题，然后将这些子问题的解得到为原问题的解。 2.分治法解决同类问题时，相同的子问题会被求解多次。动态规划法用一张表来记录所有已解决问题的子问题的答案。 ...
字符串匹配动态规划
weixin_34019144的博客
03-23 95
题目 Leetcode Edit Distance Leetcode Interleaving String Leetcode Distinct Subsequence 思路 1. 共性: 基于最后一位是否相同来决定递归函数的走向 2. 第一题. dp[i][j] 表示 str1[0...i], str2[0...j] 之间的距离 　　dp[i][j] = dp[...
字符串匹配的基本算法以及动态规划算法简析
gt11799的专栏
10-17 1780
字符串的匹配的计算量巨大，但是细细看来，可以一层一层的拆解成重复的小问题，因此引入动态规划(Dynamic Programming)算法。通过介绍动态规划算法，给出了计算字符串匹配的实现。
贝塞尔曲线法：车辆路径规划的关键技术
本资源讲述了关于智能汽车路径规划与轨迹跟踪中的一种关键算法——贝塞尔曲线法。贝塞尔曲线是由法国工程师皮埃尔·贝塞尔在1962年提出的，主要用于二维图形设计中的数学曲线生成。它通过一组控制点（如P0、P1、P2、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值