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

来源：互联网发布：java图形化界面编辑：程序博客网时间：2024/06/05 18:17

写一个时间复杂度尽可能低的程序，求一个一维数组（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的子序列。

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

[cpp] view plaincopyprint?

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的最大值
}

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]]。

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

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

[cpp] view plaincopyprint?

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;
}

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]的情况，则跟定义矛盾，为什么？

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

[cpp] view plaincopyprint?

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

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

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

小结

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

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