【最长递增子序列】动态规划

问题描述：
输入一组乱序的数据，输出这组数据的最长的递增序列，如输入X[ ] = （2 8 9 4 6 1 3 7 5 10），则输出（2 4 6 7 10）

求解最长递增子序列的问题，我们考虑用动态规划，而动态规划，我们就得弄清楚子问题，最终的解决办法如下：

1.在遍历数据的过程中，记录下排第几的数是哪一位，用L[ ]数组来记录，用len来表示当前的最高位的位数；
2.遍历遇到比最高位还大的数X[i]，则len++，记录L[len] = i；
3.若遍历的数X[i]比最高位小，则从第一位到最高位遍历，找到第一个比X[i]小的数，将这个数替换成X[i]；

遍历函数如下：

for(i = 1; i <= n; i++)
{
	if(X[i] > X[L[len]])
	{
		L[++len] = i;
	}
	else
	{
		for(j = 1; j <= len; j++)
		{
			if(X[i] < X[L[j]])
			{
				L[j] = i;
				break;
			}
		}
	}
}

当然遍历结束后，我们还要想办法输出，此时遍历之后的结果是这样的：
记录的结果是1 3 5 7 10，但我们应该得到的是2 4 6 7 10，问题在哪呢？细心的同学应该发现了，图上面有一个“父亲”记录，没错，这就是我们输出所需要的记录，在原遍历代码中加入：

for(i = 1; i <= n; i++)
{
	if(X[i] > X[L[len]])
	{
		F[i] = L[len];
		L[++len] = i;
	}
	else
	{
		for(j = 1; j <= len; j++)
		{
			if(X[i] < X[L[j]])
			{
				F[i] = L[j - 1];//注意初始条件L[0] = 0,L[1] = 0;
				L[j] = i;
				break;
			}
		}
	}
}

这样在我们输出的时候，就可以通过L[len]找到他的父亲，再找到他父亲的父亲…直到len = 0；代码如下：

l = L[len];
while(l != 0)
{
	cout << X[l] << endl;
	l = F[l];
}

最后贴出完整版代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int X[1000];
int L[1000];
int F[1000];

int Dp(int n)
{
    F[1] = 0;
    F[0] = 0;
    L[1] = 1;
    int len = 1, i;
    for(i = 2; i <= n; i++)
    {
        if(X[i] > X[L[len]])
        {
            printf("%d\n",X[L[len]]);
            F[i] = L[len];
            L[++len] = i;
        }
        else
        {
            int j;
            for(j = 1; j <= len; j++)
            {
                if(X[i] < X[L[j]])
                {
                    F[i] = L[j - 1];
                    L[j] = i;
                    break;
                }
            }
        }
    }
    return L[len];
}

int main()
{
    int n,i;
    scanf("%d",&n);
    for(i = 1; i <= n; i++)
    {
        scanf("%d", &X[i]);
    }
    int len = Dp(n);
    printf("%d\n",F[len]);
    while(len != 0)
    {
        printf("%d ",X[len]);
        len = F[len];
    } 
    system("pause");
    return 0;
}