动态规划之最长递增子序列

面试经常出现问题：

最大子序列：http://blog.csdn.net/yangquanhui1991/article/details/51943359

动态规划之最长递增子序列：http://blog.csdn.net/yangquanhui1991/article/details/51943000

动态规划之最长公共子串：http://blog.csdn.net/yangquanhui1991/article/details/51945211

动态规划之最长公共子序列：http://blog.csdn.net/yangquanhui1991/article/details/51942532

最长递增子序列问题是一个很基本、较常见的小问题，但这个问题的求解方法却并不那么显而易见，需要较深入的思考和较好的算法素养才能得出良好的算法。由于这个问题能运用学过的基本的算法分析和设计的方法与思想，能够锻炼设计较复杂算法的思维，我对这个问题进行了较深入的分析思考，得出了几种复杂度不同算法，并给出了分析和证明。

一，    最长递增子序列问题的描述

设L=<a₁,a₂,…,a_n>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<a_K1,a_k2,…,a_km>，其中k₁<k₂<…<k_m且a_K1<a_k2<…<a_km。求最大的m值。

二，    第一种算法：转化为LCS问题求解

设序列X=<b₁,b₂,…,b_n>是对序列L=<a₁,a₂,…,a_n>按递增排好序的序列。那么显然X与L的最长公共子序列即为L的最长递增子序列。这样就把求最长递增子序列的问题转化为求最长公共子序列问题LCS了。

最长公共子序列问题用动态规划的算法可解。设Li=< a₁,a₂,…,a_i>,Xj=< b₁,b₂,…,b_j>，它们分别为L和X的子序列。令C[i,j]为Li与Xj的最长公共子序列的长度。

这可以用时间复杂度为O(n²)的算法求解，由于这个算法上课时讲过，所以具体代码在此略去。求最长递增子序列的算法时间复杂度由排序所用的O(nlogn)的时间加上求LCS的O(n²)的时间，算法的最坏时间复杂度为O(nlogn)＋O(n²)＝O(n²)。

三，    第二种算法：动态规划法

设f(i)表示L中以a_i为末元素的最长递增子序列的长度。则有如下的递推方程：

这个递推方程的意思是，在求以a_i为末元素的最长递增子序列时，找到所有序号在L前面且小于a_i的元素a_j，即j<i且a_j<a_i。如果这样的元素存在，那么对所有a_j,都有一个以a_j为末元素的最长递增子序列的长度f(j)，把其中最大的f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以a_i为末元素的最长递增子序列，等于以使f(j)最大的那个a_j为末元素的递增子序列最末再加上a_i；如果这样的元素不存在，那么a_i自身构成一个长度为1的以a_i为末元素的递增子序列。

//动态规划之最长递增子序列

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>


using namespace std;

int longestIncSub(vector<int>& vec,int length[])
{
	int len = vec.size();
	length[0] = 1;
	for (int i = 1; i < len; i++)
	{
		length[i] = 1;
		for (int j = 0; j < i; j++)
		{
			if (vec[i]>vec[j] && length[j]>length[i] - 1)
				length[i] = length[j] + 1;
		}
	}
	int max = 0;
	for (int i = 0; i < len; i++)
	{
		if (length[i]>max)
			max = length[i];
	}
	return max;
}

//整数处理  
int LCS_LENGTH_INT(vector<int>& vec1, vector<int>& vec2, int c[][100], int b[][100])
{
	int m = vec1.size();
	int n = vec2.size();
	if ((m == 0) || (n == 0))  return 0;
	for (int i = 1; i < m; i++)
		c[i][0] = 0;
	for (int i = 1; i < n; i++)
		c[0][i] = 0;
	c[0][0] = 0;
	for (int i = 1; i <= m; i++)
		for (int j = 1; j <= n; j++)
			if (vec1[i - 1] == vec2[j - 1])
			{
				c[i][j] = c[i - 1][j - 1] + 1;
				b[i][j] = 1;
			}
			else if (c[i - 1][j] >= c[i][j - 1])
			{
				c[i][j] = c[i - 1][j];
				b[i][j] = 2;
			}
			else
			{
				c[i][j] = c[i][j - 1];
				b[i][j] = 3;
			}
			/*cout << "计算最优值效果图如下所示：" << endl;
			for (int i = 0; i <= m; i++)
			{
				for (int j = 0; j <= n; j++)
				{
					cout << c[i][j] << " ";
				}
				cout << endl;
			}*/
			return c[m][n];
}

int main()
{
	//整数处理
	vector<int> vec1 = { 1, 3, 5, 2, 4, 6, 7, 8 };
	
	int length[100] = {0};
	cout << longestIncSub(vec1,length) << endl;

	int c[100][100] = { 0 };
	int b[100][100] = { 0 };
	vector<int> vec2(vec1.begin(), vec1.end());
	sort(vec2.begin(), vec2.end());
	cout << LCS_LENGTH_INT(vec1, vec2, c, b) << endl;

	system("pause");
	return 0;
}

使用二分查找进行优化

/* 
*问题：求数组中最长递增子序列 
*写一个时间复杂度尽可能低的程序，求一个一维数组（N个元素）中的最长递增子序列的长度。 
*例如：在序列1，-1,2，-3,4，-5,6，-7中，其最长的递增子序列为1,2,4,6,最长递增子序列 
*的长度为4。 
*求解思路：使用动态规划+二分查找算法 时间复杂度O(nlog(n)) 
*/  
#include <cstdio>  
#include <iostream>  
  
using namespace std;  
  
int LIS(int *array,int len)  
{  
    int *LIS = new int[len];//LIS数组中存储的是 递增子序列中最大值最小的子序列的最后一个元素（最大元素）在array中的位置  
    int left,mid,right;  
    int max=1;  
    LIS[0]=array[0];  
    for(int i = 1;i < len;++i)  
    {  
        left = 0;  
        right = max;  
        while(left <=right)  
        {  
            mid = (left+right)/2;  
            if(LIS[mid] < array[i])  
                left = mid +1;  
            else  
                right = mid -1;  
        }  
        LIS[left] = array[i];//插入  
        if(left > max)  
        {  
            max++;  
        }  
    }  
    delete LIS;  
    return max;  
}  
  
int main(int args,char **argv)  
{  
    int array[] = {1,-1,2,-3,4,-5,6,-7};  
    int len = sizeof(array)/sizeof(int);  
    int res = LIS(array,len);  
    cout<<res<<endl;  
    getchar();  
    return 0;  
}