POJ2533 最长递增子序列

描述：

7

1 7 3 5 9 4 8

输出4

最长递增子序列为1 3 5 9，不必连续。

 

解法：

三种思路：

转化为最长公共子序列(n^2)，动态规划(n^2)，不知叫什么解法(nlogn)。

解法一：转化

先排序nlogn，在最长公共子序列

解法二：动态规划

dp[i]定义为，以此数为终点的最长递增子序列，

则dp[i] = dp[j] + 1，且dp <- max(dp[0] .. dp[i - 1]), a[i] > a[j]

注意处理边界条件，如果不存在dp[i]，则赋值为1，得：

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int* arr = new int[n]();
    int* arr_data = new int[n]();

    for (int i = 0; i < n; ++i) {
        int more;
        cin >> more;
        arr_data[i] = more;
        if (i == 0) {
            arr[0] = 1;
            continue;
        }

        int big = 1;
        for (int j = 0; j < i; ++j) {
            if (arr_data[j] < more && big < arr[j] + 1)
                big = arr[j] + 1;
        }
        arr[i] = big;
    }

    int ma = arr[0];
    for (int i = 1; i < n; ++i)
        if (ma < arr[i])
            ma = arr[i];

    cout << ma << endl;
    return 0;
}

解法三：更快解法

维护一个数组，第一个元素储存长度为1的递增序列最小值，第二个元素储存长度为2的递增序列终点的最小值。。。数组长度即为最长。

做法：

每次插入，替换恰大于插入数的数，如果没有，否则直接插在后面。

如例子：

1

1 7

1 3

1 3 5

1 3 5 9

1 3 4 9

1 3 4 8

以上为每次插入后，数组的变化。注意，最后数组并不是最长递增子序列！

由于每次使用二分查找插入，所以时间复杂度是nlogn。