算法设计与分析--动态规划算法

已于 2022-11-22 10:27:02 修改
阅读量369 收藏
点赞数
分类专栏： 算法程序设计学习 文章标签： 算法 动态规划 c++
于 2022-10-14 15:19:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67522539/article/details/127321122
版权

动态规划算法的有效性依赖于问题本身所具有的两个重要性质：最优子结构、重叠子问题。

动态规划算法，对每一个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此子问题时，只是简单地用常数时间查看一下结果。

动态规划算法是分阶段决策，最终使整个过程达到最好的决策。得到的是全局最优解。

各个阶段决策的选取不是任意确定的，它依赖于当前面临的状态，又影响以后的发展。

 

01:最长单调递增子序列（重点）

总时间限制: 

5000ms

内存限制: 

65535kB

描述

一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8).

你的任务，就是对于给定的序列，求出最长上升子序列的长度。

输入

输入两行.第一行输入n（n<=1000）的值，第二行输入n各数

输出

最大上升子序列的长度

样例输入

8
65 158 170 155 239 300 207 389

样例输出

6
#include <iostream>
using namespace std;

#define NUM 100
int a[NUM];
int LIS_n2(int n)
{
    int b[NUM]={0};
    int i,j;
    b[1]=1;
    int max=0;
    for(i=2;i<=n;i++)
    {
        int k=0;
        for(j=1;j<i;j++){
            if(a[j]<=a[i]&&k<b[j]){ k=b[j];
        b[i]=k+1;}
        if(max<b[i]){ max=b[i];}
      }
    }
    return max;
}
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    cout<<LIS_n2(n)<<endl;
    return 0;
}

02:点菜

总时间限制: 

5000ms

内存限制: 

65535kB

描述

题目描述：umi拿到了uoi的镭牌后，立刻拉着基友小A到了一家餐馆，很低端的那种。uim指着墙上的价目表（太低级了没有菜单），说：“随便点”。不过uim由于买了一些书，口袋里只剩M元(M≤10000)。餐馆虽低端，但是菜品种类不少，有N种(N≤100)，第i种卖ai元(ai ≤1000)。由于是很低端的餐馆，所以每种菜只有一份。

小A奉行“不把钱吃光不罢休”，所以他点单一定刚好把uim身上所有钱花完。他想知道有多少种点菜方法。

输入

第一行是两个数字，表示N和M。

第二行起N个正数ai（可以有相同的数字，每个数字均在10001000以内）。

输出

一个正整数，表示点菜方案数，保证答案的范围在int之内。

样例输入

4 4
1 1 2 2

样例输出

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

struct obj
{
    int v;
};
int main()
{
    obj list[101];
    int N,M;
    cin>>N>>M;
    for(int i=1;i<=N;i++){
        cin>>list[i].v;
    }
    vector<vector<int>>dp(N+1,vector<int>(M+1));
    dp[0][0]=1;
    for(int i=1;i<=N;i++){
        for(int j=0;j<=M;j++){
            if(j>=list[i].v)
                dp[i][j]=dp[i-1][j-list[i].v]+dp[i-1][j];
            else
                dp[i][j]=dp[i-1][j];
        }
    }
    cout<<dp[N][M];
    return 0;
}

03:合唱队形

总时间限制: 

5000ms

内存限制: 

655360kB

描述

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK，  则他们的身高满足T1<...<Ti>Ti+1>…>TK(1<=i<=K)。已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

输入

输入的第一行是一个整数N(2<=N<=100)，表示同学的总数。 第二有N个整数，用空格分隔，第i个整数Ti(130<=Ti<=230)是第i位同学的身高(厘米)。

输出

输出最少需要几位同学出列。

样例输入

8
186 186 150 200 160 130 197 220

样例输出

4
#include <iostream>
using namespace std;

int n;
int a[100];
int dp[100];
int max_up(int p)
{
    int Max=0;
    for(int i=0;i<=p;i++)
    {
        dp[i]=1;
        for(int j=0;j<i;j++)
        {
            if(a[j]<a[i]){
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
        Max=max(Max,dp[i]);
    }
    return Max;
}

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

int maxinde()
{
    int Max=0;
    for(int i=0;i<n;i++)
    {
        int ans=max_up(i)+max_down(i)-1;
        Max=max(Max,ans);
    }
    return n-Max;
}
int main()
{
    while(cin>>n)
    {
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
        }
        int ans=maxinde();
        cout<<ans<<endl;
    }
    return 0;
}

04:数塔问题

总时间限制: 

1000ms

内存限制: 

65535kB

描述

设有一个三角形的数塔，顶点为根结点，每个结点有一个整数值。从顶点出发，可以向左走或向右走，如图所示：

若要求从根结点开始，请找出一条路径，使路径之和最大，只要输出路径的和。

输入

第一行为n(n<50)，表示数塔的层数
从第2行至n+1行，每行有若干个数据，表示数塔中的数值。

输出

最大的路径值。

样例输入

5
13
11  8
12  7  26
6  14  15  8
12  7  13  24  11

样例输出

86

#include <iostream>
using namespace std;

#define NUM 100
int tri[NUM][NUM];
int triangle(int n)
{
    int i,j;
    for(i=n-1;i>=0;i--)
        for(j=0;j<=i;j++)
            if(tri[i+1][j]>tri[i+1][j+1])
               tri[i][j]+=tri[i+1][j];
            else tri[i][j]+=tri[i+1][j+1];
    return tri[0][0];
}

int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i;j++)
            cin>>tri[i][j];
    }
    cout<<triangle(n)<<endl;
    return 0;
}

05:最大子段和（重点）

总时间限制: 

5000ms

内存限制: 

65535kB

描述

问题： 给定n个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时定义子段和为0，依此定义，所求的最优值为： Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n 例如，当（a[1],a[2],a[3],a[4],a[5],a[6]）=(-20,11,-4,13,-5,-2)时，最大子段和为20。

输入

输入n及n个数

输出

子段和的最大值

样例输入

6
-20 11 -4 13 -5 -2

样例输出

20

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

#define NUM 1001
int a[NUM];
int MaxSum(int n)
{
    int sum=0;
    int 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;
}
int main()
{
    int n,m;
    cin>>n;
    int a[n];
    for(int i=1;i<=n;i++)
        cin>>a[i];
    m=MaxSum(n);
    cout<<m<<endl;
    return 0;
}

06:最长公共子序列（重点）

会写出计算最长公共子序列长度的递推式即可

总时间限制: 

5000ms

内存限制: 

65535kB

描述

若给定序列X={x1,x2,…,xm}，则另一序列Z={z1,z2,…,zk}，是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xij。

例如，序列Z={B，C，D，B}是序列X={A，B，C，B，D，A，B}的子序列。

给定2个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。

给定2个序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}，找出X和Y的最长公共子序列。

输入

三行.第一行m和n,分别表示两个子序列的长度（符号的个数）
接下来两行，分别表示X和Y

输出

最长公共子序列的长度

样例输入

7 6
ABCBDAB
BDCABA

样例输出

4
#include <iostream>
#include <vector>
using namespace std;

#define NUM 100
int c[NUM][NUM];
int b[NUM][NUM];
void LCSLength(int m,int n,const char x[],char y[])
{
    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[])
{
    if(i==0||j==0) return;
    if(b[i][j]==1){ LCS(i-1,j-1,x);printf("%c",x[i]);}
    else if(b[i][j]==2) LCS(i-1,j,x);
    else LCS(i,j-1,x);
}
int main()
{
    string x,y;
    int m= x.length(),n= y.length();
    cin>>m>>n;
    cin>>x>>y;
    for(int i = 1;i <= m;i ++)
  		for(int j = 1;j <= n;j ++)
  		{
  			c[i][j] = max(c[i - 1][j],c[i][j - 1]);
  			if (x[i - 1] == y[j - 1])
  			   c[i][j] = max(c[i][j],c[i - 1][j - 1] + 1);
  		}
  	cout << c[m][n] << endl;
  	return 0;
}

07:矩阵连乘积问题（重点）

已知：给定n个矩阵{A1,A2,...,An}，其中Ai与Ai+1是可乘的，

计算：这n个矩阵的连乘积A1A2...An所需要的乘法运算的次数的最小值。

 设有四个矩阵A,B,C,D，它们的维数分别是：A=50×10，B=10×40，C=40×30，D=30×5 总共有五种完全加括号的方式： (A((BC)D))     (A(B(CD)))  ((AB)(CD)) (((AB)C)D)  ((A(BC))D)

动态规划法：

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

int p[11];
int m[101][101];//记录子问题的最优值,最少乘法次数
int s[101][101];//记录子问题的最优解

void Maxs(int n)
{
    for(int i=1;i<=n;i++)
        m[i][i]=0;//长度是1的矩阵链连乘的计算次数
    for(int r=2;r<=n;r++)//矩阵链的长度，按照矩阵链长度递增的方法完成计算
        for(int i=1;i<=n-r+1;i++)//连乘的起点
    {
        int j=i+r-1;//矩阵链中的最后一个矩阵的编号
        m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];//m[i][j]的假设值
        s[i][j]=i;//断开位置的初值，记录即最优解的初值
        for(int k=i+1;k<j;k++)
        {
            int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
            if(t<m[i][j])
            {
                m[i][j]=t;
                s[i][j]=k;
            }
        }
    }
}

void printM(int m[101][101], int n)
{
int i,j;
for(i = 1; i <= n; i++)
{
for(j = 1; j <= n; j++)
{
printf("%d\t",m[i][j]);
}
printf("\n");
}
}

void printS(int s[101][101], int n)
{
int i,j;
for(i = 1; i <= n; i++)
{
for(j = 1; j <= n; j++)
{
printf("%d\t",s[i][j]);
}
printf("\n");
}
}

int main()
{
    int n;//矩阵个数
    cin>>n;
    for(int i=0;i<=n;i++)//每一个矩阵维数
    {
        cin>>p[i];
    }
    Maxs(n);
    printf("最少数乘次数矩阵 \n");
printM(m ,n);
printf("最佳断开位置矩阵 \n");
printS(s, n);
}

 备忘录算法（仅算法）：

int LookupChai  (int i, int j){ 
if (m[i][j]>0) return m[i][j]; 
if (i==j) return 0; 
int u = LookupChain(i,i)+LookupChain(i+1,j)+p[i-1]*p[i]*p[j]; 
s[i][j] = i; 
for (int k = i+1; k<j; k++) { 
  Int  t = LookupChain(i,k)+LookupChain(k+1,j)+p[i-1]*p[k]*p[j]; 
  if (t < u) { u = t; s[i][j] = k;} 
} 
m[i][j] = u; 
return u;
}

08:0-1背包问题（重点）

分析

阶段:   1~n ，依次处理（考察）前 i 件物品

状态： 背包的容量：1~m    

决策： 在第 i 阶段，在背包容量是v（1~m之间） 的情况下，如何处理前 i 件物品，才能使装入背包中的物品价值最大。

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

const int maxm = 201, maxn = 31;
int m, n;
int w[maxn], c[maxn];
int f[maxn][maxm];
int max(int x,int y)
{
    if(x>y)
        return x;
    else
        return y;
}

int main()
{
   cin>>m>>n;//背包容量m,物品数量n;
   for(int i=1;i<=n;i++)
      cin>>w[i]>>c[i];//每个物品的重量和价值
    for(int i=1;i<=n;i++)
        for(int v=m;v>=1;v--)
    {
        if(w[i]<=v)//v表示背包剩余容量
            f[i][v]=max(f[i-1][v],f[i-1][v-w[i]]+c[i]);
        else
            f[i][v]=f[i-1][v];
    }
    cout<<f[n][m]<<endl;//f[n][m]为最优解
    return 0;
}

 

 

牛马研究僧王老汉
关注
专栏目录
算法设计与分析之动态规划
05-26
这里面的内容很基础，但很经典，想学好算法这门课的同志建议大家看这个，不要看市面上的一些很难懂的！
算法设计与分析_练习三_动态规划算法
最新发布
qq_55793988的博客
11-06 808
动态规划
算法设计与分析——动态规划
krain的博客
06-09 2184
文章目录1. 动态规划1.1 基本思想1.2 设计步骤1.3 两个要素（特征）1.4 动态规划实质2. 典型算法案例2.1 最长单调递增子序列2.1.1 问题描述2.1.1 递归方程2.1.2 代码实现2.2 0-1背包问题2.2.1 问题描述2.2.1. 递归方程2.2.3 复杂度2.2.4 代码实现2.3 矩阵连乘积问题2.3.1 问题描述2.3.2 建立递推公式2.3.3 复杂度2.3.3 代码实现3. 动态规划与分治法区别4. 动规与分支对问题进行分解时各
算法设计与分析【3】动态规划算法
qq_34391511的博客
06-06 729
目录动态规划基本思想影响算法复杂度的因素经典案例最短路径背包问题图像压缩最优二叉树 动态规划 基本思想 动态规划的基本思想是将待求解的问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解；这些求解的子问题往往不是相互独立的；另外，在计算过程中需要将所有已解决的子问题的答案记录在一个表中以避免大量的重复计算。 影响算法复杂度的因素 最优子结构性质 子问题的重叠性质 经典案例 最短路径 背包问题 图像压缩 最优二叉树 ...
算法设计与分析 —— 5-3 动态规划算法设计
梦Dancing的博客
10-29 369
 
算法设计与分析-4动态规划金罐游戏源代码.cpp
06-18
算法设计与分析-4动态规划金罐游戏源代码.cpp （1） 动态规划算法设计思想。 （2） 金罐游戏问题的动态规划解法。 通过本次实验，我尝试了使用蛮力法（简单重复递归）和动态规划解决金罐问题，在该过程中我加深了...
北航算法设计与分析-韩军.7z
04-18
《算法设计与分析》是计算机科学领域的一门核心课程，主要研究如何有效地解决问题，并通过计算机程序实现这些解决方案。韩军教授的这本教材是北航（北京航空航天大学）在该领域的经典教学资源，旨在帮助学生深入理解...
0.jlmao-ch3-算法设计与分析-动态规划.ppt
05-28
0.jlmao-ch3-算法设计与分析-动态规划.ppt
算法设计与分析（三）动态规划（一）
SakuraMashiro的博客
11-27 967
基本思想 1.动态规划是一种使多阶段决策过程最优的通用方法。2.动态规划算法与分治法类似，其思想把求解的问题分成许多阶段或多个子问题，然后按顺序求解各子问题。最后一个阶段或子问题的解就是初始问题的解。3.动态规划中分解得到的子问题往往不是互相独立的。但不同子问题的数目常常只有多项式级。用分治法求解时，有些子问题被重复计算了许多次，从而导致分治法求解问题时间复杂度较高。 4.动态规划基本思想是保留
动态规划的描述与分析方法——《算法导论》
karry_zzj的博客
04-09 554
背景：动态规划是一个很难的算法，以我近些日子做的动态规划的题目来看，十个里面有八个我是想不出来是怎么做的，因为有许多问题需要思考它的递推式，而我那么笨，就是找不到解决此问题的方法，所以我要系统地理论性地将《算法导论》中的动态规划的分析方法整理出来，以便以后做题时能够合理分析此问题。动态规划描述：它应用于子问题重叠的情况，即不同的子问题具有公共的子子问题（子问题的求解是递归进行的，将其划分为更小的子子
算法设计与分析案例代码总结(二)：动态规划
zycode1561的博客
11-16 560
动态规划  动态规划是一种使多阶段决策过程最优的通用方法。与分治法类似，其思想把求解的问题分成许多阶段或多个子问题，然后按顺序求解各子问题。但动态规划中分解得到的子问题往往不是相互独立的，但不同子问题的数目常常只有多项式级。所以在动态规划中，我们要保留已解决子问题的解，避免大量重复计算，从而提升算法效率。  以下是各种案例的原理代码总结： 矩阵连乘问题 问题描述： 给定n个矩阵｛A1,A2,…,A...
动态规划最多任务工资java_五大常用算法之二：动态规划算法，会用的程序员工资都翻倍了...
weixin_28884741的博客
02-28 301
动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。二、基本思想与策略基本思想与分治法类似，也是将待求解的问题分解为若干个子问题(阶段)，按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢...
算法设计与分析复习-动态规划例子代码
03-25 516
需要注意的一点： 1.找出递推关系式，用空间存储中间结果，递推求解。 2.算法的描述中数组从1开始，实际上却是0开始，我处理的方式是不用0下标的元素，置为-1. 3.如有错误，欢迎指出~~ //动态规划 VS 分治 //Common: 均是分解问题，组合子问题求解 //Different: /* 1.分治：自上而下 规划：自下而上 2.分治：不能避免重复计算、应尽量划分成单独
动态规划算法(n阶整数矩阵，从子行、子列、子斜线中找小于整数k的最长线)
jiaxuejun的博客
11-18 1592
动态规划算法：一个n阶整数矩阵，给定一个整数k，求出最长的一条线(子行，子列，子斜线)，其和小于等于k。 算法说明：对于给定的n阶矩阵，实现了对行、列、正斜线(\)的查找，由于反斜线(/)的查找与正斜线相似，因此未实现；另，在分别对上三角和下三角实行查找时，正对角线重复了一次
算法分析与设计——动态规划
qq_40438165的博客
09-20 2253
\quad动态规划是将一个问题分解为若干不重合子问题，通过求解每个子问题的解来得到问题的解。 问题一、带权区间调度问题 \quad给定n个区间，每个区间包含起始时间、结束时间和权重，目的是找出若干个不重合的区间，使得这些区间权重和最大。不带权重的区间调度问题我们可以用贪心算法求解，即将区间按照结束时间从小到大排序，按照这个顺序依次选择与当前区间集不冲突的区间，这样能得到最多的不冲突的区间数量。 \...
算法分析与设计----动态规划
zhourunan
07-24 398
动态规划的原理 基本思想：将待求问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 基本要素： 最优子结构  重叠子问题 设计动态规划算法的步骤： 找出最优解的性质，并刻画其结构特征； 递归地定义最优值； 以自底向上的方式计算最优值； 根据计算最优值时得到的信息构造最优解。 动态规划与分治法的异同 共同点： 将待求解的问题分解成若干子问题，先求解子问题，...
《算法设计与分析》-动态规划解析
"这是一份关于动态规划算法的PPT，属于计算机科学中的算法设计与分析领域。由王晓东编著的《算法设计与分析》教材涵盖了递归、分治策略、动态规划、贪心算法、回溯法、分支限界法等核心算法主题。动态规划算法是解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值