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

面试经常出现问题：

最大子序列：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=<a1,a2,…,an>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<aK1,ak2,…,akm>，其中k1<k2<…<km且aK1<ak2<…<akm。求最大的m值。

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

设序列X=<b1,b2,…,bn>是对序列L=<a1,a2,…,an>按递增排好序的序列。那么显然X与L的最长公共子序列即为L的最长递增子序列。这样就把求最长递增子序列的问题转化为求最长公共子序列问题LCS了。

最长公共子序列问题用动态规划的算法可解。设Li=< a1,a2,…,ai>,Xj=< b1,b2,…,bj>，它们分别为L和X的子序列。令C[i,j]为Li与Xj的最长公共子序列的长度。

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

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

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

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

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

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

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