HDU 4512 最长公共上升子序列

各种序列复习：

（1）最长上升子序列。

1、这个问题用动态规划就很好解决了，设dp[i]是以第i个数字结尾的上升子序列的最长长度。那么方程可以是dp[i]=max(dp[j]+1)。（j<i）。复杂度为O(n^2);

2、另外有一个该经典问题的O(nlogn)算法。

　　首先知道，当求dp[i]时，如果出现a[k]<a[j],而dp[k]=dp[j]时，应当优先选k吧。那么，既然每次选的都是较小，就可以把字符串按照dp[t]=k这个子序列长度分类。当同样dp[t]=k时，记录下该长度的最小的a[p]，设为数组d[k]。注意到d数组是单调不减的。为什么呢？因为假设当前是长度p，记录的位置就为d[p]，如果出现d[q]>d[p]，q<p，干脆就让以d[p]结尾的子序代替前面的。

　　于是有这个特点：

　　A、d[1]<=d[2]<=.......

　　那么，在每次更新dp[i]时，对于字符a[i]，只需找出比它小的最大的k，使d[k]<a[i]，不就可以了吗。然后更新dp[i]。对于查找，由于单调，很明显可以使用二分查找。

　　对于一个比较巧妙的写法。

　　

#include <iostream>  
#include <cstdio>  
#include <cstring>  
using namespace std;  
const int N = 41000;  
int a[N];       //a[i] 原始数据  
int d[N];       //d[i] 长度为i的递增子序列的最小值  
  
int BinSearch(int key, int* d, int low, int high)  
{  
    while(low<=high)  
    {  
        int mid = (low+high)>>1;  
        if(key>d[mid] && key<=d[mid+1])  
            return mid;  
        else if(key>d[mid])  
            low = mid+1;  
        else  
            high = mid-1;  
    }  
    return 0;  
}  
  
int LIS(int* a, int n, int* d)  
{  
    int i,j;  
    d[1] = a[1];  
    int len = 1;        //递增子序列长度  
    for(i = 2; i <= n; i++)  
    {  
        if(d[len]<a[i])  
            j = ++len;  
        else  
            j = BinSearch(a[i],d,1,len) + 1;  
        d[j] = a[i];  
    }  
    return len;  
}  
  
int main()  
{  
    int t;  
    int p;  
    scanf("%d",&t);  
    while(t--)  
    {  
        scanf("%d",&p);  
        for(int i = 1; i <= p; i++)  
            scanf("%d",&a[i]);  
        printf("%d
",LIS(a,p,d));  
    }  
    return 0;  
} 

(2)最长公共子序列。

  设dp[i][j]是第一个字符串以第i个结尾，第二个字符串以第j个结尾的长度。

　　那么就有dp[i][j]=max{dp[i-1][j],dp[i][j-1],dp[i-1][j-1]}。前两种情况针对a[i]!=a[j]的，后一种是针对相等的。

(3)最长公共上升子序列。

我介绍一种O(N(M^2))的算法，它将是我们向O(NM)进步的阶梯。我们设F[j]为必选择B[j]为末尾时的最长。。。子序列（懒得打），那么F[j] = Max{F[k]}+1，并且通过设置一个i变量来枚举A[i]。

var
    f       : array[0..5000] of integer;
    ans     : integer;
procedure work2();
var
    i,j,k:integer;
begin
    for i:= 1 to n do
        for j:= 1 to m do
            if a[i] = b[j] then
                for k:= 0 to j-1 do
                    if b[k] < b[j] then
                        if f[j] < f[k]+1 then
                            f[j]:=f[k]+1;
    for i:= 1 to m do
        if ans < f[i] then
            ans:=f[i];
end;

此时我们把空间降到了一维。解释一下，k循环下面比较时，B[k]所对应的A[?]一定在A[i]以前，而k也小于j，这就保证了解的合法性。但注意到其中的k循环，这实际上是用来找最大值用的。那么我们想，为什么不把最大只保存起来呢？i循环没结束时不断更新这个k值就行了啊。那么下面的算法就出来了：

procedure work;
var
    i,j,k:integer;
begin
    for i:= 1 to n do
        begin
            k:=0;
            for j:= 1 to m do
                begin
                    if a[i] = b[j] then
                        if f[j] < f[k]+1 then
                            f[j]:=f[k]+1;
                    if a[i] > b[j] then
                        if f[k] < f[j] then
                            k:=j;                  // 更新新的k
                end;
        end;
    for i:= 1 to m do
        if ans < f[i] then
            ans:=f[i];
end; 

其实，对于上面的更新保存最大值的操作，为什么是可行的呢？

要知道，更新DP数组f是在a[i]==b[j]时才进行的，因为f数组定义的是以b[j]为结尾的最长序列。那么，由于是上升的，则必定是在结尾的字符之前b[k]<a[i]吧？那么，在扫描的过程中，就可以当满足

f[k] < f[j]时更新k了。


 对于HDU 4512这道题，也就是最长公共上升子序列的模型。我以两个序列来模拟，一个顺序一个逆序。在代码中可以知道，对于以b[j]为结束序列，在最外层循环到i时，内层循环最多只能到n-i+1，为什么呢？因为两个序列是互逆的，当超出这个值时，它们之前的序列就可能交叉或重叠。当a[n-i+1]==b[j]&&n-不+1==j时，序列最长应该是奇数的。在求解过程中找出最长序列即可。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

int num1[210],num2[210];
int f[210];

int main(){
    int T,n;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d",&num1[i]);
            num2[n-i+1]=num1[i];
        }
        memset(f,0,sizeof(f));
        int ans=1;
        for(int i=1;i<=n;i++){
            int k=0;
            for(int j=1;j<=n-i+1;j++){
                if(num2[i]==num1[j]){
                    if(f[j] < f[k]+1)
                    f[j]=f[k]+1;
                    if(j==n-i+1)
                    ans=max(ans,2*f[j]-1);
                    else {
                        ans=max(ans,2*f[j]);
                    }
                }
                if(num2[i]>num1[j]){
                    if(f[k]<f[j])
                    k=j;
                }
            }
        }
        printf("%d
",ans);
    }
    return 0;
}