动态规划

最新推荐文章于 2023-06-01 19:25:01 发布
最新推荐文章于 2023-06-01 19:25:01 发布
阅读量187 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28840229/article/details/79758547
版权

1、钢条切割


自顶向下

int maXt(int a, int b)
{
	if (a>b)
	{
		return a;
	}
	return b;
}
int cutRod(vector<int>vec, int n)
{
	if (n==0)
	{
		return 0;
	}
	/*if (memoziedArray[n-1]>0)
	{
		return memoziedArray[n - 1];
	}*/
	int max = 0;
	for (int i = 1; i <= n&&i <= vec.size();i++)
	{
		max = maXt(max, vec[i - 1] + cutRod(vec, n - i));
	}
	return max;
}

在测试时，我们发现，当钢条的长度稍微变大（比如n=30）时，上述程序的运行时间会大大增大。仔细考虑原因，会发现实际上我们做了很多重复的递归操作。比如在求解cutRod(p, n)过程中，我们会递归求解cutRod(p, 0 ~ n-1)，而在求解cutRod(p, n-1)的过程中，同样我们会递归求解cutRod(p, 1 ~ n-1)，可以看出，仅仅就是这两次的调用，就重复调用了n-2次。时间效率当然会下降。

改进：

int maXt(int a, int b)
{
	if (a>b)
	{
		return a;
	}
	return b;
}
int *memoziedArray;
int cutRod(vector<int>vec, int n)
{
	memoziedArray = memoziedArray == NULL ? new int[n] : memoziedArray;
	if (n==0)
	{
		return 0;
	}
	if (memoziedArray[n-1]>0)
	{
		return memoziedArray[n - 1];
	}
	int max = 0;
	for (int i = 1; i <= n&&i <= vec.size();i++)
	{
		max = maXt(max, vec[i - 1] + cutRod(vec, n - i));
	}

	memoziedArray[n - 1] = max;
	return max;
}
自底向上方法 
int bottomUpCutRod(vector<int>vec, int n)
{
	int *memoziedArray = new int[n + 1];
	memoziedArray[0] = 0;
	int max = 0;
	for (int i = 1; i <= n;i++)
	{
		for (int j = 1; j <= i&&j <= vec.size();j++)
		{
			max = maXt(max, vec[j - 1] + memoziedArray[i-j]);
		}
		memoziedArray[i] = max;
	}
	return max;
}

2、最长公共子串问题LCS

     设序列X={x1,x2,……xm}和Y={y1,y2,……yn}的最长公共子序列为Z={z1,z2,……zk}。则有：

      (1)若xm=yn,则zk=xm=yn,且zk-1是Xm-1和Yn-1的最长公共子序列。

      (2)若xm!=yn且zk!=xm，则Z是Xm-1和Y的最长公共子序列。

      (3)若xm!=yn且zk!=yn，则Z是X和Yn-1的最长公共子序列。

      其中，Xm-1={x1,x2……xm-1}，Yn-1={y1,y2……yn-1},Zk-1={z1,z2……zk-1}。

递推关系：用c[i][j]记录序列Xi和Yj的最长公共子序列的长度。其中，Xi={x1,x2……xi}，Yj={y1,y2……yj}。当i=0或j=0时，空序列是xi和yj的最长公共子序列。此时，c[i][j]=0；当i,j>0，xi=yj时，c[i][j]=c[i-1][j-1]+1；当i,j>0，xi!=yj时，c[i][j]=max{c[i][j-1],c[i-1][j]}。

求最长公共子串的长度

void LCSLength(int m, int n, char *x, char *y, int **c, int **b)
{
	int i, j;

	for (i = 1; i <= m; i++)
		c[i][0] = 0;
	for (i = 1; i <= n; i++)
		c[0][i] = 0;

	for (i = 1; i <= m; i++)
	{
		for (j = 1; j <= n; j++)
		{
			if (x[i] == y[j])
			{
				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;
			}
		}
	}
}

求公共子串

void LCS(int i, int j, char *x, int **b)
{
	if (i == 0 || j == 0)
	{
		return;
	}
	if (b[i][j] == 1)
	{
		LCS(i - 1, j - 1, x, b);
		cout << x[i] << " ";
	}
	else if (b[i][j] == 2)
	{
		LCS(i - 1, j, x, b);
	}
	else
	{
		LCS(i, j - 1, x, b);
	}
}

3、LSC改进：将数组b省去

void LCSLength(int m,int n,char *x,char *y,int **c)
{
	int i,j;

	for(i=1; i<=m; i++)
		c[i][0] = 0;
	for(i=1; i<=n; i++)
		c[0][i] = 0;

	for(i=1; i<=m; i++)
	{
		for(j=1; j<=n; j++)
		{
			if(x[i]==y[j])
			{
				c[i][j]=c[i-1][j-1]+1;
			}
			else if(c[i-1][j]>=c[i][j-1])
			{
				c[i][j]=c[i-1][j];
			}
			else
			{
				 c[i][j]=c[i][j-1];
			}
		}
	}
}

void LCS(int i,int j,char *x,int **c)
{
	if(i==0 || j==0)
	{
		return;
	}
	if(c[i][j]==c[i-1][j-1]+1)
	{
		LCS(i-1,j-1,x,c);
		cout<<x[i]<<" ";
	}
	else if(c[i-1][j]>=c[i][j-1])
	{
		LCS(i-1,j,x,c);
	}
	else
	{
		LCS(i,j-1,x,c);
	}
}

4、菲波那切数列

//避免重复运算的斐波那契数列运算  
int fib(int n, map<int, int>my_Map)
{
	if (n==0||n==1)
	{
		return 1;
	}
	else
	{
		map<int, int>::iterator iter = my_Map.find(n);
		if (iter==my_Map.end())
		{
			int temp = fib(n - 1, my_Map) + fib(n - 2, my_Map);
			my_Map.insert(pair<int, int>(n, temp));
			return temp;
		}
		else
		{
			return iter->second;
		}
	}
}

5、连续最长公共子串（多个）

string getLCSLength(string &s, string &t)  
{  
    int p = s.length();  
    int q = t.length();  
  
    string **num = new string *[p];    
    for(int i=0;i<p;i++)      
    {      
        num[i] = new string[q];    
    }     
  
    char char1 = '\0';  
    char char2 = '\0';  
  
    int len = 0;  
    string lcs = "" ;  
  
    for(int i=0; i<p; i++)  
    {  
        for (int j=0; j<t.length(); j++)  
        {  
            char1 = s.at(i);  
            char2 = t.at(j);  
            if(char1!=char2)  
            {  
                num[i][j] = "" ;  
            }  
            else  
            {  
                if (i==0||j==0)  
                {  
                    num[i][j]=char1;  
                }  
                else  
                {  
                    num[i][j]=num[i-1][j-1]+char1;  
                }  
                if(num[i][j].length()>len)  
                {  
                    len = num[i][j].length() ;  
                    lcs = num[i][j];  
                }  
                else if(num[i][j].length()==len)  
                {  
                    lcs = lcs + "," + num[i][j];  
                }  
            }  
        }  
    }  
  
    for(int i=0;i<p;i++)      
    {      
        delete[] num[i];   
    }   
    delete[] num;  
  
    return lcs;  
}

6、最大子段问题

问题定义：对于给定序列a1,a2,a3……an,寻找它的某个连续子段，使得其和最大。如( -2,11,-4,13,-5,-2 )最大子段是{ 11,-4,13 }其和为20。

int MaxSum(int n,int *a,int& besti,int& bestj)  
{     
    int sum = 0;  
    for(int i=0; i<n; i++)//控制求和起始项  
    {  
        for(int j=i; j<n; j++)//控制求和结束项  
        {  
            int thissum = 0;  
            for(int k=i; k<=j; k++)//求和  
            {  
                thissum += a[k];  
            }  
  
            if(thissum>sum)//求最大子段和  
            {  
                sum = thissum;  
                besti = i;  
                bestj = j;  
            }  
        }  
    }  
    return sum;  
}

7、最大子段问题，改进

int MaxSum(int n,int *a,int& besti,int& bestj)  
{     
    int sum = 0;  
    for(int i=0; i<n; i++)//控制求和起始项  
    {  
        int thissum = 0;  
        for(int j=i; j<=n; j++)//控制求和结束项  
        {  
            thissum += a[j];//求和  
            if(thissum>sum)  
            {  
                sum = thissum;  
                besti = i;  
                bestj = j;  
            }  
              
        }  
    }  
    return sum;  
}

8、最大子段和：分治算法

int MaxSubSum(int *a,int left,int right)  
{     
    int sum = 0;  
    if(left == right)  
    {  
        sum = a[left]>0?a[left]:0;  
    }  
    else  
    {  
        int center = (left+right)/2;  
        int leftsum = MaxSubSum(a,left,center);  
        int rightsum = MaxSubSum(a,center+1,right);  
  
        int s1 = 0;  
        int lefts = 0;  
        for(int i=center; i>=left;i--)  
        {  
            lefts += a[i];  
            if(lefts>s1)  
            {  
                s1=lefts;  
            }  
        }  
  
        int s2 = 0;  
        int rights = 0;  
        for(int i=center+1; i<=right;i++)  
        {  
            rights += a[i];  
            if(rights>s2)  
            {  
                s2=rights;  
            }  
        }  
        sum = s1+s2;  
        if(sum<leftsum)  
        {  
            sum = leftsum;  
        }  
        if(sum<rightsum)  
        {  
            sum = rightsum;  
        }  
  
    }  
    return sum;  
}  
  
int MaxSum(int n,int *a)  
{  
    return MaxSubSum(a,0,n-1);  
}

9、最大子段和：动态规划

int MaxSum(int n,int *a)  
{  
    int sum=0,b=0;  
    for(int i=1; i<=n; i++)  
    {  
        if(b>0)  
        {  
            b+=a[i];  
        }  
        else  
        {  
            b=a[i];  
        }  
        if(b>sum)  
        {  
            sum = b;  
        }  
    }  
    return sum;  
}

10、最大矩阵和

int MaxSum2(int m,int n,int a[M][N])  
{  
    int sum = 0;  
    int *b = new int[n+1];  
    for(int i=0; i<m; i++)//枚举行  
    {  
        for(int k=0; k<n;k++)  
        {  
            b[k]=0;  
        }  
  
        for(int j=i;j<m;j++)//枚举初始行i,结束行j  
        {  
            for(int k=0; k<n; k++)  
            {  
                b[k] += a[j][k];//b[k]为纵向列之和  
                int max = MaxSum(n,b);  
                if(max>sum)  
                {  
                    sum = max;  
                }  
            }  
        }  
    }  
    return sum;  
}  
  
int MaxSum(int n,int *a)  
{  
    int sum=0,b=0;  
    for(int i=1; i<=n; i++)  
    {  
        if(b>0)  
        {  
            b+=a[i];  
        }  
        else  
        {  
            b=a[i];  
        }  
        if(b>sum)  
        {  
            sum = b;  
        }  
    }  
    return sum;  
}

11、最大m子段和

问题描述：给定由n个整数(可能为负数)组成的序列a1,a2,a3……an,以及一个正整数m,要求确定此序列的m个不相交子段的总和达到最大。最大子段和问题是最大m字段和问题当m=1时的特殊情形。

int MaxSum(int m,int n,int *a)  
{  
    if(n<m || m<1)  
        return 0;  
    int *b = new int[n+1];  
    int *c = new int[n+1];  
  
    b[0] = 0;//b数组记录第i行的最大i子段和  
    c[1] = 0;//c数组记录第i-1行的最大i-1子段和  
  
    for(int i=1; i<=m; i++)  
    {  
        b[i] = b[i-1] + a[i];  
        c[i-1] = b[i];  
        int max = b[i];  
  
        //n-m+i限制避免多余运算，当i=m时，j最大为n，可据此递推所有情形  
        for(int j=i+1; j<=i+n-m;j++)  
        {  
            b[j] = b[j-1]>c[j-1]?b[j-1]+a[j]:c[j-1]+a[j];  
            c[j-1] = max;//预先保存第j-1行的最大j-1子段和  
  
            if(max<b[j])  
            {  
                max = b[j];  
            }  
        }  
        c[i+n-m] = max;  
    }  
  
    int sum = 0;  
    for(int j=m; j<=n; j++)  
    {  
        if(sum<b[j])  
        {  
            sum = b[j];  
        }  
    }  
    return sum;  
}

12、背包问题

给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问:应如何选择装入背包的物品，使得装入背包中物品的总价值最大?


AtwOne
关注
专栏目录
动态规划实验报告
05-30
算法分析与设计 动态规划实验：矩阵连乘与最大字段和
动态规划算法的应用实验报告.doc
04-28
1．掌握动态规划算法的基本思想，包括最优子结构性质和基于表格的最优值计算方法。 2．熟练掌握分阶段的和递推的最优子结构分析方法。 3．学会利用动态规划算法解决实际问题。 题目一：数塔问题 给定一个数塔，其存储形式为如下所示的下三角矩阵。在此数塔中，从顶部出发，在每一节点可以选择向下走还是向右走，一直走到底层。请找出一条路径，使路径上的数值和最大。
动态规划实验报告matlab,matlab动态规划
weixin_39583222的博客
03-16 943
动态规划matlab仿真实例_数学_自然科学_专业资料。动态规划在火力分配中的应...施益昌, 郑贤斌, 李自立 1 基于 Matlab 动态规划中最短路 线的实现程...动态规划方法的 matlab 实现及其应用(龙京鹏,张华庆,罗明良,刘水林) (南昌航空大学,数学与信息科学学院,江西,南昌) 摘要:本文运用 matlab 语言实现了动态规划的逆序......最优化方法的发展很快,现在已经包含...
代码 随机动态规划的实例的matlab代码
06-04
代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的...
会议安排（贪心算法和动态规划） 贪心算法和动态规划.pdf
04-08
会议安排（贪心算法和动态规划） 会议安排问题是计算机科学中的一种经典问题，目的是在一系列活动中选择尽可能多的活动，使得每个活动的结束时间不早于下一个活动的开始时间。这个问题可以使用贪心算法和动态规划两...
动态规划动态规划.zip
最新发布
10-25
动态规划（Dynamic Programming，简称DP）是解决复杂问题的有效算法设计方法，尤其在计算机科学和IT领域中占有重要地位。它通过将一个大问题分解为若干个子问题，并利用子问题的解来构建原问题的解，从而避免了重复...
动态规划解决TSP问题用动态规划算法求解TSP，数据为Solomon数据集的c101文件读取，可视化路径图，用图展示每次迭代的最
10-22
动态规划是一种解决问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，它的目标是找到一个城市的最短可能路线，使得...
贪心算法、分治算法和动态规划的区别 贪心算法和动态规划.pdf
04-08
贪心算法、分治算法和动态规划的区别 贪心算法、分治算法和动态规划是三种常用的算法设计策略，每种算法都有其特点和应用场景。下面我们将对这三种算法进行详细的比较和分析。 分治算法 分治算法是一种将原问题...
c++最长公共子序列问题LCSLength
11-04
动态规划的问题解题思路都差不多（一些浅见），基本要素是最优子结构性质，子问题重叠性质，自底向上的求解方法。只要了解了基本要素，那么这种题型也会更好理解。本题有不少注释，便于读者阅读。
【动态规划】最长公共子序列问题(LCS)
yearningseeker的博客
05-10 524
本文转载自：http://blog.csdn.net/liufeng_king/article/details/8500084   问题描述：一个给定序列的子序列是在该序列中删去若干元素后得到的序列。确切地说，若给定序列X= { x1, x2,…, xm}，则另一序列Z= {z1, z2,…, zk}是X的子序列是指存在一个严格递增的下标序列 {i1, i2,…, ik}，使得对
【算法】动态规划法——最长公共子序列（LCS）
NewGe6的博客
10-14 3050
前言 这篇是大三算法分析与设计课程的第一篇博客，写他是因为上课学到了，并且也算是留作记忆，以后学习时方便使用。 这篇博客主要想讲讲动态规划法，然后以LCS问题为例展开来说一下怎么利用动态规划法求解它，下面是自己的一些理解和总结，有不对的地方还请大家指正。 动态规划法 动态规划法（dynamic programming）通常用于求解最优化问题（optimiza...
3.3 最长公共子序列
tang7mj的博客
06-01 2436
我的理解：在字符串或序列中，子序列是指从原始序列中删除零个或多个元素后得到的序列，而且相对顺序保持不变。换句话说，子序列是从原始序列中选择出的元素，它们保持相对顺序，但可以跳过一些元素或者不选择任何元素。举个例子，考虑序列 "abcd"，它的一些子序列包括："a"，"b"，"c"，"d"，"ab"，"ac"，"ad"，"bc"，"bd"，"cd"，"abc"，"abd"，"acd"，"bcd"，"abcd"。注意，这些子序列可能不一定是连续的，可以跳过某些元素。
算法之动态规划算法---最长公共子序列
weixin_52561679的博客
04-13 816
参考书中的伪码用C编写： #include <stdio.h> #include <stdlib.h> void LCSLength(int m,int n,char *x,char *y,int *c[],int *b[]) { int i,j; for(i=1;i<=m;i++) c[i][0]=0; for(i=1;i<=n;i++) c[0][i]=0; for(i=1;i<=m;i++){ for(j=1;j<=n;j++){
最长公共子序列
qq_41381461的博客
09-18 330
求解两个字符串的最长公共子序列 题目描述 最长公共子序列 最优解(最大长度) void LCSlength(int m,int n,char *x,char *y,int **c,int **b) { int i,j; for(i=1;i<=m;i++)c[i][0]=0; for(i=1;i<=n;i++)c[0][i]=0; //i=0或者j=0,最长公共子序列为空...
动态规划-----最长公共子序列
一个人的学习和碎碎念
12-13 201
  具体思想可以参考这篇文章，很详细。（https://blog.csdn.net/hrn1216/article/details/51534607） #include&lt;iostream&gt; #include&lt;string.h&gt; using namespace std; /*给定两个序列X，Y，当另一个序列Z既是X的子序列也是Y的子序列时，称Z为X,Y的公共子序列。 求...
动态规划算法实验报告_动态规划算法
weixin_39804631的博客
11-24 3029
动态规划算法是经典的最优值寻找算法，不同于贪心算法(局部最优，只考虑下一步最好的选择)，每步都会考虑是否全局最优。为了便于理解，这里将通过理论与实际案例相结合来介绍。一、基本概念动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。二、基本思想与策略基本思想与分治法类似，也是将待求解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值