最長上升子序列 LIS演算法實現
最長上升子序列LIS演算法實現
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在演算法結束後記錄的並不是一個符合題意的最長上升子序列！演算法還可以擴充套件到整個最長子序列系列問題。
有兩種演算法複雜度為O(n*logn)和O(n^2)
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[x] < A[y] < A[t] (3)F[x] = F[y]
此時，選擇F[x]和選擇F[y]都可以得到同樣的F[t]值，那麼，在最長上升子序列的這個位置中，應該選擇A[x]還是應該選擇A[y]呢？
很明顯，選擇A[x]比選擇A[y]要好。因為由於條件(2)，在A[x+1] ... A[t-1]這一段中，如果存在A[z]，A[x] < A[z] < a[y]，則與選擇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[]在演算法結束後記錄的並不是一個符合題意的最長上升子序列！
這個演算法還可以擴充套件到整個最長子序列系列問題，整個演算法的難點在於二分查詢的設計，需要非常小心注意。
最長上升子序列LIS演算法實現
最長上升子序列問題是各類資訊學競賽中的常見題型，也常常用來做介紹動態規劃演算法的引例，筆者接下來將會對POJ上出現過的這類題目做一個總結，並介紹解決LIS問題的兩個常用演算法(n^2)和(nlogn).
問題描述:給出一個序列a1,a2,a3,a4,a5,a6,a7....an,求它的一個子序列（設為s1,s2,...sn），使得這個子序列滿足這樣的性質，s1<s2<s3<...<sn並且這個子序列的長度最長。輸出這個最長的長度。（為了簡化該類問題，我們將諸如最長下降子序列及最長不上升子序列等問題都看成同一個問題，其實仔細思考就會發現，這其實只是<符號定義上的問題，並不影響問題的實質）
例如有一個序列:1 7 3 5 9 4 8,它的最長上升子序列就是 1 3 4 8 長度為4.
演算法1(n^2):我們依次遍歷整個序列，每一次求出從第一個數到當前這個數的最長上升子序列，直至遍歷到最後一個數字為止，然後再取dp數組裡最大的那個即為整個序列的最長上升子序列。我們用dp[i]來存放序列1-i的最長上升子序列的長度，那麼dp[i]=max(dp[j])+1,(j∈[1, i-1]); 顯然dp[1]=1,我們從i=2開始遍歷後面的元素即可。
下面是模板：
//最長上升子序列(n^2)模板
//入口引數：1.陣列名稱 2.陣列長度（注意從1號位置開始）
template<class T>
int LIS(T a[],int n)
{
int i,j;
int ans=1;
int m=0;
int *dp=new int[n+1];
dp[1]=1;
for(i=2;i<=n;i++)
{
m=0;
for(j=1;j<i;j++)
{
if(dp[j]>m&&a[j]<a[i])
m=dp[j];
}
dp[i]=m+1;
if(dp[i]>ans)
ans=dp[i];
}
return ans;
}
演算法2(nlogn):維護一個一維陣列c，並且這個陣列是動態擴充套件的，初始大小為1，c[i]表示最長上升子序列長度是i的所有子串中末尾最小的那個數，根據這個數字，我們可以比較知道，只要當前考察的這個數比c[i]大，那麼當前這個數一定能通過c[i]構成一個長度為i+1的上升子序列。當然我們希望在C陣列中找一個儘量靠後的數字，這樣我們得到的上升子串的長度最長，查詢的時候使用二分搜尋，這樣時間複雜度便下降了。
模板如下：
//最長上升子序列nlogn模板
//入口引數:陣列名+陣列長度，型別不限，結構體型別可以通過過載運算子實現
//陣列下標從1號開始。
/**//////////////////////////BEGIN_TEMPLATE_BY_ABILITYTAO_ACM////////////////////////////
template<class T>
int bsearch(T c[],int n,T a)
{
int l=1, r=n;
while(l<=r)
{
int mid = (l+r)/2;
if( a > c[mid] && a <= c[mid+1] ) return mid+1; // >&&<= 換為: >= && <
else if( a < c[mid] ) r = mid-1;
else l = mid+1;
}
}
template<class T>
int LIS(T a[], int n)
{
int i, j, size = 1;
T *c=new T[n+1];
int *dp=new int[n+1];
c[1] = a[1]; dp[1] = 1;
for(i=2;i<=n;++i)
{
if( a[i] <= c[1] ) j = 1;// <= 換為: <
else if( a[i] >c[size] )
j=++size; // > 換為: >=
else
j = bsearch(c, size, a[i]);
c[j] = a[i]; dp[i] = j;
}
return size;
}