动态规划学习小结-12138

已于 2023-03-22 08:37:46 修改
阅读量235 收藏
点赞数
分类专栏： 算法学习 文章标签： 动态规划 算法
于 2022-04-02 22:20:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51370197/article/details/123908727
版权

目录

无后效性，当前的若干个状态值一旦确定，则此后过程的演变就只和这若干个状态的值有关，和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态，没有关系。。
最优子结构，问题的最优解，可以由相互关联的子问题的最优解推出来。
重叠子问题，后续问题的求解，需要之前的数据。

线性动态规划

最长单调递增子序列

题意：对于给定的一个序列(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个数，以空格隔开。
最优子结构：dp[4]的值要由dp[1],dp[2],dp[3]中的最大值确定且a[4]>a[i],i=1…3。
重叠子问题：在最优子结构的说明中已经体现。
无后效性：dp[4]的确定只关心a[4]与a[i]的大小关系，不关心dp[1…3]是如何确定的。
代码：

#include <bits/stdc++.h>
#define eps 1e-15
using namespace std;
int n;
int dp[105],a[105];
void solve(){
    dp[1]= 1;
    for(int i= 2; i<= n; i++){
        int m= 0;
        for(int j= 1; j< i; j++)if(a[i]>= a[j] && dp[j]> m)m= dp[j];
        dp[i]= m+1;
    }
}
int main()
{

	cin>>n;
	for(int i = 1; i <= n; i++)cin>>a[i];
	solve();
	int maxx=0;
	for(int i= 1; i<= n; i++)if(dp[i]> maxx)maxx= dp[i];
	cout<<maxx;
    return 0;
}
最大字段和

题意：给出一个长度为 n 的序列 a，选出其中连续且非空的一段使得这段和最大，如果最大值为负数则最大值为0。
输入：第一行n，表示序列长度。第二行n个数，以空格隔开。
最优子结构：dp[4]的值要由dp[1],dp[2],dp[3]中与a[4]和的最大值确定。
重叠子问题：在最优子结构的说明中已经体现。
无后效性：dp[4]的确定只关心a[4]+a[i]的值，不关心dp[1…3]是如何确定的。
代码：

#include <bits/stdc++.h>
#define eps 1e-15
using namespace std;
int n,a[105];
int dp[105];
//b,l用于输出最优解
int solve(int &b,int &l){
    int sum=0;
    b=0;l=0;
    for(int i=1;i<=n;i++){
        if(dp[i-1]==0)b=i;
        dp[i]=max(dp[i-1]+a[i],0);
        if(dp[i]>sum){sum=dp[i];l=i;}
    }
    return sum;
}
int main()
{
    cin>>n;
    int b,l;
    for(int i=1;i<=n;i++)cin>>a[i];
    int sum=solve(b,l);
    cout<<b<<" "<<l<<endl;
    cout<<sum;
    return 0;
}
最长公共子序列

题意：若给定序列X={x1,x2,…,xm}，则另一序列Z={z1,z2,…,zk}，是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xij。
输入：第一行两个整数，以空格隔开，分别表示两个序列的长度。第二行两串字符串，以空格隔开。
最优子结构：因为每次对两个序列比较时都会比较a[i]和b[j]是否相同或抄下c[i][j-1]和c[i-1][j]的较大值，所以才存在最优子结构，每次比较也只需要关注a[i]和b[j]是否相同以及c[i][j-1]和c[i-1][j]谁大谁小。
重叠子问题：在最优子结构的说明中已经体现。
无后效性：应该也可以在最优子结构中体现。
代码：

#include <iostream>
#define MAX 101
using namespace std;
char a[MAX],b[MAX];
int m,n;
int c[MAX][MAX];//c[i][j]表示a序列到i，b序列到j的最长子序列长度
string s[MAX][MAX];
void LCSLength(){
    int i, j;
    for(i = 0; i <= m; i++)c[i][0]=0;
    for(j = 0; j <= n; j++)c[0][j]=0;
    for(i = 1; i <= m; i++)
        for(j = 1; j <= n; j++){
            if(a[i] == b[j]){c[i][j] = c[i-1][j-1] + 1;s[i][j] = s[i-1][j-1] + a[i];}
            else if(c[i-1][j] > c[i][j-1]){c[i][j] = c[i-1][j];s[i][j] = s[i-1][j];}
            else {c[i][j] = c[i][j-1];s[i][j] = s[i][j-1];}
    }
}

int main()
{
    cin>>m>>n;
    for(int i = 1;i <= m; i++)
        cin>>a[i];
    for(int i = 1;i <= n; i++)
        cin>>b[i];
    LCSLength();
    for(int i=1; i<=m; i++){
        for(int j=1; j<=n; j++)
        cout<<c[i][j];
        cout<<endl;
    }
    cout<<c[m][n]<<" ";
    cout<<s[m][n];
    return 0;
}
合唱队形

题意：N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足T1<…Ti+1>…>TK(1<=i<=K)。已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
输入：第一行n，表示n位同学。第二行n个数，表示每个同学的身高。
只需要运用两次最长单调子序列
代码：

#include <bits/stdc++.h>
#define eps 1e-15
using namespace std;
int n;
int a[102];
int dp[102];
int dpf(int i,int k){
    dp[i]= 1;
    for(int l= i+1; l<= k; l++){
        int m= 0;
        for(int j= i; j< l; j++)if(a[l]> a[j] && dp[j]> m)m= dp[j];
        dp[l]= m+1;
    }
    int maxx=0;
   for(int l= i; l<= k; l++)if(dp[l]> maxx)maxx= dp[l];
   return maxx;
}
int solve(){
    int ans=0,num;
    for(int k=1;k<n;k++){
        if(a[k]<a[k+1]){
        num = dpf(1,k) + dpf(k+1,n);
        if(num > ans){ans = num;/*cout<<k<<" "<<ans<<endl;*/}
        }
    }
    return ans;
}

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
	cout<<n-solve();
    return 0;
}

导弹拦截
滑雪
挖地雷

区间动态规划

矩阵连乘积问题

题意：给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1，2…，n-1。如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。
最优子结构：每次对矩阵进行加括号都要选择使(m[i][k]+m[k+1][j]+p[i-1]*p[i]*p[j])最小的k，这样一直分最后就变成一个矩阵的情况，然后从1个矩阵到n个矩阵递推。
分析：此问题需要知道每几个矩阵乘积的值，所以需要算出全部的两个矩阵乘积，三个矩阵乘积等等，每一次循环都可以组成一个矩阵对角线
代码：

#include <iostream>
#define MAX 51
using namespace std;
int m[MAX][MAX];
int p[MAX];
int s[MAX][MAX];
/*
m[i][j]=min(m[i][k]+m[k+1][j]+p[i-1]*p[i]*p[j])
*/

void matrixChain(int n){
        for(int i = 1; i <= n; i++)m[i][i]=0;
            for(int r = 2; r <= n; r++)//表示对角线
            for(int i = 1; i <= n-r+1; i++){
            int j = r+i-1;
            int temp = 99999999;
            for(int k = i; k < j; k++){
                if(m[i][k] + m[k+1][j] + p[i-1]*p[k/*加的乘积需要注意*/]*p[j] < temp){
                    m[i][j] = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
                    temp = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
                    s[i][j] = k;
                }
            }
    }
}
//找出最优解
void traceBack(int i,int j){
    if(i == j){cout<<"A"<<i;return;}
    int k = s[i][j];
    cout<<"(";
    traceBack(i,k);
    traceBack(k+1,j);
    cout<<")";
}
int main()
{
    int n;
    cin>>n;
    for(int i = 1; i <= n; i++){cin>>p[i-1]>>p[i];}
    matrixChain(n);
    cout<<m[1][n];
    traceBack(1,n);
    return 0;
}

背包问题

0-1背包

#include <bits/stdc++.h>
#define eps 1e-15
using namespace std;
int n,value;
int w[105],v[105];
int dp[105][105];
int ans[105];
int max(int a,int b){
    return a>b?a:b;
}
void solve(){
    for(int i=n;i>=1;i--)
    for(int j=1;j<=value;j++){
        if(j<w[i])dp[i][j] = dp[i+1][j];
        else dp[i][j] = max(dp[i+1][j], dp[i+1][j-w[i]] + v[i]);
    }
}
void traceBack(){
    int i = 1,j = value;
    while(i <= n){
//            cout<<i<<" "<<j<<" "<<dp[i][j]<<" "<<dp[i+1][j-w[i]] + v[i]<<endl;
        if(dp[i][j] == dp[i+1][j-w[i]] + v[i]){ans[i] = 1; j = j-w[i]; i++;}
        else {i++;}
    }
}
int main()
{
    cin>>n>>value;
    for(int i=1;i<=n;i++)cin>>w[i]>>v[i];
    solve();
    traceBack();
	cout<<dp[1][value]<<endl;
	for(int i=1;i<=n;i++)
        cout<<ans[i]<<" ";
    return 0;
}
栈

题意：现在可以进行两种操作。将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的 push 操作）。将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的 pop 操作）。你的程序将对给定的 n，计算并输出由操作数序列 1,2,…,n 经过操作可能得到的输出序列的总数。
代码：

#include <bits/stdc++.h>
#define eps 1e-15
using namespace std;
//dp i j，表示栈内有i个，输出了j个情况的个数，这是关键
//背包类型的题目，只有出栈和入栈两种选择，那相应的dp[i][j]表示的意义就也知道了
//卡特兰数 f[i] = f[0]*f[n-1]+f[1]f[n-2]+...+f[n-1]f[0];
int dp[20][20],n;
void solve(){
    for(int i = 1; i <= n; i++)dp[i][0] = 1;
    for(int i = 1; i <= n; i++)
        for(int j = 0; j <= n-i; j++)
        if(j == 0)dp[j][i] = dp[j+1][i-1];
        else dp[j][i] = dp[j-1][i] + dp[j+1][i-1];
}

int main()
{

	cin>>n;
	solve();
	cout<<dp[0][n];
    return 0;
}

多重背包

摆花

题意：小明的花店新开张，为了吸引顾客，他想在花店的门口摆上一排花，共 m 盆。通过调查顾客的喜好，小明列出了顾客最喜欢的 n 种花，从 1 到 n 标号。为了在门口展出更多种花，规定第 i 种花不能超过ai盆，摆花时同一种花放在一起，且不同种类的花需按标号的从小到大的顺序依次摆列。
试编程计算，一共有多少种不同的摆花方案。
代码：

#include <bits/stdc++.h>
#define eps 1e-15

using namespace std;
//n种类,m最大摆数量.dp表示摆到第i种，摆了j盆花的方案数.p表示摆i盆的方案数
int n,m,dp[105][105],a[105];
int p[105];
void solve(){
    /*for(int i=2; i<=n; i++){
        dp[i][0] = 1;
    for(int j=1; j<=m; j++)
        for(int k=a[i]>j?j:a[i]; k>=0; k--)
            dp[i][j] = (dp[i][j]%1000007+dp[i-1][j-k]%1000007)%1000007;

    }*/
    //因为每次循环只用到了前一次的方案状态,可以进行数组压缩
    for(int i=0; i<=a[1]; i++)
        p[i] = 1;
    for(int i=2; i<=n; i++)
        for(int j=m; j>=0; j--)
            for(int k=1; k<=min(a[i],j); k++)
            //每次多摆一盆，考到虑第i种花摆完，画一下表格好理解
                p[j] = (p[j] + p[j-k])%1000007;


}

int main()
{

	cin>>n>>m;
	for(int i=1;i<=n;i++)cin>>a[i];
	solve();
/*    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++)
        cout<<dp[i][j]<<" ";
    cout<<endl;
	}
	cout<<dp[n][m];*/
	cout<<p[m];
/*	for(int i=0; i<=m; i++){
        cout<<p[i]<<" ";
	}*/
    return 0;
}

分大理石

完全背包

疯狂的采药

题意：LiYuxiang 是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同种类的草药，采每一种都需要一些时间，每一种也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是 LiYuxiang，你能完成这个任务吗？

此题和原题的不同点：

  1. 每种草药可以无限制地疯狂采摘。

  2. 药的种类眼花缭乱，采药时间好长好长啊！师傅等得菊花都谢了！

输入：
输入第一行有两个整数，分别代表总共能够用来采药的时间 t 和代表山洞里的草药的种类 m。

第 2 到第 (m + 1) 行，每行两个整数，第(i+1) 行的整数 a_i, b_ia 分别表示采摘第 i 种草药的时间和该草药的价值。

#include <bits/stdc++.h>
#define eps 1e-15
using namespace std;
long long int v[10005],w[10005];
long long int dp[10000005];
//dp表示花费i时间的最大价值
void solve( long long int t,long long int m){
    for(int i= m; i >= 1; i--)
        for(int j = w[i]; j <= t; j++)
            {
                dp[j] = max(dp[j], dp[j-w[i]]+v[i]);
		//会用到此次循环产生的状态，简化了num，
        //状态转移方程 dp[j] = max(dp[j], dp[j-num*w[i]]+num*v[i]);
	   //相当于 dp[i][j] = max(dp[i+1][j], dp[i+1][j-w[i]] + v[i])
       //状态转移方程 max { dp[i+1][v−k×w[i]] + k × c[i] }  0≤k×w[i]≤v。
                }
    }
int main()
{
    long long int t,m;cin>>t>>m;
    for(int i=1;i<=m;i++)cin>>w[i]>>v[i];
    for(int i=0;i<=m+1;i++)
        dp[i]=0;
    solve(t,m);
	cout<<dp[t];
    return 0;
}

持续更新，如有不足，还请提出。

绿毛水怪12138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划总结.doc
12-12
鉴于算法分析与设计教科书中，关于动态规划算法章节的学习总结，分享至CSDN资源供广大读者学习交流，同专业学生可以作为复习参考资料。
koa-router源码学习小结
01-02
这里通过解析 koa-router 的源码来达到深入学习的目的. 源码架构图 调用链路-routes() HTTP请求调用流程 Usage const Koa = require('koa'); const Router = require('koa-router'); const app = new Koa(); ...
动态规划小结
skyline
06-30 1068
这两天做了几道dp，回顾一下. 1，http://acm.hdu.edu.cn/showproblem.php?pid=1024 dp[i][j]表示前j个数字包括j 选i段划分出的最大值 dp[i][j]=max(dp[i][j-1],max(dp[i-1][k]))+num[j]; 1 编程中可以用滚动数组实现dp数组，而用pre[k]来表示前一阶段前k个数字最大值（可以不包括k）
教你彻底学会动态规划——入门篇
热门推荐
常敲代码手不抖
08-11 38万+
动态规划相信大家都知道，动态规划算法也是新手在刚接触算法设计时很苦恼的问题，有时候觉得难以理解，但是真正理解之后，就会觉得动态规划其实并没有想象中那么难。网上也有很多关于讲解动态规划的文章，大多都是叙述概念，讲解原理，让人觉得晦涩难懂，即使一时间看懂了，发现当自己做题的时候又会觉得无所适从。我觉得，理解算法最重要的还是在于练习，只有通过自己练习，才可以更快地提升。话不多说，接下来，下面我就...
EXCEL学习小结.doc
11-23
EXCEL学习小结.doc
setTimeout学习小结
12-07
今天看了一篇文章，觉得写得不错，所以学习了一下，这篇博客是我自己的理解和总结 原文：你应该知道的 setTimeout 秘密 主要内容： 　1、setTimeout原理 　2、setTimeout(function(){..},0)的意义 　3、setTimeout的...
RMI使用学习 小结
10-30
RMI使用学习 小结
Vue.js样式动态绑定实现小结
01-21
在项目中，我们时常会遇到动态的去绑定操作切换不同的CSS样式，结合自身项目中遇到的一些情况，也参考了一些文档，针对vue.js样式的动态绑定切换做出如下小结： 动态切换的核心思想： 利用vue指令v-bind来实现动态...
动态规划总结
明朗晨光的专栏
04-02 1151
动态规划
12.算法思想-动态规划算法
爱欧米
12-22 204
动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复
动态规划算法总结
sjk12332134的博客
10-27 1113
动态规划的基本思想 动态规划算法的基本思想是将代求解的的问题分为若干子问题，先求解子问题，再利用子问题的解得到原问题的解，这就要求问题整体的解一定也是局部的最优解。若用分治法求解时，有些子问题被重复计算了多次，如果能够保存子问题的答案，在求规模更大的问题的解的时候可以再利用以求得的答案，就可以避免大量重复计算。动态规划的本质思想是利用子问题求解原问题。这样就衍生出了两种解决问题的方法，一种是自顶向下递归式解决问题，这种方法代码书写简单，往往写出状态转移方程问题就能解决。但缺点...
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 254
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 332
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 462
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 593
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
贪心动态规划算法实验小结
05-29
好的，我会为您总结一下贪心动态规划算法实验的小结。 在贪心算法方面，实验中我们学习了贪心算法的基本思想和应用场景，如找零钱问题、区间覆盖问题等。通过实际编程实现，我们加深了对贪心算法的理解和掌握。 在动态规划算法方面，实验中我们学习了动态规划算法的基本概念和原理，如最长上升子序列问题、背包问题等。通过实际编程实现，我们理解了动态规划算法的优缺点以及应用场景，加深了对动态规划算法的理解和掌握。 总的来说，通过这次实验，我们学习了贪心和动态规划两种算法，并通过编程实现加深了对这两种算法的理解和掌握。同时，我们也更加了解了算法设计与分析的方法和思路，为我们今后的学习和研究奠定了基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值