动态规划

最新推荐文章于 2021-06-28 17:39:58 发布
最新推荐文章于 2021-06-28 17:39:58 发布
阅读量281 收藏
点赞数 1
分类专栏： 算法竞赛知识点整理
HUIKI
本文链接：https://blog.csdn.net/Nismilesucc/article/details/106238683
版权

date: 2019-07-01 11:18:40

动态规划

核心在于状态的表示和状态的转移

在这里插入图片描述

1. 背包问题

2.线性dp

例1：数字三角形

在这里插入图片描述

输入
5
7
3 8
8 1 0 
2 7 4 4
4 5 2 6 5
输出
30
思路

在这里插入图片描述

dp的时间复杂度计算一般是状态数*转移的计算次数

本题状态数n2，转移计算量O(1)，所以总时间复杂度为O(n2)

注意：三角形中的整数可以为负数，所以初始化的时候要负得足够多

从下往上  把(1,1)当成唯一终点
#include <iostream>
using namespace std;
const int maxn=505;
const int INF=1e8;
int dp[maxn][maxn],a[maxn][maxn];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            cin>>a[i][j];
           
    for(int i=n;i>=1;i--)
        for(int j=i;j>=1;j--)
            dp[i][j]=max(dp[i+1][j]+a[i][j],dp[i+1][j+1]+a[i][j]);
            
    cout<<dp[1][1]<<endl;
    return 0;
}
从上往下  需要遍历最底层所有终点
#include <iostream>
using namespace std;
const int maxn=505;
const int INF=1e8;
int dp[maxn][maxn],a[maxn][maxn];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            cin>>a[i][j];
    for(int i=0;i<=n;i++)//注意初始化要从0开始，因为dp[i-1]
        for(int j=0;j<=i+1;j++)
            dp[i][j]=-INF;
            
    dp[1][1]=a[1][1];
    for(int i=2;i<=n;i++)
        for(int j=1;j<=i;j++)
            dp[i][j]=max(dp[i-1][j-1]+a[i][j],dp[i-1][j]+a[i][j]);
            
    int ans=-INF;
    for(int i=1;i<=n;i++)
        ans=max(ans,dp[n][i]);
    cout<<ans<<endl;
    return 0;
}
WA代码：没有注意到数据范围可为负，如果输入的为负数，那么初始化为全0就会导致问题
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            dp[i][j]=max(dp[i-1][j-1]+a[i][j],dp[i-1][j]+a[i][j]);
}
例2：最长上升子序列

在这里插入图片描述

n个状态，转移时要枚举n，所以时间复杂度为O(n2)
在这里插入图片描述

#include <iostream>
using namespace std;
const int maxn=1e3+5;
int dp[maxn];
int a[maxn];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
        
    for(int i=1;i<=n;i++)
    {
        dp[i]=1;//初始化，最开始时只有自己
        for(int j=1;j<=i;j++)
            if(a[j]<a[i])
                dp[i]=max(dp[i],dp[j]+1);
    }
    int ans=0;
    for(int i=1;i<=n;i++)
        ans=max(ans,dp[i]);
    cout<<ans<<endl;
    return 0;
}
记录最长上升子序列
#include <iostream>
using namespace std;
const int maxn=1e3+5;
int dp[maxn];
int a[maxn],pre[maxn];//ind用来记录转移的路径
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
        
    for(int i=1;i<=n;i++)
    {
        dp[i]=1;//初始化，最开始时只有自己
        pre[i]=0;
        for(int j=1;j<=i;j++)
            if(a[j]<a[i])
            {
                if(dp[i]<dp[j]+1)
                {
                    dp[i]=dp[j]+1;
                    pre[i]=j;//记录每一次从哪里转移而来
                }
            }
    }
    int k=1;
    for(int i=1;i<=n;i++)
        if(dp[i]>dp[k])
            k=i;
    cout<<dp[k]<<endl;//找到最大值
    
    int len=dp[k];
    int s[maxn];
    for(int i=0;i<len;i++)
    {
        s[i]=a[k];
        //cout<<a[k]<<" ";//倒序输出
        k=pre[k];//它由谁转移而来
    }
    for(int i=len-1;i>=0;i--)
    cout<<s[i]<<" ";
    cout<<endl;
    return 0;
}
二分加速

如果数据量变成了1≤n≤100000，O(n2) 就变成1010接受不了了
在这里插入图片描述

O(nlogn)

#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int mod=1e9+7;
int a[maxn],y[maxn];//y里存储末尾最小的数
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    cin>>a[i];

    int len=0;//存储最长上升子序列长度
    y[0]=-2e9;
    for(int i=0;i<n;i++)//遍历每一个数
    {
        int l=0,r=len;
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(y[mid]<a[i])
                l=mid;
            else
                r=mid-1;
        }
        //r找的是第1个<a[i]的y的下标，即a[i]可以接在该数后面
        len=max(len,r+1);//更新最大长度
        y[r+1]=a[i];//原来的y[r+1]≥a[i]
    }
    cout<<len<<endl;
    return 0;
}
也可以模拟栈
#include <iostream>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int mod=1e9+7;
int a[maxn],y[maxn];//y里存储末尾最小的数
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    cin>>a[i];

    vector<int>st;
    st.push_back(a[0]);//模拟栈
    for(int i=1;i<n;i++)
    {
        if(a[i]>st.back())
            st.push_back(a[i]);
        else//这个数≤栈顶，就替换掉栈里第一个大于或者等于a[i]的那个数
        {
            vector<int>::iterator it=lower_bound(st.begin(),st.end(),a[i]);
            (*it)=a[i];
        }
    }
    cout<<st.size()<<endl;
    return 0;
}
例3：最长公共子序列

在这里插入图片描述
小集合的最大值≤大集合的最大值，所以01的最大值≤dp[i-1][j],10同理，所以dp[i-1][j]和dp[i][j-1]就可以覆盖掉01和10两部分最大值

虽然dp[i-1,j]的最大值不一定是01这种情况，但对答案是没影响的，因为dp[i-1,j]中的方案一定是f[i,j]中的方案。

#include <iostream>
#include <string>
const int maxn=1e3+5;
using namespace std;
int dp[maxn][maxn];
int main()
{
    int n,m;
    cin>>n>>m;
    char s[maxn],t[maxn];
    cin>>s+1;//如果s声明成string类就不能直接s+1
    cin>>t+1;
    for(int i=1;i<=n;i++)//如果从0开始，会导致数组越界到-1
        for(int j=1;j<=m;j++)
        {   
            dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            if(s[i]==t[j])
                dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);//相当于三部分取max       
        }
    cout<<dp[n][m]<<endl;
    return 0;
}
例4：最短编辑距离

在这里插入图片描述

输入
10 
AGTCTGACGC
11 
AGTAAGTAGGC
输出
4
题解

在这里插入图片描述

#include <iostream>
using namespace std;
const int maxn=1e3+5;
char a[maxn],b[maxn];
int dp[maxn][maxn];
int main()
{
    int n,m;
    scanf("%d",&n);
    scanf("%s",a+1);
    scanf("%d",&m);
    scanf("%s",b+1);
    
    for(int i=0;i<=n;i++)//一定要注意边界情况
        dp[i][0]=i;
    for(int j=0;j<=m;j++)
        dp[0][j]=j;

    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
            if(a[i]==b[j])
            dp[i][j]=min(dp[i][j],dp[i-1][j-1]);
            else
            dp[i][j]=min(dp[i][j],dp[i-1][j-1]+1);
        }
    printf("%d\n",dp[n][m]);
    return 0;
}
例4变形：编辑距离

在这里插入图片描述

输入
3 2
abc
acd
bcd
ab 1
acbd 2
输出
1
3
题解

基本同上。

#include <iostream>
#include <cstring>
using namespace std;
int maxn=15;
char str[1005][15];
int compute(char a[],char b[])
{
    int dp[maxn][maxn];
    int n,m;
    n=strlen(a+1),m=strlen(b+1);
    for(int i=0;i<=n;i++)//一定要注意边界情况
        dp[i][0]=i;
    for(int j=0;j<=m;j++)
        dp[0][j]=j;

    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
            if(a[i]==b[j])
            dp[i][j]=min(dp[i][j],dp[i-1][j-1]);
            else
            dp[i][j]=min(dp[i][j],dp[i-1][j-1]+1);
        }
    return dp[n][m];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)
    scanf("%s",str[i]+1);
    while(m--)
    {
        char s[maxn];
        int up;
        scanf("%s%d",s+1,&up);
        int ans=0;
        for(int i=0;i<n;i++)
            if(compute(s,str[i])<=up)
                ans++;
        printf("%d\n",ans);
    }
    return 0;
}

3.区间dp

区间dp一般会从小到大枚举区间大小,再循环枚举区间的左端点，再枚举决策
例题 合并相邻石子堆

在这里插入图片描述

输入
4
1 3 5 2
输出
22
思路

在这里插入图片描述

状态数量n2，状态计算只需要枚举k，计算量为n，所以总时间复杂度为O(n3)

#include <iostream>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=305;
const int mod=1e9+7;
int s[maxn],dp[maxn][maxn];//y里存储末尾最小的数
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>s[i];
    for(int i=1;i<=n;i++)
        s[i]+=s[i-1];//求前缀和
        //区间为1，合并不需要代价，所以可以从2开始
    for(int num=2;num<=n;num++)//枚举区间长度，即所需合并石子总堆数
        for(int i=1;i+num-1<=n;i++)//枚举起点
        {
            int l=i,r=i+num-1;
            dp[l][r]=1e8;//一定要注意这里的初始化
            for(int k=l;k<r;k++)//枚举分界点
                dp[l][r]=min(dp[l][r],dp[l][k]+dp[k+1][r]+s[r]-s[l-1]);
        }
    cout<<dp[1][n]<<endl;
    return 0;
}

因为要保证要求的区间内的所有状态都已经被求好，所以枚举区间大小

4.计数类dp

整数划分问题

在这里插入图片描述

输入
5
输出
7
思路1：背包写法

容量为n的背包，物品体积分别为1，2，…，n，求恰好装满背包的方案数。每个物品可以用无限次，所以是完全背包问题。
在这里插入图片描述

#include <iostream>
using namespace std;
const int maxn=1e3+5;
const int mod=1e9+7;
int dp[maxn];
int main()
{
    int n;
    cin>>n;
    dp[0]=1;//一定要注意这个初始化情况
    for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++)//
            dp[j]=(dp[j]+dp[j-i])%mod;
    
    cout<<dp[n]<<endl;
    
    return 0;
}
思路2：

在这里插入图片描述

#include <iostream>
using namespace std;
const int maxn=1e3+5;
const int mod=1e9+7;
int dp[maxn][maxn];
int main()
{
    int n;
    cin>>n;
    dp[0][0]=1;//一定要注意这个初始化情况
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            dp[i][j]=(dp[i-1][j-1]+dp[i-j][j])%mod;
    
    int  ans=0;
    for(int i=1;i<=n;i++)
        ans=(ans+dp[n][i])%mod;//注意取模
        
    cout<<ans<<endl;
    
    return 0;
}
动态规划动态规划.zip
10-25
动态规划（Dynamic Programming，简称DP）是解决复杂问题的有效算法设计方法，尤其在计算机科学和IT领域中占有重要地位。它通过将一个大问题分解为若干个子问题，并利用子问题的解来构建原问题的解，从而避免了重复...
动态规划解决TSP问题用动态规划算法求解TSP，数据为Solomon数据集的c101文件读取，可视化路径图，用图展示每次迭代的最
最新发布
10-22
动态规划是一种解决问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，它的目标是找到一个城市的最短可能路线，使得...
1224：最大子矩阵 2020-12-02
lybc2019的博客
12-02 629
1224：最大子矩阵 时间限制: 1000 ms 内存限制: 65536 KB【题目描述】 已知矩阵的大小定义为矩阵中所有元素的和。给定一个矩阵，你的任务是找到最大的非空(大小至少是1×1)子矩阵。 比如，如下4×4的矩阵 0 −2 −7 0 9 2 −6 2 −4 1 −4 1 −1 8 0 −2 的最大子矩阵是 9 2 −4 −1 1 8 这个子矩阵的大小是15。【输入】 输入是一个N×N的矩阵。输入的第一行给出N(0<N≤100)。再后面的若干行中，依次(首先从左到右给出第一行的...
[PTA] 数据结构与算法题目集 6-8 求二叉树高度 & 6-9 二叉树的遍历
Rh's blog
11-18 294
6.8 二叉树高度 int GetHeight(BinTree BT) { if (BT == NULL) return 0; int leftH = GetHeight(BT->Left); int rightH = GetHeight(BT->Right); if (leftH > rightH) r...
最短路--五种表示方法
hnlg311709000526的博客
06-28 263
至于什么是最短路，就不再赘述了，直接上算法 1.Bellman-Ford 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 /* Bellman-Ford算法： 1.单源最短路 2.不存在负圈，更新操作有限 3.如果存在从s可达的负圈，那么在第n次循环中也会 更新d的值 *...
每天学一丢之 IDDFS （5.28）
ShadowGhostH的博客
05-28 1193
每天学一丢意为每天学一点丢一点。然后每天二字名存实亡，还是坚持在每天学习，只是每天学习的东西不够单开一文去总结。这段时间在准备各种比赛，所以题解没有跟上，还不好说会不会补训练赛的题解。IDDFS（iterative deepening deep-first-search）迭代 加深 搜索首先第一点我们知道，在迷宫问题计算最短路的时候，我们经常使用BFS 这样做的好处是：第一次搜索到目标点时，就是到...
UVA - 11853 Paintball
weixin_30294021的博客
10-07 110
/* 这题的思路让我觉得很巧妙，所以...虽然小白书 P175 ，已经有详细到能看懂的解释了，但我还是用自己的话，把书上的解析复述一遍: 简化： 先判断解的存在性，有解再找解 类比： 可将敌人类比为圆，攻击范围则为一个个以敌人位置为圆心，攻击距离为半径的圆 可将战场看成湖，敌人的攻击范围组成的圆，看作一个个圆形踏脚石，...
代码 随机动态规划的实例的matlab代码
06-04
代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的...
会议安排（贪心算法和动态规划） 贪心算法和动态规划.pdf
04-08
会议安排（贪心算法和动态规划） 会议安排问题是计算机科学中的一种经典问题，目的是在一系列活动中选择尽可能多的活动，使得每个活动的结束时间不早于下一个活动的开始时间。这个问题可以使用贪心算法和动态规划两...
贪心算法、分治算法和动态规划的区别 贪心算法和动态规划.pdf
04-08
贪心算法、分治算法和动态规划的区别 贪心算法、分治算法和动态规划是三种常用的算法设计策略，每种算法都有其特点和应用场景。下面我们将对这三种算法进行详细的比较和分析。 分治算法 分治算法是一种将原问题...
acm专题学习之单调栈（一）单调栈入门+Max answer
qq_40306845的博客
04-23 403
单调栈： 定义：栈里面保持一种单调性 举例： 栈里面的元素为1，2，5，6（6是栈顶） 插入一个元素7 7大于栈顶元素6，可以直接入栈，此时栈为1，2，5，6，7 插入一个元素4 4小于栈顶元素7，7出栈，栈为1，2，5，6 4小于栈顶元素6，6出栈，栈为1，2，5 4小于栈顶元素5，5出栈，栈为1，2 4大于栈顶元素2，可以直接入栈，此时栈为1，2，4 遇到比栈顶元素大的就直...
c语言1e3和1e3,C语言(2012-2013-1-班用)-5.ppt
weixin_31227315的博客
05-20 1199
C语言(2012-2013-1-班用)-53.4 浮点型数据 3.4.1 浮点型常量的表示方法 (1)十进制小数形式，由数字和小数点组成。 例如：0.123、123、123.0、0.0 (2)指数形式， 如123e3、123E3 规范化的指数形式： 在字母e(或E)之前的小数部分中，小数点左边应有一位(且只能有一位)非零的数字. 例如: 123.456可以表示为： 123.456e0...
ACM寒假集训第二天：背包九讲
The student way
01-17 260
背包：01背包优化、完全背包、多重背包 01背包（ZeroOnePack）: 有total件物品和一个容量为weight的背包。（每种物品均只有一件）第i件物品的费用是w[i]，价值是v[i]。求解将哪些物品装入背包可使价值总和最大。 完全背包(CompletePack): 有total种物品和一个容量为weight的背包，每种物品都有无限件可用。第i种物品的费用是w[i]，价值是v[i]。...
【动态规划1】动态规划的引入 练习笔记
Chuancey的博客
03-10 352
【动态规划1】动态规划的引入 题目链接：https://www.luogu.com.cn/training/211#problems T1 数字三角形 Number Triangles 题目描述 观察下面的数字金字塔。 写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 在上面的样例中,从 7 -
const 详解
本是后山人
08-11 2355
1、定义const常量  如：const int Max = 100;
最短路相关算法
Nismilesucc的学习札记
08-04 468
最短路问题难点在于建图，如何把原问题抽象成最短路问题，如何定义点和边 1.朴素版Dijkstra算法
7-11 装箱问题（20 分）
酱菜小可爱的博客
08-27 2396
7-11 装箱问题（20 分） 假设有N项物品，大小分别为s​1​​、s​2​​、…、s​i​​、…、s​N​​，其中s​i​​为满足1≤s​i​​≤100的整数。要把这些物品装入到容量为100的一批箱子（序号1-N）中。装箱方法是：对每项物品, 顺序扫描箱子，把该物品放入足以能够容下它的第一个箱子中。请写一个程序模拟这种装箱过程，并输出每个物品所在的箱子序号，以及放置全部物品所需的箱子数目。 ...
二次剩余
Nismilesucc的学习札记
04-29 3152
title: 二次剩余 date: 2019-08-27 00:10:46 tags: 数论 一、定义（Quadratic_residue） 一个整数X对另一个整数p的二次剩余 d 注意这边的取模是 X2X^2X2 和 d 都要对p取模噢 eg. 32≡2(mod 7)3^2≡2 (mod\ 7)32≡2(mod 7),我们称 2是7的二次剩余 当存在某个 X2≡d&nbsp...
关于 __int128
Nismilesucc的学习札记
04-28 3010
关于 __int128 众所周知: int是32位，范围大概为10^9 long long(g++编译器）， __int64（用%I64d控制，用scanf,printf比较好），都是64位扩展,范围大概是10^19 关于两种扩展的区别，参照:https://blog.csdn.net/qq_31736627/article/details/52912691 __int128是128位，大概10^...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值