codevs 2185 最长公共上升子序列

题目链接：

codevs 2185 最长公共上升子序列
codevs 1408 最长公共子序列

题目描述 Description
熊大妈的奶牛在小沐沐的熏陶下开始研究信息题目。
小沐沐先让奶牛研究了最长上升子序列，再让他们研究了最长公共子序列，
现在又让他们要研究最长公共上升子序列了。
小沐沐说，对于两个串A，B，如果它们都包含一段位置不一定连续的数字，且数字是严格递增的，
那么称这一段数字是两个串的公共上升子串，而所有的公共上升子串中最长的就是最长公共上升子串了。
奶牛半懂不懂，小沐沐要你来告诉奶牛什么是最长公共上升子串。不过，只要告诉奶牛它的长度就可以了。

输入描述 Input Description
第一行N，表示A，B的长度。
第二行，串A。
第三行，串B。

输出描述 Output Description
输出最长公共上升子序列的长度。

样例输入 Sample Input
4
2 2 1 3
2 1 2 3

样例输出 Sample Output
2

数据范围及提示 Data Size & Hint
1<=N<=3000，A，B中的数字不超过maxlongint

分类标签
动态规划

参考题解：
http://blog.csdn.net/wall_f/article/details/8279733
https://wenku.baidu.com/view/3e78f223aaea998fcc220ea0.html   下载该文档

分析：

定义状态

F[i][j]表示以a串的前i个整数与b串的前j个整数且以b[j]为结尾构成的LCIS的长度。

状态转移方程：

①F[i][j] = F[i-1][j]     (a[i] != b[j])

②F[i][j] = max(F[i-1][k]+1)     (1 <= k <= j-1 && b[j] > b[k])

现在我们来说为什么会是这样的状态转移方程呢？

对于①，因为F[i][j]是以b[j]为结尾的LCIS，如果F[i][j]>0那么就说明a[1]..a[i]中必然有一个整数a[k]等于b[j],因为a[k]!=a[i]，那么a[i]对F[i][j]没有贡献，于是我们不考虑它照样能得出F[i][j]的最优值。所以在a[i]!=b[j]的情况下必然有F[i][j]=F[i-1][j]。

对于②，前提是a[i] == b[j],我们需要去找一个最长的且能让b[j]接在其末尾的LCIS。之前最长的LCIS在哪呢？首先我们要去找的F数组的第一维必然是i-1。因为i已经拿去和b[j]配对去了，不能用了。并且也不能是i-2，因为i-1必然比i-2更优。第二维呢？那就需要枚举b[1]...b[j-1]了，因为你不知道这里面哪个最长且哪个小于b[j]。这里还有一个问题，可不可能不配对呢？也就是在a[i]==b[j]的情况下，需不需要考虑F[i][j]=F[i-1][j]的决策呢？答案是不需要。因为如果b[j]不和a[i]配对，那就是和之前的a[1]...a[j-1]配对（假设F[i-1][j]>0，等于0不考虑），这样必然没有和a[i]配对优越。（为什么必然呢？因为b[j]和a[i]配对之后的转移是max(F[i-1][k])+1，而和之前的i`配对则是max(F[i`-1][k])+1。

朴素的LCIS算法实现

以Hdu 1423 Greatest Common Increasing Subsequence为例。

预处理：

 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <algorithm>
 using namespace std;  

 const int MAXN = ;  

 int a[MAXN], b[MAXN];
 int f[MAXN][MAXN];
 int n, m;  

 void init()
 {
     memset(f, , sizeof(f));
 }  

核心代码：

 void dp()
 {
     init();
     int i, j, k;
     for(i = ; i <= n; i++)
     {
         for(j = ; j <= m; j++)
         {
             f[i][j] = f[i-][j]; // if(a[i] != b[j])
             if(a[i] == b[j])
             {
                 int MAX = ;
                 for(k = ; k <= j-; k++) if(b[j] > b[k]) //枚举最大的f[i-1][k]
                 {
                     MAX = max(MAX, f[i-][k]);
                 }
                 f[i][j] = MAX+;
             }
         }
     }
     int ans = ;
     for(int i = ; i <= m; i++) ans = max(ans, f[n][i]);
     printf("%d\n", ans);
 }  

从状态转移方程以及上述核心代码不难看到，这是一个时间复杂度为O(n^3)的DP，离平方还有一段距离。

但是，这个算法最关键的是，如果按照一个合理的递推顺序，max(F[i-1][k])的值我们可以在之前访问F[i][k]的时候通过维护更新一个max变量得到。怎么得到呢？首先递推的顺序必须是状态的第一维在外层循环，第二维在内层循环。也就是算好了F[1][len(b)]再去算F[2][1]。
如果按照这个递推顺序我们可以在每次外层循环的开始加上令一个max变量为0，然后开始内层循环。当a[i]>b[j]而且max<f[i-1][j]的时候令max=F[i-1][j]。如果循环到了a[i]==b[j]的时候，则令F[i][j]=max+1。
最后答案是F[len(a)][1]..F[len(a)][len(b)]的最大值。

********************************论述开始的分割线***************************

假如上面的论述不是太理解，可以参考下面的论述：（假如懂了请自行忽略。主要是“当a[i]>b[j]而且max<f[i-1][j]的时候令max=F[i-1][j]”这一句话的原理）

**********************************论述结束的分割线********************************

所以可以优化如下：

 #include<cstdio>
 #include<cstring>
 int f[][],a[],b[],i,j,t,n1,n2,max;
 int main()
 {
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n1,&n2);
         for(i=;i<=n1;i++) scanf("%d",&a[i]);
         for(i=;i<=n2;i++) scanf("%d",&b[i]);
         memset(f,,sizeof(f));
         for(i=;i<=n1;i++)
         {
             max=;
             for(j=;j<=n2;j++)
             {
                 f[i][j]=f[i-][j];
                 if (a[i]>b[j]&&max<f[i-][j])  max=f[i-][j];
                 if (a[i]==b[j])  f[i][j]=max+;
             }
         }
         max=;
         for(i=;i<=n2;i++)  if (max<f[n1][i]) max=f[n1][i];
         printf("%d\n",max);
     }
 }

至于本文题目codevs 2185的代码如下：

 #include <stdio.h>
 #define maxN 3003

 int n,a[maxN],b[maxN];
 int f[][maxN];

 int main(int argc, char *argv[])
 {
     int i,j;
     int cur,max;
     scanf("%d",&n);
     for(i=;i<n;i++) scanf("%d",&a[i]);
     for(i=;i<n;i++) scanf("%d",&b[i]);

     for(i=;i<;i++) f[i][]=;
     for(j=;j<=n;j++) f[][j]=;
     cur=;

     for(i=;i<=n;i++)
     {
         cur=cur^;
         max=;
         for(j=;j<=n;j++)
         {
             f[cur][j]=f[cur^][j];
             if(b[j]<a[i]&&f[cur^][j]>max) max=f[cur^][j];
             if(a[i]==b[j]) f[cur][j]=max+;
         }
     }
     max=;
     for(j=;j<=n;j++)
     {
         if(f[cur][j]>max) max=f[cur][j];
     }
     printf("%d\n",max);
     return ;
 }

可以发现，其实上面的代码有些地方与0/1背包很相似，即每次用到的只是上一层循环用到的值，即f[i-1][j]，那么我们可以像优化0/1背包问题利用滚动数组来优化空间。

核心代码：

 void dp()
 {
     init();
     for(int i = ; i <= n; i++)
     {
         int MAX = ;
         for(int j = ; j <= n; j++)
         {
             if(a[i] > b[j]) MAX = max(MAX, f[j]);
             if(a[i] == b[j]) f[j] = MAX+;
         }
     }
     int ans = ;
     for(int j = ; j <= m; j++) ans = max(ans, f[j]);
     printf("%d\n", ans);
 }  

如果是求最长公共下降子序列呢？很明显嘛，把状态定义改动一下，即f[i][j]表示以a串的前i个整数与b串的前j个整数且以b[j]为结尾构成的LCDS的长度，具体实现的时候只要把a[i] > b[j]改为a[i] < b[j]就可以啦。