动态规划：子序列问题

最长上升子序列问题

• 最长上升子序列问题（LIS问题），是指在一个给定长度为 $N$ 的序列 $A$ 中求出数值单调递增的子序列的长度最长为多少。

• 状态表示与划分：用 $F[i]$ 表示以 $A[i]$ 为结尾的最长上升子序列的长度，从后往前枚举子序列的结尾的位置。

• 边界：$F[0]=0$。

• 状态转移方程：
  F [ i ] = max ⁡ { F [ j ] + 1 }   ( j < i , A [ j ] < A [ i ] ) F[i] = \max\{F[j]+1\} \ (j<i,A[j]<A[i]) F[i]=max{F[j]+1} (j<i,A[j]<A[i])

• 答案： max ⁡ { f [ i ] }   ( 1 ≤ i ≤ N ) \max\{f[i] \} \ (1 \le i \le N) max{f[i]} (1≤i≤N)。

• 代码

  #include <bits/stdc++.h>
  #define M 1005000
  using namespace std;
  
  int n, ans=0;
  int a[M], f[M];
  
  inline int read()
  {
      int re=0, f=1; char ch=getchar();
      while(ch<'0' || ch>'9') {if(ch=='-') f=-1; ch=getchar();}
      while(ch>='0' && ch<='9') {re=re*10+(ch-'0'); ch=getchar();}
      return re*f;
  }
  
  int main()
  {
      n=read();
      for(int i=1;i<=n;++i) a[i]=read();
      f[0]=0;
      for(int i=1;i<=n;++i)
      {
          for(int j=0;j<i;++j)
          {
              if(a[i]>a[j]) f[i]=max(f[i],f[j]+1);
          }
      }
      for(int i=0;i<=n;++i) ans=max(ans,f[i]);
      printf("%d\n",ans);
  }
  

最长公共子序列问题

• 最长公共子序列问题（LCS），是指给定两个长度分别为 $N$ 和 $M$ 的字符串 $A$ 和 $B$，求既是 $A$ 的子序列又是 $B$ 的子序列的串的长度最长为多少。

• 状态表示与转移：用 $F[i][j]$ 表示前缀子串 $A[1...i]$ 和 $B[1...j]$ 的LCS的长度。

• 边界：$F[i][0]=F[0][j]=0$。

• 状态转移方程：
  $$F[i][j]=\max \{\begin{array}{l}F[i-1][j]\\ F[i][j-1]\\ F[i-1][j-1]+1(A[i]=B[j])\end{array}$$

• 答案：$F[N][M]$。

• 代码：

  #include <bits/stdc++.h>
  #define M 5000
  using namespace std;
  
  int n, m, ans=0;
  int f[M][M], a[M+10], b[M+10];
  
  inline int read()
  {
      int re=0, f=1; char ch=getchar();
      while(ch<'0' || ch>'9') {if(ch=='-') f=-1; ch=getchar();}
      while(ch>='0' && ch<='9') {re=re*10+(ch-'0'); ch=getchar();}
      return re*f;
  }
  
  int main()
  {
      n=read();
      for(int i=1;i<=n;++i) a[i]=read(), f[i][0]=0;
      for(int i=1;i<=n;++i) b[i]=read(), f[0][i]=0;
      for(int i=1;i<=n;++i)
      {
          for(int j=1;j<=n;++j)
          {
              f[i][j]=max(f[i][j],max(f[i-1][j],f[i][j-1]));
              if(a[i]==b[j]) f[i][j]=max(f[i][j],f[i-1][j-1]+1);
          }
      }
      printf("%d\n",f[n][n]);
      return 0;
  }
  

最长公共上升子序列问题

• 结合上面两个问题，很容易想到上面两个问题。这样我们想到了一个 $n^3$ 的算法。

  当 $A[i]\ne B[j]$ 时，$F[i][j]=F[i-1][j]$；

  当 $A[i]=B[j]$ 时， F [ i ] [ j ] = max ⁡ { F [ i − 1 ] [ k ] + 1 } ( 0 ≤ k < j , B [ k ] < B [ j ] ) F[i][j] = \max\{F[i-1][k]+1 \}(0 \le k <j,B[k]<B[j]) F[i][j]=max{F[i−1][k]+1}(0≤k<j,B[k]<B[j])

  $\therefore$ 当 $A[i]=B[j]$ 时，   F [ i ] [ j ] = max ⁡ { F [ i − 1 ] [ k ] + 1 } ( 0 ≤ k < j , B [ k ] < A [ i ] ) \ F[i][j] = \max\{F[i-1][k]+1 \}(0 \le k < j,B[k]<A[i])  F[i][j]=max{F[i−1][k]+1}(0≤k<j,B[k]<A[i])

• 但是，这个算法最关键的是，如果按照一个合理的递推顺序， max ⁡ { F [ i − 1 ] [ k ] } \max\{F[i-1][k] \} max{F[i−1][k]} 的值我们可以在之前访问 $F[i][k]$ 的时候通过维护更新一个 $val$ 变量得到。怎么得到呢？首先递推的顺序必须是状态的第一维在外层循环，第二维在内层循环。也就是算好了 $F[1][len(b)]$ 再去算 $F[2][1]$。

  如果按照这个递推顺序我们可以在每次外层循环的开始加上令一个 $val$ 变量为 $0$，然后开始内层循环。当 $a[i]>b[j]$ 的时候令 $val=F[i-1][j]$。如果循环到了 $a[i]=b[j]$ 的时候，则令 $F[i][j]=val+1$。

  最后答案是 $F[len(a)][1]..F[len(a)][len(b)]$ 的最大值。

• $n^2$ 代码

  #include <bits/stdc++.h>
  using namespace std;
  const int N = 3005;
  int n;
  int main() {
    cin >> n;
    int dp[n + 1][n + 1], a[n + 1], b[n + 1];
    memset(dp, 0, sizeof(dp));
   
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
    for (int i = 1; i <= n; i++) {
      int v = 0;
      for (int j = 1; j <= n; j++) {
        if (dp[i - 1][j] > v && a[i] > b[j]) v = dp[i - 1][j];
        if (a[i] == b[j])
          dp[i][j] = v + 1;
        else {
          dp[i][j] = dp[i - 1][j];
        }
      }
    }
    int ans=0;
    for(int j=1;j<=n;j++)
    ans=max(dp[n][j],ans);
    cout << ans<< endl;
  }