给出长度为N的数组，找出这个数组的最长递增子序列。(递增子序列是指，子序列的元素是递增的）
例如：5 1 6 8 2 4 5 10，最长递增子序列是1 2 4 5 10。
Input
第1行：1个数N，N为序列的长度(2 <= N <= 50000)
第2 - N + 1行：每行1个数，对应序列的元素(-10^9 <= S[i] <= 10^9)
Output
输出最长递增子序列的长度。
Input示例
8
5
1
6
8
2
4
5
10
Output示例
5

这道题，最开始想着一种比较耗时的法子，当然真的超时了，想着建立一个数组，存对应位置前的最长递增子序列，每当考虑一个数，都是考虑所有的前边的键值小于此数的对应最长子序列的长度中最长的，然后加上1即可，代码如下：

#include <stdio.h>
#define MAX(a, b) a > b ? a : b

int main(int argc, const char * argv[])
{
    int maxLen = 0, N, A[50001], B[50001] = {
  0}, i, j;
    scanf("%d", &N);
    scanf("%d", A);
    B[0] = 1;
    for (i = 1; i < N; i++)
    {
        scanf("%d", A + i);
        maxLen = 0;
        for (j = i - 1; j >= 0; j--)
        {
            if (A[j] <= A[i])
            {
                maxLen = MAX(maxLen, B[j]);
            }
        }
        B[i] = maxLen + 1;
    }
    maxLen = 0;
    for (i = 0; i < N; i++)
    {
        maxLen = MAX(maxLen, B[i]);
    }
    printf("%d\n", maxLen);
    return 0;
}

这种写法只能过四分之三的测试数据，很是伤心，于是只好用动归，如下：

#include <stdio.h>
#define MAXSIZE 50001
#define MAX(a, b) a > b ? a : b
int A[MAXSIZE];
int B[MAXSIZE]; //最长子序列

//从当前序列中返回第一个键值大于A的数的下标
int upper_bound(int len, int A)
{
    int i = 0;
    for (; i < len; i++)
    {
        if (B[i] > A)
        {
            return i;
        }
    }
    return i;
}

int list(int n)
{
    int len = 1;
    B[0] = A[0];
    for (int i = 1; i < n; i++)
    {
        B[A[i] > B[len - 1] ? len++ : upper_bound(len, A[i])] = A[i];
    }
    return len;
}
int main(int argc, const char * argv[])
{
    int N, i;
    scanf("%d", &N);
    for (i = 0; i < N; i++)
    {
        scanf("%d", A + i);
    }
    printf("%d\n", list(N));
    return 0;
}

这里需要说的就是第一个函数upper_bound(int len, int A)函数，在C艹中有类似的函数，返回的是当前B序列中第一个键值大于A的数的下标，然后我们主要操作就是将此下标的值重写。
状态转移方程：B[A[i] > B[len - 1] ? len++ : upper_bound(len, A[i])] = A[i];
只要A[i] > B[len - 1]，那么我们就顺着往后存，否则重写upper_bound()函数返回的下标对应的值。
OVER！！！