最长递增子序列（poj-3903，1631我，1887（严格下降），2533（严格上升），LIS）

方法一：转换为LCS

O（n^2）对原数组排序去重，用一次LCS，要用到滚动数组。

方法二：动态规划法

设f(i)表示L中以a_i为末元素的最长递增子序列的长度。则有如下的递推方程：

这个递推方程的意思是，在求以a_i为末元素的最长递增子序列时，找到所有序号在L前面且小于a_i的元素a_j，即j<i且a_j<a_i。如果这样的元素存在，那么对所有a_j,都有一个以a_j为末元素的最长递增子序列的长度f(j)，把其中最大的f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以a_i为末元素的最长递增子序列，等于以使f(j)最大的那个a_j为末元素的递增子序列最末再加上a_i；如果这样的元素不存在，那么a_i自身构成一个长度为1的以a_i为末元素的递增子序列。

这个算法由Java实现的代码如下：

public void lis(float[] L)

  {

         int n = L.length;

         int[] f = new int[n];//用于存放f(i)值；

         f[0]=1;//以第a₁为末元素的最长递增子序列长度为1；

         for(int i = 1;i<n;i++)//循环n-1次

         {

                f[i]=1;//f[i]的最小值为1；

                for(int j=0;j<i;j++)//循环i次

                {

                       if(L[j]<L[i]&&f[j]>f[i]-1)

                              f[i]=f[j]+1;//更新f[i]的值。

                }

         }

         System.out.println(f[n-1]);            

              }

　　这个算法有两层循环，外层循环次数为n-1次，内层循环次数为i次，算法的时间复杂度

所以T(n)=O(n²)。这个算法的最坏时间复杂度与第一种算法的阶是相同的。但这个算法没有排序的时间，所以时间复杂度要优于第一种算法。

对第二种算法的改进

　　在第二种算法中，在计算每一个f(i)时，都要找出最大的f(j)(j<i)来，由于f(j)没有顺序，只能顺序查找满足a_j<a_i最大的f(j)，如果能将让f(j)有序，就可以使用二分查找，这样算法的时间复杂度就可能降到O(nlogn)。于是想到用一个数组B来存储“子序列的”最大递增子序列的最末元素，即有

B[f(j)] =a_j

　　在计算f(i)时，在数组B中用二分查找法找到满足j<i且B[f(j)]=a_j<a_i的最大的j,并将B[f[j]+1]置为a_i。

nt d[100005], B[100005];int len, n;void LIS(){B[0] = -10000;B[1] = d[1];len = 1;int i;for (i = 2; i <= n; ++i) {int low = 0;int high = len;while (low <= high) {int mid = (low + high) / 2;if (B[mid] < d[i]) low = mid + 1;else high = mid - 1;}B[low] = d[i];if (low > len) ++len;}}