线性动态规划

随便想的

已于 2023-12-25 04:07:15 修改

阅读量395

点赞数 4

分类专栏：算法文章标签：动态规划算法

于 2023-12-25 04:06:10 首次发布

本文链接：https://blog.csdn.net/qq_55078860/article/details/135160618

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

定义

具有线性阶段划分的动态规划算法称为线性动态规划（简称线性DP）。若状态包含多个维度，则每个维度都是线性划分的阶段，也属于线性DP。

举例

若f(m)是第m级台阶的走法数目，第m级台阶可能是第m-1级台阶向上走1级，也可能是第m-2级台阶向上走2级，因此f(m)=f(m-1)+f(m-2)，本质是斐波那契数列。

算法实现

递归

int solve1(n){
    if(n<=3)
        return n-1;
    return solve1(n-1)+ solve1(n-2);                
}

记忆化递归（备忘录）

const int maxn=40;
int dp[maxn+1];
int solve2(n){
    if(dp[n]!=0)
        return dp[n];
    if(n<=3)
        dp[n]=n-1;
    else
        dp[n]=solve2(n-1)+solve2(n-2);
    return dp[n];
}
memset(dp,0,sizeof(dp));//清零dp数组

动态规划

const int maxn=40;
int dp[maxn+1];
int solve3(n){
    dp[1]=0;
    dp[2]=1;
    dp[3]=2;
    for(int i=4;i<=n;i++)
        dp[i]=dp[i-1]+dp[i-2];
    return dp[n];
}

动态规划，迭代（空间优化）

int solve4(int n){
    if(n<=3)
        return n-1;
    s1=1;
    s2=2;
    int sum=0;
    for(int i=4;i<=n;i++){
        sum=s1+s2;
        s1=s2;
        s2=sum;
    }
    return sum;
}

动态规划+打表

const int maxn=40;
int dp[maxn+1];
void solve5(){
    dp[1]=0;
    dp[2]=1;
    dp[3]=2;
    for(int i=4;i<=maxn;i++)
        dp[i]=dp[i-1]+dp[i-2];
}
solve5();
cout<<dpn[]>>endl;

练习

1.The Triangle

将数字三角形用数组存储后，题目中的沿左对角线或右对角线向下，变成了沿正下方或右对角线向下。

若dp[m][n]表示从第1行到第m行第n列位置的最大的和，第m行第n列位置可能是第m-1行第n-1列位置沿右对角线向下，可能是第m-1行第n列位置沿正下方向下，所以dp[m][n]=max(dp[m-1][n-1],dp[m-1][n])+arr[m][n]

#include<iostream>
using namespace std;
const int maxn=100;
int dp[maxn][maxn];
int arr[maxn][maxn];

int main()
{
    int n;
    cin>>n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i+1; j++) {
            cin>>arr[i][j];
            }
        }
    dp[0][0]=arr[0][0];//第1行只有1个元素，且上方无元素
    for(int i=1;i<n;i++){
        for(int j=0;j<i+1;j++){
            if(j==0)
                dp[i][0]=arr[i][0]+dp[i-1][0];//第1列元素只能由正上方的元素沿下加和
            else
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-1])+arr[i][j];//每行最后一个元素的arr[i-1,j]=0
        }
    }
    int t=0;//最大值是dp最后一行中的最大值
    for(int i=0;i<n;i++){
        if(dp[n-1][i]>t)
            t=dp[n-1][i];
    }
    cout<<t<<endl;
    return 0;
}

2.最长上升子序列

遍历整个数组，对每个元素再往前遍历，如果前面的元素（下标j）小于该元素，则dp[j]+1，遍历完选出最大值即以该元素为结尾的最长有序子序列长度。

#include<iostream>
#include <cstring>
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn=1000;
int dp[maxn];
int arr[maxn];

int main()
{
    int n;
    cin>>n;
    for (int i = 0; i < n; i++)
        cin>>arr[i];
    for(int i=0;i<n;i++)
        dp[i]=1;//最长上升子序列最小的长度为1（仅一个元素）
    for(int i=1;i<n;i++){
        for(int j=0;j<i;j++){
            if(arr[j]<arr[i]){
                if((dp[j]+1)>dp[i])
                    dp[i]=dp[j]+1;
            }
        }
    }
    int t=dp[0];
    for(int i=1;i<n;i++)
        if(t<dp[i])t=dp[i];
    cout<<t<<endl;
    return 0;
}

3.最长公共子序列

设T是X和Z的最长公共子序列，若X[m]==Z[k]，则T1...Tt-1是X1...Xm-1和Z1....Zk-1的最长公共子序列。当X[m]！=Z[k]时，若X[m]!=T[t]，则T是X1...Xm-1和Z的最长公共子序列；若Z[k]!=T[t]，则T是X和Z1....Zk-1的最长公共子序列。

若用dp[i][j]二维数组表示X1...Xi和Z1....Zj的最长公共子序列的长度，由此可得

$dp[i][j]=\left\{\begin{matrix} 0 & i==0||j==0& \\ dp[i-1][j-1]+1 & i,j>0and x[i]==z[j]& \\ max(dp[i-1][j],dp[i][j-1])& i,j>0andx[i]!=z[j]& \end{matrix}\right.$

#include<iostream>
#include<cstdio>
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
string x,y;
int m,n;

int main()
{
    while(cin>>x>>y){//因为输入没写循环错了很多次
        m=x.size();
        n=y.size();
        int dp[m+1][n+1];
        for(int i=0;i<=m;i++){
            for(int j=0;j<=n;j++){
                if(i==0||j==0)
                    dp[i][j]=0;
                else if(x[i-1]==y[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        cout<<dp[m][n]<<endl;
    }
    return 0;
}

4.最大连续字段和

用dp[i]表示以索引i为结尾的最大子序列和，若dp[i-1]>=0,dp[i]=dp[i-1]+arr[i]，否则dp[i]=arr[i]。最后遍历整个dp数组，看以哪个索引结尾的最大子序列和是最大的。

#include<iostream>
#include<cstdio>
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=1e5+5;
int n;
int arr[N],dp[N],index[N];

void solve(){
    dp[0]=arr[0];
    index[0]=0;
    for(int i=1;i<n;i++){
        if(dp[i-1]>=0){//如果dp[i-1]大于等于0，可以把前面的和与此时索引的值继续加起来
            dp[i]=dp[i-1]+arr[i];
            index[i]=index[i-1];//初始索引和前一位的初始索引一样
        }else{
            dp[i]=arr[i];//重新开始累和
            index[i]=i;//初始索引也从该索引开始
        }
    }
    int maxn=dp[0];
    int ind=0;
    for(int i=1;i<n;i++)
        if(maxn<dp[i]){
            maxn=dp[i];
            ind=i;
        }
    printf("%d %d %d\n",maxn,index[ind]+1,ind+1);
}


int main()
{
    int t;
    scanf("%d",&t);
    for (int i = 1; i <= t; i++){
        scanf("%d",&n);
        for(int j=0;j<n;j++)
            scanf("%d",&arr[j]);
        printf("Case %d:\n",i);
        solve();

    }
    return 0;
}

网上：当前i-1数组的子数组和<0时（即dp[i-1]<0），就更新开始下标为i是不对的，如果前i-1数组中包含了整个数组的最大子数组和，只是后边加了些负数导致<0；况且，假设能正确找到最大值的开始下标，如果整个数组有多个最大值，left会更新为最后一个最大值的开始下标。

我：用index数组保存每个和的开始下标，找到最大值，获得结束下标，从index数组中查询开始下标