程序员面试100题之十二：求数组中最长递增子序列

写一个时间复杂度尽可能低的程序，求一个一维数组（N个元素）中最长递增子序列的长度。

例如：在序列1，-1，2，-3，4，-5，6，-7中，其最长递增子序列为1，2，4，6。

分析与解法

根据题目要求，求一维数组中的最长递增子序列，也就是找一个标号的序列b[0]，b[1]，... b[m]（0<=b[0]<b[1]<...<b[m]<N），使得array[b[0]]< array[b[1]]<...<array[b[m]]。

解法一

根据无后效性的定义我们知道，将各阶段按照一定的次序排列好之后，对于某个给定阶段的状态来说，它以前各阶段的状态无法直接影响它未来的决策，而只能间接地通过当前状态来影响。换句话说，每个状态都是过去历史的一个完整总结。

同样地，仍以序列1，-1，2，-3，4，-5，6，-7中为例，我们在找到4之后，并不关心4之前的两个值具体是怎样，因为它对找到6并没有直接影响。因此，这个问题满足无后效性，可以使用动态规划来解决。

可以通过数字的规律来分析目标串：1，-1，2，-3，4，-5，6，-7。

使用i来表示当前遍历的位置：

当i=1时，显然，最长的递增序列为（1），序列长度为1.

当i=2时，由于-1<1。因此，必须丢弃第一个值然后重新建立串。当前的递增序列为（-1），长度为1.

当i=3时，由于2>1，2>-1。因此，最长的递增序列为（1,2），（-1,2），长度为2。在这里，2前面是1还是-1对求出后面的递增序列没有直接影响。

依次类推之后，可以得出如下的结论。

假设在目标数组array[]的前i个元素中，最长递增子序列的长度为LIS[i]。那么，

LIS[i+1]=max{1,LIS[k]+1}，array[i+1]>array[k]，for any k<=i

即如果array[i+1]大于array[k]，那么第i+1个元素可以接在LIS[k]长的子序列后面构成一个更长的子序列。与此同时array[i+1]本身至少可以构成一个长度为1的子序列。

根据上面的分析，可以得到如下的代码：

int LIS(int[] array) { int *LIS = new int[array.Length]; for(int i = 0; i < array.Length; i++) { LIS[i] = 1; //初始化默认的长度 for(int j = 0; j < i; j++) //前面最长的序列 { if(array[i] > array[j] && LIS[j] + 1 > LIS[i]) { LIS[i] = LIS[j] + 1; } } } return Max(LIS); //取LIS的最大值 }

这种方法的时间复杂度为O（N^2+N）= O（N^2）。

解法二

显然O(N^2)的算法只是一个比较基本的解法，我们须要想想看是否能够进一步提高效率。在前面的分析中，当考虑第i+1个元素的时候，我们是不考虑前面i个元素的分布情况的。现在我们从另一个角度分析，即当考虑第i+1个元素的时候考虑前面i个元素的情况。

对于前面i个元素的任何一个递增子序列，如果这个子序列的最大的元素比array[i+1]小，那么就可以将array[i+1]加在这个子序列后面，构成一个新的递增子序列。

比如当i=4的时候，目标序列为：1，-1，2，-3，4，-5，6，-7最长递增序列为：（1,2），（-1,2）。那么，只要4>2，就可以把4直接增加到前面的子序列形成一个新的递增子序列。

因此，我们希望找到前i个元素中的一个递增子序列，使得这个递增子序列的最大的元素比array[i+1]小，且长度尽量地长。这样将array[i+1]加在该递增子序列后，便可找到以array[i+1]为最大元素的最长递增子序列。

仍然假设在数组的前i个元素中，以array[i]为最大元素的最长递增子序列的长度为LIS[i]。

同时，假设：

长度为1的递增子序列最大元素的最小值为MaxV[1]；

长度为2的递增子序列最大元素的最小值为MaxV[2]；

......

长度为LIS[i]的递增子序列最大元素的最小值为MaxV[LIS[i]]。

假如维护了这些值，那么，在算法中就可以利用相关的信息来减少判断的次数。

具体算法实现如代码所示：

int LIS(int array[]) { //记录数组中的递增序列信息 int *MaxV = new int[array.Length + 1]; MaxV[1] = array[0]; //数组中的第一值，边界值 MaxV[0] = Min(array) - 1; //数组中最小值，边界值 int *LIS = new int[array.Length]; //初始化最长递增序列的信息 for(int i = 0;i < LIS.Length; i++) { LIS[i] = 1; } int nMaxLIS = 1; //数组最长递增子序列的长度 for(int i = 1; i < array.Length; i++) { //遍历历史最长递增序列信息 int j; for(j = nMaxLIS; j >=0; j--) { if(array[i] > MaxV[j]) { LIS[i] = j + 1; break; } } //如果当前最长序列大于最长递增序列长度，更新最长信息 if(LIS[i] > nMaxLIS) { nMaxLIS = LIS[i]; MaxV[LIS[i]] = array[i]; } else if(MaxV[j] < array[i] && array[i] < MaxV[j + 1]) { MaxV[j + 1] = array[i]; } } return nMaxLIS; }

由于上述解法中的穷举遍历，时间复杂度仍然为O（N^2）。

解法三
解法二的结果似乎仍然不能让人满意。我们是否把递增序列中间的关系全部挖掘出来了呢？再分析一下临时存储下来的最长递增序列信息。

在递增序列中，如果i<j，那么就会有MaxV[i]<MaxV[j]。如果出现MaxV[j]<MaxV[i]的情况，则跟定义矛盾，为什么？

因此，根据这样单调递增的关系，可以将上面方法中的穷举部分进行如下修改：

for(int j = LIS[i - 1]; j >= 1; j--) { if(array[i] > MaxV[j]) { LIS[i] = j + 1; break; } }

如果把上述的查询部分利用二分搜索进行加速，那么就可以把时间复杂度降为O(N*log2N)。

小结

从上面的分析中可以看出我们先提出一个最直接（或者说最简单）的解法，然后从这个最简单解法来看是否有提升的空间，进而一步一步地挖掘解法中的潜力，从而减少解法的时间复杂度。

在实际的面试中，这样的方法同样有效。因为面试者更加看中的是应聘者是否有解决问题的思路，不会因为最后没有达到最优算法而简单地给予否定。应聘者也可以先提出简单的办法，以此投石问路，看看面试者是否会有进一步的提示。