POJ 2127 DP(n^2)

题意：

最长公共上升子序列

思路：

以前都是写的n^3的，今天听说有n^2算法，就看了一下。其实就是n^3的优化

以前n^3的方程是：

dp[i][j]表示以a串的前i个数字且以b[j]结尾的的最大的LCIS的长度

转移是：

dp[i][j]=max(dp[i][j],dp[i-1][k]+1)    a[i]==b[j]&&b[k]<b[j]   1<=k<j

dp[i][j]=max(dp[i][j],dp[i-1][j])     a[i]!=b[j]

现在开始优化：

第一个方程是n^3的，i,j两层循环是肯定干不掉的，那我们就想办法干掉k的这层循环

可以观察发现循环i层的状态是由i-1层转移过来的，这样就暗示我们要优化循环顺序，i的循环在外部，j的循环在内部

这样我们才可以降低复杂度：

考虑以下不等式：

a[i]==b[j]>b[k]    ------>    a[i]>b[k]

（仔细想想上面的不等式能给你启发）

那么！这个东西可以再上一层循环中求出来！发现没有？

在进入内层循环时，就可以维护一个最大值ma；

当b[j]<a[i]时，ma=max(ma, dp[i-1][ j])

当出现b[j]==a[i]时，就可以直接取dp[i][j]=ma+1

（说白了，就是把k的循环用j充当了。）

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <string>
#include <iostream>

#define N 600

using namespace std;

int n,m,a[N],b[N],dp[N][N],pre[N][N],stk[N];

void go()
{
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    scanf("%d",&m);
    for(int j=1;j<=m;j++) scanf("%d",&b[j]);
    memset(dp,0,sizeof dp);
    dp[0][0]=0;
    for(int i=1,ma,last;i<=n;i++)
    {
        ma=0;last=0;
        for(int j=1;j<=m;j++)
        {
            if(a[i]==b[j])
            {
                dp[i][j]=ma+1;
                pre[i][j]=last;
            }
            else dp[i][j]=max(dp[i][j],dp[i-1][j]);
            if(b[j]<a[i]&&ma<dp[i-1][j])
            {
                ma=dp[i-1][j];
                last=j;
            }
        }
    }
    int ans=-1,x=n,y,p=0;
    for(int j=1;j<=n;j++)
        for(int i=1;i<=m;i++)
            if(ans<dp[j][i])
            {
                ans=dp[j][i];
                y=i;
            }
    printf("%d\n",ans);
    
    while(ans--)
    {
        stk[++p]=b[y];
        while(a[x]!=b[y]) x--;
        y=pre[x][y];
        x--;
    }
    for(int i=p;i>=1;i--) printf("%d ",stk[i]);
}

int main()
{
    while(scanf("%d",&n)!=EOF) go();
    return 0;
}