LIS（最长上升子序列）

       学习动态规划，绕不过去的一个经典的算法就是LIS, 也就是最长上升子序列。当然，对于这个问题有很多变化形式，如最长下降子序列、最长非上升子序列、最长非下降子序列等。但是，其内在的原理是一样，所运用的算法也是相同的，只是在一些细节方面有些许变化而已。

       现在以BUAA内部上机网站上的EASY LIS为例（好久没有上过POJ了），来总结自己在学习LIS中的心得体会。

       题目原址：http://acm.buaa.edu.cn/problem/353/

       

       LIS的定义google一下都知道，不再赘述。现在主要讨论的是LIS的两种算法，先来说O(N*N)的算法：

1. O(N*N)算法

       这个算法的思路是基于动态规划的思想，假设有序列a[1],a[2].....a[n]。那么试想，我们对于元素a[i]，都用对应的maxlen[i]储存以该元素为结尾的上升序列长度，那么最后的要寻找的最长上升子序列必然是所有这些序列中一个，而且是最长的一个。基于这种思想，先可以将所有的maxlen[i]储存，最后执行一次遍历就找到了最长的上升子序列。

      那么，在统计maxlen[i]时的思想是什么呢？试想，如果我们已经有了一个maxlen[i-1],那么以a[i]结尾的最长上升子序列就是在前面已经遍历过的i-1个元素中寻找这样的序列：

    （1）该序列最后一个元素比a[i]小

    （2）该序列在满足（1)的条件下，长度最长

     满足了这两个条件的序列实质上是寻找一个最长的以比a[i]小的元素结尾的序列，然后将a[i]接在这个序列的结尾，形成一个以a[i]结尾的最长子序列。设在前面找到的满足(1)(2)的长度是max, 那么maxlen[i] = max + 1。

     这样，就导出了maxlen的状态转移方程  maxlen[i] = max(maxlen[j]) + 1,其中0 < j < i 并且 a[j] < a[i]（假设a是从1开始储存的）。通过这样的状态转移方程，我们求得了maxlen，继续遍历一次就找到了最长上升子序列的长度。

    对于每一个maxlen[i]都需要遍历i前面的所有元素，平均遍历长度是n/2, 因此最后的时间复杂度为O(n*n/2) = O(N*N).

    

#define MAXN 1000005
#include <stdio.h>

int maxlen[MAXN],height[MAXN];
int l = 0;

int main()
{
    int i,j,n,max,ans;
    while(scanf("%d",&n) != EOF)
    {
        for(i = 1; i <= n;i++){
           scanf("%d",&height[i]);
           maxlen[i] = 0;  //初始化为0
        }

        ans = 0;
        for(i = 1; i <= n;i++)
        {
            max = 0;
            for(j = 1; j < i;j++)
               if(height[j] < height[i] && max < maxlen[j])//状态转移方程
                  max = maxlen[j];

            maxlen[i] = max + 1;//前面找到最长的+1就是当前最长的
            
            if(ans < maxlen[i]) ans = maxlen[i];//全部遍历一次，最后找出最大值
        }

        printf("Case %d: %d\n",++l,ans);
    }
}

在LIS的形式变化中，只需修改其中的比较部分代码就可以，比如需要寻找的是最长不下降子序列。那么，只需要简单地将height[j] < height[j]改成height[j] <= height[j]即可。最长下降子序列道理也是相同的，只是修改大于小于号的问题。

2. O(N*lgN)算法

       在1s的时间限制下，显然O(N*N)算法不能满足n>10^4的计算量，对于LIS就有时间复杂度更低的算法，也就是O(N*lgN)的算法。

       算法的思路是这样的，试想，在遍历整个序列的过程中，用一个栈储存最长子序列的元素，每遇到一个比当前最长子序列最后一个元素大的值，就把这个值压入栈中，那么最后得到的栈的长度就是我们。