LIS LCS LCIS （主要过一遍，重在做题）

只详细讲解LCS和LCIS，别的不讲…做题优先。

先得理解最长上升子序列吧，那个HDOJ拦截导弹系列可以做一下，然后用O(nlog(n))的在做一遍

然后就是真正理解LCS；

真正理解源于做题，做题就像查漏补缺一样，你总有不会的地方。

【完全的求一个最长公共子序列】
(非常彻底地理解路径或者说是状态转移的规律)
先是初始化
付一个0的dp数组，把dp作为一个介体达到一种最长公共子序列的目的
然后就开始更新dp的值，dp的状态转移方程OK，然后根据状态转移方程，
可以很清楚地知道，路径的变化就是状态转移变化的方向。【这样就可以实现路径的初始模型】

【详细阐述路径】
就是标记啊，因为LCS问题上面，状态转移只有三种，向下，向右，还有右下，然后就是搞三个标记，在竖直方向上移动的话就是-1，在水平方向上移动的话就是1，然后如果满足了相等，要斜对角移动的话就是0，然后递归进行输出。
【反着的一个题目(拓展)】

另一个问题就是给你两个序列，再给你一个序列，然后问你前面两个序列能否组成被给的第三个序列。

DP求解：定义dp[i][j]表示A中前i个字符与B中前j个字符是否能组成C中的前 (i+j) 个字符，如果能标记true，如果不能标记false；
满足什么状态可以转变成什么状态；

【小优化】
用个滚动数组；减少内存；

【彻底理解的LCS的应用】

Hdoj3779，hdoj1501，poj2192，poj2250，poj1159

【补】

【LIS的nlog(n)】

int a[1010];
int d[1010];

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        d[1]=a[1];
        int len=1;
        int j;
        /*
        严格单调递增子序列就是lower_bound（）；非严格单调子序列就是upper_bound();
        */
        for(int i=2;i<=n;i++)
        {
            if(a[i]>=d[len]) {len++;d[len]=a[i];}
        else{
             int pos=upper_bound(d+1,d+len,a[i])-d;//非严格单调
             d[pos]=a[i];
        }
        }
        printf("%d\n",len);
    }
    return 0;
}

【最长公共上升子序列（LICS）】
题分成两种，一个是在求个LICS个数，还有
一个是要求求LICS的样子codeforces的10D好像

下面的解释来自百度/各种博客…集结【慢慢看】

//某大神的几句话的事：http://www.cnblogs.com/ka200812/archive/2012/10/15/2723870.html
设题目给出a[],b[]两个序列。f[j]表示b序列到j的时候，与a[？？]序列构成最长公共上升子序列的最优解。其中a[？？]序列，从1到n枚举过来。
如果某一个时刻a[i]==b[j]，那么显然，我们就应该在0到j-1中，找一个f值最大的来更新最优解。这和求上升子序列是思想是一样的。另外，在枚举b[j]的时候，我们顺便保存一下小于a[i]的f值最大的b[j]，这样在更新的时候，我们就可以做到O(1)的复杂度，从而将整个算法的复杂度保证在O(nm)
输入案例
/*
10
7 10 1 2 1 7 1 5 9 9
9
6 2 5 6 7 7 5 5 2
*/

看不懂大神的几句话，看这个…【大自然的搬运工】…（来自百度）
预备知识：动态规划的基本思想，LCS，LIS。
问题：字符串a，字符串b，求a和b的LCIS（最长公共上升子序列）。
首先我们可以看到，这个问题具有相当多的重叠子问题。于是我们想到用DP搞。DP的首要任务是什么？定义状态。
1定义状态F[i][j]表示以a串的前i个字符b串的前j个字符且以b[j]为结尾构成的LCIS的长度。
为什么是这个而不是其他的状态定义？最重要的原因是我只会这个，还有一个原因是我知道这个定义能搞到平方的算法。而我这只会这个的原因是，这个状态定义实在是太好用了。这一点我后面再说。
我们来考察一下这个这个状态。思考这个状态能转移到哪些状态似乎有些棘手，如果把思路逆转一下，考察这个状态的最优值依赖于哪些状态，就容易许多了。这个状态依赖于哪些状态呢？
首先，在a[i]!=b[j]的时候有F[i][j]=F[i-1][j]。为什么呢？因为F[i][j]是以b[j]为结尾的LCIS，如果F[i][j]>0那么就说明a[1]..a[i]中必然有一个字符a[k]等于b[j]（如果F[i][j]等于0呢？那赋值与否都没有什么影响了）。因为a[k]!=a[i]，那么a[i]对F[i][j]没有贡献，于是我们不考虑它照样能得出F[i][j]的最优值。所以在a[i]!=b[j]的情况下必然有F[i][j]=F[i-1][j]。这一点参考LCS的处理方法。
那如果a[i]==b[j]呢？首先，这个等于起码保证了长度为1的LCIS。然后我们还需要去找一个最长的且能让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。显然有F[i][j]>F[i][j],i>i） 于是我们得出了状态转移方程：
a[i]!=b[j]: 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]
不难看到，这是一个时间复杂度为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]。如果循环到了a[i]==b[j]的时候，则令F[i][j]=max+1。
最后答案是F[len(a)][1]..F[len(a)][len(b)]的最大值。 参考代码：

int f[1005][1005],a[1005],b[1005],i,j,t,n1,n2,max;
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n1,&n2);
        for(i=1; i<=n1; i++) 
            scanf("%d",&a[i]);
        for(i=1; i<=n2; i++) 
            scanf("%d",&b[i]);
        memset(f,0,sizeof(f));

//        a[i]!=b[j]:   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])

        //如果按照一个合理的递推顺序，
        //max(F[i-1][k])的值我们可以在之前访问F[i][k]的时候，
        //通过维护更新一个max变量得到。
        for(i=1; i<=n1; i++)
        {
            max=0;
            for(j=1; j<=n2; j++)
            {
                f[i][j]=f[i-1][j];           //可判断也可不判断
                if (a[i]>b[j]&&max<f[i-1][j])//max一直是f[i][j]下更新
                    max=f[i-1][j];
                if (a[i]==b[j])
                    f[i][j]=max+1;
            }
        }
        max=0;
        for(i=1; i<=n2; i++)
            if (max<f[n1][i]) 
                max=f[n1][i];
        printf("%d\n",max);
    }
}

其实还有一个很风骚的一维的算法。在此基础上压掉了一维空间（时间还是平方）。i循环到x的时候，F[i]表示原来F[x][j]。之所以可以这样，是因为如果a[i]!=b[j]，因为F[x][j]=F[x-1][j]值不变，F[x]不用改变，沿用过去的就好了，和这个比较维护更新得到的max值依然是我们要的。而a[i]==b[j]的时候，就改变F[x]的值好了。具体结合代码理解。 参考代码：

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