LIS（Longest Increasing Subsequence）最長上升（不下降）子序列，有兩種算法複雜度為O(n*logn)和O(n^2)。在上述算法中，若使用樸素的順序查找在D1..Dlen查找，由於共有O(n)個元素需要計算，每次計算時的複雜度是O(n)，則整個算法的時間複雜度為O(n^2)，與原來算法相比沒有任何進步。但是由於D的特點(2)，在D中查找時，可以使用二分查找高效地完成，則整個算法時間複雜度下降為O(nlogn)，有了非常顯著的提高。需要注意的是，D在算法結束後記錄的並不是一個符合題意的最長上升子序列！算法還可以擴展到整個最長子序列系列問題。
基本介紹
- 中文名：LIS算法
- 外文名：Longest Increasing Subsequence
- 複雜度：O(n*logn)和O(n^2)
- 特點：單調不上升
Pascal代碼
program Project1;
var a,x:array[1..10000]of longint;
i,j,sum,n:longint;
function min(s:longint):longint;
var l,r,t:longint;
begin
l:=1;
r:=sum;
while l<r do
begin
t:=(l+r)div 2;
if s>x[t]then l:=t+1
else r:=t;
while x[l]=s do inc(l);
end;
exit(l);
end;
begin readln(n);
for i:=1 to n do
read(a[i]);
x[1]:=a[1];
sum:=1;
for i:=2 to n do
begin
if a[i]>=x[sum]then
begin
inc(sum);
x[sum]:=a[i];
end
else
begin
j:=min(a[i]);
if a[i]<x[j] then x[j]:=a[i];
end;
end;
writeln(sum);
readln;
end.
算法簡析
有兩種算法複雜度為O(n*logn)和O(n^2)
C代碼複雜度為O(n^2)的如下
#include<stdio.h>#defineSIZE100/*@parama表述基礎序列數組@paramd[i]表示在a[i]為最長子序列的尾部的位置*/intLIS(int*a,int*d){intmax=0;d[0]=1;for(inti=1;i<SIZE;i++){d[i]=1;for(intj=0;j<i;j++){if(a[i]>a[j]&&d[i]+1>d[j]){d[i]=d[j]+1;}}max=d[i]>max?d[i]:max;}returnmax;}c代碼複雜度為O(nlgn)的如下：
#include<stdio.h>#define SIZE 100000int F[SIZE],n;/*b:棧中元素s:待查找元素length:棧中元素個數*/int dichotomy_search(int *b,int s,int length){ int low=0,between=0; while(low<length) { between=(low+length)/2; if(b[between]>s) length=between-1; else low=between+1; } return low;}int LIS(int *a){ int stack[SIZE],j=0; stack[j]=a[0]; for(int i=1;i<n;i++) { if(a[i]>stack[i-1]) { stack[j++]=a[i]; } else if(a[i]<stack[i-1]) { int n=dichotomy_search(stack,a[i],j+1); stack[n]=a[i]; } } return j;}O(n^2)算法分析
（a[1]...a[n] 存的都是輸入的數）
1、對於a[n]來說，由於它是最後一個數，所以當從a[n]開始查找時，只存在長度為1的不下降子序列；
2、若從a[n-1]開始查找，則存在下面的兩種可能性：
（1）若a[n-1] < a[n] 則存在長度為2的不下降子序列 a[n-1],a[n].
（2）若a[n-1] > a[n] 則存在長度為1的不下降子序列 a[n-1]或者a[n]。
3、一般若從a[t]開始，此時最長不下降子序列應該是按下列方法求出的：
在a[t+1],a[t+2],...a[n]中，找出一個比a[t]大的且最長的不下降子序列，作為它的後繼。
4、為算法上的需要，定義一個數組：
d:array [1..n,1..3] of integer;
d[t,1]表示a[t]
d[t,2]表示從i位置到達n的最長不下降子序列的長度
d[t,3]表示從i位置開始最長不下降子序列的下一個位置
最長不下降子序列的O(n*logn)算法
先回顧經典的O(n^2)的動態規划算法，設A[t]表示序列中的第t個數，F[t]表示從1到t這一段中以t結尾的最長上升子序列的長度，初始時設F[t] = 0(t = 1, 2, ..., len(A))。則有動態規劃方程：F[t] = max{1, F[j] + 1} (j = 1, 2, ..., t - 1, 且A[j] < A[t])。
現在，我們仔細考慮計算F[t]時的情況。假設有兩個元素A[x]和A[y]，滿足
(1)x < y < t (2)A[y] < A[x] < A[t] (3)F[x] = F[y]
此時，選擇A[x]和選擇A[y]都可以得到同樣的F[t]值，那么，在最長上升子序列的這個位置中，應該選擇A[x]還是應該選擇A[y]呢？
很明顯，選擇A[y]比選擇A[x]要好。因為由於條件(2)，在A[x+1] ... A[t-1]這一段中，如果存在A[z]，A[y] < A[z] < A[x]，則與選擇A[x]相比，選擇A[y]將會得到更長的上升子序列。
再根據條件(3)，我們會得到一個啟示：根據F[]的值進行分類。對於F[]的每一個取值k，我們只需要保留滿足F[t] = k的所有A[t]中的最小值。設D[k]記錄這個值，即D[k] = min{A[t]} (F[t] = k)。
注意到D[]的兩個特點：
(1) D[k]的值是在整個計算過程中是單調不上升的。
(2) D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。
利用D[]，我們可以得到另外一種計算最長上升子序列長度的方法。設當前已經求出的最長上升子序列長度為len。先判斷A[t]與D[len]。若A[t] > D[len]，則將A[t]接在D[len]後將得到一個更長的上升子序列，len = len + 1， D[len] = A[t]；否則，在D[1]..D[len]中，找到最大的j，滿足D[j] < A[t]。令k = j + 1，則有D[j] < A[t] <= D[k]，將A[t]接在D[j]後將得到一個更長的上升子序列，同時更新D[k] = A[t]。最後，len即為所要求的最長上升子序列的長度。
在上述算法中，若使用樸素的順序查找在D[1]..D[len]查找，由於共有O(n)個元素需要計算，每次計算時的複雜度是O(n)，則整個算法的時間複雜度為O(n^2)，與原來的算法相比沒有任何進步。但是由於D[]的特點(2)，我們在D[]中查找時，可以使用二分查找高效地完成，則整個算法的時間複雜度下降為O(nlogn)，有了非常顯著的提高。需要注意的是，D[]在算法結束後記錄的並不是一個符合題意的最長上升子序列！
這個算法還可以擴展到整個最長子序列系列問題，整個算法的難點在於二分查找的設計，需要非常小心注意。
