用O(nlogn)的算法实现最大上升子序列（LIS）输出.

一直在考虑能不能用O(nlogn)的贪心能否输出子序列，参考了别人的blog，自己分析了一下，整理了这样一篇文章。

首先我们要知道在LIS贪心算法中，dp[i]数组表示的是长度为i的子序列的可取最小末尾是dp[i]，所以直接输出的dp[i]数组得到的并不是最大上升子序列。

详见：http://blog.csdn.net/yorkcai/article/details/8651895

那么如果非要实现，有没有办法呢？

我们先看LIS的O(nlogn)的实现代码。

int getLis(int n)
{
    fill(dp, dp + n, INF);
    for (int i = 0; i < n; i ++)
    {
        *lower_bound(dp, dp + n, a[i]) = a[i];
    }
    return lower_bound(dp, dp + n, INF) - dp;
}

如果要记录路径，我们需要一个pre[]数组来记录前驱，这点和dp算法是一样的。

但是这是不够，我们还需要一个专门的数组pos[]来记录最小末尾的下标。

现在到了往dp中插入一个数a[i]，有两种可能，一种是加到末尾，一种是替换前边的某一个数。

注：下面的是子序列，不是dp数组。

如果a[i]被插到了末尾意味着，最长升子序列增大了1。这时候新的序列相当于在后边添加一个a[i]。

①1 3 5 插入6 子序列变成 1 3 5 6

如果a[i]被插到前边，最长上升子序列数是不变的。但是序列可能发生变化，也可能不变。

②1 3 5 插入2 子序列还是 1 3 5

③1 3 5 插入4  子序列变成 1 3 4（1 3 5也可以，但是因为是贪心，要保证末尾尽量小）

但是无论是哪一种，我们只要记录pos【dp数组的最小末尾值在a数组中的位置（dp只能记录最小末尾的值)】、pre【前驱在a数组中的下标】就可以了。

假定a序列为 1 3 5 2 4 6 5 3  LIS为1 2 4 5或者1 3 4 5

① 插入1， pos[1] = 1, pre[1] = -1                    dp:1

② 插入3， pos[2] = 2, pre[2]= pos[1];            dp:1 3

③ 插入5， pos[3] = 3, pre[3]= pos[2];            dp:1 3 5

④ 插入2， pos[2] = 4, pre[4] = pos[1]            dp:1 2 5

⑤ 插入4， pos[3] = 5, pre[5] = pos[2]            dp: 1 2 4

⑥ 插入 6，pos[4] = 6, pre[6] = pos[3]            dp:1 2 4 6

⑦ 插入5， pos[4] = 7, pre[7] = pos[3]            dp:1 2 4 5

⑧ 插入3， pos[3] = 8, pre[8] = pos[2]            dp:1 2 3 5

dp[4] = 5对应的pos[4] = 7,  子序列最后一个元素为a[7],(a从1开始)

接着你会发现，前驱是4的下标——5                         而不是3的下标——8。

……

最终结果就是a[7], a[5], a[4], a[1]，逆序即可。

为什么这样就能得到结果。其实认真看你会发现，它是一颗树。

           1(1)

        /        \

3(2)          2(2)——3(3)

     /              \             

5(3)              4(3)（更新这个节点的时候，3已经不是pos[2]了，但是树没被破坏）

                 /      \

          5(4)       6(4)

pos表示的是层数，pre数组才是用来保存树的。

那么用代码实现就很简单了。

int get_lis(int n)
{
	fill(dp, dp + n, inf);
	pos[0] = -1;
	int i, lpos;
	for (i = 0; i < n; ++i)
	{
	    lpos = lower_bound(dp, dp + n, a[i]) - dp;
		dp[lpos] = a[i], pos[lpos] = i;
		if(lpos == 0)
            pre[i] = -1;
        else
            pre[i] = pos[lpos - 1];
	}
	return lower_bound(dp, dp + n, inf) - dp;
}
void print(int pos)
{
    if(pre[pos] != -1)
    {
        print(pre[pos]);
    }
    printf("%d ", pos + 1);
}

完整的代码：

#include <bits/stdc++.h>
using namespace std;
int a[1000], dp[1000], pre[1000], pos[1000];
const int inf = 0xffffff;
int get_lis(int n)
{
	fill(dp, dp + n, inf);
	pos[0] = -1;
	int i, lpos;
	for (i = 0; i < n; ++i)
	{
	    lpos = lower_bound(dp, dp + n, a[i]) - dp;
		dp[lpos] = a[i], pos[lpos] = i;
		if(lpos == 0)
            pre[i] = -1;
        else
            pre[i] = pos[lpos - 1];
	}
	return lower_bound(dp, dp + n, inf) - dp;
}

void print(int pos)
{
    if(pre[pos] != -1)
    {
        print(pre[pos]);
    }
    printf("%d ", a[pos]);
}

int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i ++)
    {
        scanf("%d", a + i);
    }
    int k = get_lis(n);
    printf("%d\n",k);
    print(pos[k-1]);
    printf("\n");
}

参考博客：http://blog.csdn.net/synapse7/article/details/11757021。