NYOJ-214 單調遞增子序列(二)

單調遞增子序列(二)

時間限制： 1000 ms  |           內存限制： 65535 KB

難度： 4

 

描述

給定一整型數列{a₁,a₂...,a_n}（0<n<=100000），找出單調遞增最長子序列，並求出其長度。

如：1 9 10 5 11 2 13的最長單調遞增子序列是1 9 10 11 13，長度為5。

 

輸入

有多組測試數據（<=7） 每組測試數據的第一行是一個整數n表示序列中共有n個整數，隨后的下一行里有n個整數，表示數列中的所有元素.每個整形數中間用空格間隔開（0<n<=100000）。 數據以EOF結束 。 輸入數據保證合法（全為int型整數）！

輸出

對於每組測試數據輸出整形數列的最長遞增子序列的長度，每個輸出占一行。

樣例輸入

7
1 9 10 5 11 2 13
2
2 -1

樣例輸出

5
1

/* 代碼一：  經典求法---TLE
#include <iostream>
#include <cstdio>
const int N = 100000 + 10;

using namespace std;

int a[N], dp[N];
int main()
{
    int n, maxlen;
    while(scanf("%d", &n) != EOF)
    {
        maxlen = 0;
        for(int i = 0; i < n; ++i)
        {
            scanf("%d", &a[i]);
            dp[i] = 1;
            for(int j = 0; j < i; ++j)
            {
                if(a[j] < a[i] && dp[j] + 1 > dp[i])
                    dp[i] = dp[j] + 1;
                if(maxlen < dp[i])
                    maxlen = dp[i];
            }
        }
        printf("%d\n", maxlen);
    }
    return 0;
}
代碼二：
這是一個很好的題目。題目的算法還是比較容易看出來的，就是求最長上升子序列的長度。
不過這一題的數據規模最大可以達到40000，經典的O(n^2)的動態規划算法明顯會超時。
我們需要尋找更好的方法來解決是最長上升子序列問題。
先回顧經典的O(n^2)的動態規划算法，設A[i]表示序列中的第i個數，F[i]表示從1到i這一段
中以i結尾的最長上升子序列的長度，初始時設F[i] = 0(i = 1, 2, ..., len(A))。則有動態規划方程：F[i] = max{1, F[j] + 1} (j = 1, 2, ..., i - 1, 且A[j] < A[i])。
現在，我們仔細考慮計算F[i]時的情況。假設有兩個元素A[x]和A[y]，滿足
(1) x < y < i
(2) A[x] < A[y] < A[i]
(3) F[x] = F[y]
此時，選擇F[x]和選擇F[y]都可以得到同樣的F[i]值，那么，在最長上升子序列的這個位置中，
應該選擇A[x]還是應該選擇A[y]呢？
很明顯，選擇A[x]比選擇A[y]要好。因為由於條件(2)，在A[x+1] ... A[i-1]這一段中，
如果存在A[z]，A[x] < A[z] < a[y]，則與選擇A[y]相比，將會得到更長的上升子序列。
再根據條件(3)，我們會得到一個啟示：根據F[]的值進行分類。對於F[]的每一個取值k，
我們只需要保留滿足F[i] = k的所有A[i]中的最小值。設D[k]記錄這個值，
即D[k] = min{A[i]} (F[i] = k)。

注意到D[]的兩個特點：

(1) D[k]的值是在整個計算過程中是單調不上升的。
(2) D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。

利用D[]，我們可以得到另外一種計算最長上升子序列長度的方法。設當前已經求出的
最長上升子序列長度為len。先判斷A[i]與D[len]。若A[i] > D[len]，
則將A[i]接在D[len]后將得到一個更長的上升子序列，len = len + 1， D[len] = A[i]；
否則，在D[1]..D[len]中，找到最大的j，滿足D[j] < A[i]。令k = j + 1，則有D[j] < A[i] <= D[k]，
將A[i]接在D[j]后將得到一個更長的上升子序列，同時更新D[k] = A[i]。
最后，len即為所要求的最長上升子序列的長度。

在上述算法中，若使用朴素的順序查找在D[1]..D[len]查找，由於共有O(n)個元素需要計算，
每次計算時的復雜度是O(n)，則整個算法的時間復雜度為O(n^2)，與原來的算法相比沒有任何進步。
但是由於D[]的特點(2)，我們在D[]中查找時，可以使用二分查找高效地完成，則整個算法的時間復雜度
下降為O(nlogn)，有了非常顯著的提高。需要注意的是，D[]在算法結束后記錄的並不是一個符合題意的
最長上升子序列！

這個算法還可以擴展到整個最長子序列系列問題，整個算法的難點在於二分查找的設計，需要非常小心注意。
*/

#include <iostream>
#include <cstdio>
const int N = 100000 + 10;

using namespace std;

int a[N], dp[N];

int binarysearch(int k, int len)
{
    int right = len;
    int left = 1;
    int mid = (right + left) >> 1;
    while(left <= right)
    {
        if(k == dp[mid])
            return mid;
        if(k > dp[mid])
            left = mid + 1;
        else
            right = mid - 1;
        mid = (right + left) >> 1;
    }
    return left;
}

int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        int len, t;
        for(int i = 0; i < n; ++i)
            scanf("%d", &a[i]);
        len = 1;
        dp[1] = a[0];
        for(int i = 1; i < n; ++i)
        {
            t = binarysearch(a[i], len);
            dp[t] = a[i];
            if(t > len)
                len = t;
        }
        printf("%d\n", len);
    }
    return 0;
}