线性DP详解

顾名思义，线性DP就是在一条线上进行DP，这里举一些典型的例子。

LIS问题（最长上升子序列问题）

题目

给定一个长度为N的序列A，求最长的数值单调递增的子序列的长度。

上升子序列B可表示为B={A_k1,A_k2,···,A_kp}，其中k₁<k₂<···<k_p。

解析

状态：F[i]表示以A[i]为结尾的最长上升子序列的长度，边界为f[0]=0。

状态转移方程：F[i]=max{F[j]+1}(0≤j<i,A[j]<A[i])。

答案显然为max{F[i]}(1≤i≤N)。

事实上，无论是上升、下降还是不上升等等此类问题，代码都是相似的，唯一的区别只是判断的符号更改罢了。

Code

#include <iostream>
using namespace std;
int n,a[],f[],maxn;
int main()
{
    f[]=;
    cin>>n;
    for(int i=;i<=n;i++)
    {
        cin>>a[i];
        for(int j=;j<n;j++)
            if(a[j]<a[i]) f[i]=max(f[i],f[j]+);
        maxn=max(maxn,f[i]);
    }
    cout<<maxn;
    return ;
}

LCS问题（最长公共子序列）

题目

给定两个长度分别为N、M的字符串A和B，求最长的既是A的子序列又是B的子序列的字符串的长度。

解析

状态：F[i][j]表示A的前i个字符与B的前j个字符中的最长公共子序列，边界为F[i][0]=F[0][j]=0。

状态转移方程：F[i][j]=max{F[i-1][j],F[i][j-1],F[i-1][j-1]+1(if A[i]=B[j])}。

答案为F[N][M]。

Code

#include <iostream>
using namespace std;
int n,m,f[][];
char a[],b[];
int main()
{
    cin>>n>>m;
    for(int i=;i<=n;i++)
    {
        cin>>a[i];
        f[i][]=;
    }
    for(int i=;i<=m;i++)
    {
        cin>>b[i];
        f[][i]=;
    }
    for(int i=;i<=n;i++)
        for(int j=;j<=m;j++)
        {
            f[i][j]=max(f[i-][j],f[i][j-]);
            if(a[i]==b[j]) f[i][j]=max(f[i][j],f[i-][j-]+);
        }
    cout<<f[n][m];
    return ;
}

数字三角形

题目

给定一个N行的三角矩阵A，其中第i行有i列，从左上角出发，每次可以向下方或向右下方走一步，最终到达底部。

求把经过的所有位置上的数加起来，和最大是多少。

解析

状态：F[i][j]表示走到第i行第j列，和最大是多少，边界为F[1][1]=A[1][1]。

状态转移方程：F[i][j]=A[i][j]+max{F[i-1][j],F[i-1][j-1](if j>1)}。

答案为max{F[N][j]}(1≤j≤N)。

Code

#include <iostream>
using namespace std;
int n,a[][],f[][],maxn;
int main()
{
    cin>>n;
    for(int i=;i<=n;i++)
        for(int j=;j<=i;j++) cin>>a[i][j];
    f[][]=a[][];
    for(int i=;i<=n;i++)
        for(int j=;j<=i;j++)
        {
            f[i][j]=a[i][j]+f[i-][j];
            if(j>) f[i][j]=max(f[i][j],a[i][j]+f[i-][j-]);
        }
    for(int i=;i<=n;i++) maxn=max(maxn,f[n][i]);
    cout<<maxn;
    return ;
}

例题一：合唱队形

题目

【题目描述】

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位同学的身高(厘米)。

【输出格式】

一个整数，最少需要几位同学出列。

【输入样例】

【输出样例】

【数据规模】

对于50％的数据，保证有n≤20；

对于全部的数据，保证有n≤100。

解析

最少出列，就是最多留下。

分析一下队形，其实质便是先上升再下降，不难联想到最长上升子序列与最长下降子序列。

定义状态F[i][0/1]，F[i][0]表示以第i个人为结尾的最长上升子序列，F[i][1]表示以第i个人为结尾的最长合唱队形，F数组初值都为1,。

所以前i个人的最长合唱队形为max(F[i][0],F[i][1])。

状态转移方程：

F[i][0]=max(F[i][0],F[j][0]+1(if T[i]>T[j]))；(T[i]如题所述，j<i)

F[i][1]=max(F[i][1],a[j][0],a[j][1]+1(if T[i]<T[j])；

最后的答案为n-max(F[i][0],F[i][1])。

Code

#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
using namespace std;
int n,t[],f[][],ans;
int main()
{
    cin>>n;
    for(int i=;i<=n;i++) cin>>t[i];
    for(int i=;i<=n;i++)
    {
        f[i][]=;
        for(int j=;j<i;j++)
            if(t[i]>t[j]) f[i][]=max(f[i][],f[j][]+);
    }
    for(int i=;i<=n;i++)
    {
        f[i][]=;
        for(int j=;j<i;j++)
            if(t[i]<t[j]) f[i][]=max(f[i][],max(f[j][],f[j][])+);
    }
    for(int i=;i<=n;i++) ans=max(ans,max(f[i][],f[i][]));
    cout<<n-ans;
    return ;
}

例题二：导弹拦截

题目

【题目描述】

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度，计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

【输入格式】

1行，若干个整数。

【输出格式】

2行，每行一个整数，第一个数字表示这套系统最多能拦截多少导弹，第二个数字表示如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

【输入样例】

【输出样例】

【数据规模】

导弹高度是≤50000的正整数，导弹个数≤100000。

注：O(n²) 100分，O(nlogn) 200分。

解析

非常经典的一道线性DP题目。

先来说说O(n²)的做法：

第一问显然是在求最长不上升子序列，定义状态F[i]表示以第i个数为结尾的最长不下降子序列。

状态转移方程：F[i]=max(F[i],F[j]+1(if a[i]<=a[j]))(a[i]表示第i个导弹的高度，j<i)。

第二问实际上是在求最长上升子序列，证明比较麻烦，这里便不给出了，自行理解一下。

与第一问求法相同，只需要把<=改成>即可。

这种做法只有100分，考虑一下优化。

---

以第一问为例，观察样例，不难发现，当F的值相同时，越后面的导弹高度越高。

所以我们可以用一个d[i]维护F值为i的序列的最后一个导弹的值，t记录当前求出的最长不上升子序列的长度，

然后在递推时判断a[d[i]](1≤i≤t)的值，若大于等于当前导弹高度，就更新F。

第二问同理。

优化之后，虽然依旧是O(n²)的做法，但其时间复杂度却很小，足以拿到200分。

---

O(nlogn)的做法有很多，例如二分、线段树什么的，这里便不再给出（懒），有兴趣的可以自己尝试做做。

Code

#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
using namespace std;
int a[],f[],n,maxn=-;
int main()
{
    while(scanf("%d",&a[++n])==) ;
    n--;
    for(int i=;i<=n;i++)
    {
        f[i]=;
        for(int j=;j<i;j++)
            if(a[i]<=a[j]) f[i]=max(f[i],f[j]+);
        maxn=max(maxn,f[i]);
    }
    printf("%d\n",maxn);
    maxn=-;
    for(int i=;i<=n;i++)
    {
        f[i]=;
        for(int j=;j<i;j++)
            if(a[i]>a[j]) f[i]=max(f[i],f[j]+);
        maxn=max(maxn,f[i]);
    }
    printf("%d",maxn);
    return ;
}

O(n^2) 100分做法

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
long long f[],a[],tot=,s=,d[],t=;
int main()
{
    memset(d,,sizeof(d));
    while(scanf("%lld",&a[++tot])==);
    tot--;
    for(int i=;i<=tot;i++)
    {
        f[i]=;
        for(int j=t;j>=;j--)
            if(a[i]<=a[d[j]])
                f[i]=max(f[i],f[d[j]]+);
         t=max(f[i],t);
        d[f[i]]=i;
    }
    cout<<t<<endl;
    t=;
    for(int i=;i<=tot;i++)
    {
        f[i]=;
        for(int j=t;j>=;j--)
            if(a[i]>a[d[j]])
                f[i]=max(f[i],f[d[j]]+);
         t=max(f[i],t);
        d[f[i]]=i;
    }
    cout<<t;
    return ;
}

O(n^2)优化 200分做法

注：参考书籍：《算法竞赛进阶指南》