求数组中最长递增子序列

《编程之美》 2.16

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

解法一：DP解法。详见代码。

代码一：

int LIS(int a[],int n)
{
	int *LIS = (int*)malloc(n*sizeof(int));
	for(int i = 0; i < n; i++){
		LIS[i] = 1;
		for(int j = 0; j < i; j++){
			if (a[i] > a[j] && LIS[j] + 1 > LIS[i]){
				LIS[i] = LIS[j] + 1;
			}
		}
	}
	//找出最长序列长度maxL以及最大元素的下标maxi 
	int maxL = LIS[0];
	int maxi = 0;
	for (int i = 1; i < n; i++){
		if (LIS[i] > maxL) {
			maxL = LIS[i];
			maxi = i;
		}
		
	}
	//输出LIS 
	for(int i = 0; i < n; i++){
		printf("%-4d",LIS[i]);
	}
	printf("\n");
	//逆序输出递增序列 
	int tmp = LIS[maxi];
	for (int i = maxi; i >= 0; i--){
		if (LIS[i] == tmp){ 
			printf("%-4d",a[i]);
			tmp--;
		}
	}
	printf("\n");
	free(LIS);
	return maxL;
}

解法二：记录各个长度的递增序列的最大元素的最小值。通过这些信息减少判断次数。优化“遍历历史最长递增序列信息”的查找为二分查找可以进一步减少复杂度。

代码二：

int min(int a[], int n)
{
	int minV = INT_MAX;
	for(int i = 0; i < n; i++){
		if (a[i] < minV){
			minV = a[i];
		}		
	}
	return minV;
}

int LIS2(int a[],int n)
{
	//记录数组中的递增序列信息
	int *maxV = (int*)malloc((n+1)*sizeof(int));
	maxV[1] = a[0];
	maxV[0] = min(a,n) - 1;
	int *lis = (int*)malloc(n*sizeof(int));
	//初始化最长递增序列的信息 
	for (int i = 0; i < n; i++) {
		lis[i] = 1;
	}
	
	int nMaxlis = 1;
	for (int i = 1; i < n; i++) {
		//遍历历史最长递增序列信息
		int j;
		for (j = nMaxlis; j >= 1; j--) {
			if (a[i] > maxV[j]) {
				lis[i] = j + 1;
				break;
			}
		} 

		//如果当前最长序列大于最长递增序列长度，更新最长信息
		if (lis[i] > nMaxlis){
			nMaxlis = lis[i];
			maxV[lis[i]] = a[i]; 
		} 
		else if (maxV[j] < a[i] && a[i] < maxV[j+1]) {
			maxV[j + 1] = a[i];
		}
	}
	return nMaxlis; 
}

测试代码：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>


int LIS(int a[],int n)
{
	int *LIS = (int*)malloc(n*sizeof(int));
	for(int i = 0; i < n; i++){
		LIS[i] = 1;
		for(int j = 0; j < i; j++){
			if (a[i] > a[j] && LIS[j] + 1 > LIS[i]){
				LIS[i] = LIS[j] + 1;
			}
		}
	}
	//找出最长序列长度maxL以及最大元素的下标maxi 
	int maxL = LIS[0];
	int maxi = 0;
	for (int i = 1; i < n; i++){
		if (LIS[i] > maxL) {
			maxL = LIS[i];
			maxi = i;
		}
		
	}
	//输出LIS 
	for(int i = 0; i < n; i++){
		printf("%-4d",LIS[i]);
	}
	printf("\n");
	//逆序输出递增序列 
	int tmp = LIS[maxi];
	for (int i = maxi; i >= 0; i--){
		if (LIS[i] == tmp){ 
			printf("%-4d",a[i]);
			tmp--;
		}
	}
	printf("\n");
	free(LIS);
	return maxL;
}
/*-------------------------------------------------------------------*/
int min(int a[], int n)
{
	int minV = INT_MAX;
	for(int i = 0; i < n; i++){
		if (a[i] < minV){
			minV = a[i];
		}		
	}
	return minV;
}

int LIS2(int a[],int n)
{
	//记录数组中的递增序列信息
	int *maxV = (int*)malloc((n+1)*sizeof(int));
	maxV[1] = a[0];
	maxV[0] = min(a,n) - 1;
	int *lis = (int*)malloc(n*sizeof(int));
	//初始化最长递增序列的信息 
	for (int i = 0; i < n; i++) {
		lis[i] = 1;
	}
	
	int nMaxlis = 1;
	for (int i = 1; i < n; i++) {
		//遍历历史最长递增序列信息
		int j;
		for (j = nMaxlis; j >= 1; j--) {
			if (a[i] > maxV[j]) {
				lis[i] = j + 1;
				break;
			}
		} 

		//如果当前最长序列大于最长递增序列长度，更新最长信息
		if (lis[i] > nMaxlis){
			nMaxlis = lis[i];
			maxV[lis[i]] = a[i]; 
		} 
		else if (maxV[j] < a[i] && a[i] < maxV[j+1]) {
			maxV[j + 1] = a[i];
		}
	}
	return nMaxlis; 
}

/*-------------------------------------------------------------------*/

void show(int a[],int n)
{
	for(int i = 0; i < n; i++){
		printf("%-4d",a[i]);
	}
	printf("\n");
}

int main()
{
	srand(time(NULL));
	int N = 10;
	int a[10];
	
	for(int i = 0; i < 10; i++){
		a[i] = ((rand() & 0x1) ? -1 : 1) * (rand() % 20);
	}
	show(a,N);
	
	printf("Max LIS len : %d .\n",LIS(a,10));
	printf("Max LIS len : %d .\n",LIS2(a,10));
	
}

测试输出：

-7  17  -3  -18 10  6   -14 -9  -4  -10 
1   2   2   1   3   3   2   3   4   3   
-4  -9  -14 -18 
Max LIS len : 4 .
Max LIS len : 4 .

REF:

1，编程之美 2.16 求数组中最长递增子序列