动态规划6：最长递增子序列问题

一、最长递增子序列问题

1、动态规划法

设LIS[i]保存的是0到i（包括i）的最长递增子序列的元素个数

则LIS[i]=max{1,LIS[j]+1}0<=j<i

时间复杂度O(n^2)

//最长递增子序列
#include <iostream>
#include <algorithm>
#include <string>
#include <functional>
using namespace std;

#define MAX 100
#define len 10
int main()
{
int LIS[MAX]={0};
int arr[len];
int maxC=INT_MIN;
generate(arr,arr+len,[](){return rand()%100;});
for_each(arr,arr+len,[](int i){cout<<i<<" ";});
cout<<endl;

for(int i = 0;i < len;++i)
{
LIS[i] = 1;
for(int j = 0; j < i;++j)
{
if(arr[i] > arr[j] && LIS[j] + 1 > LIS[i])
{
LIS[i] = LIS[j] + 1;
}
}
maxC=max(maxC,LIS[i]);
}
cout<<maxC<<endl;
return 0;
}

2、还有一种二分法，其实是一种贪心的策略，时间复杂度O(nlogn)

算法演示：

例如有数组arr={2,1,3,5,4}，最长递增序列长度可以看出是3

（1）取得第一个元素为2，LIS[0]=2，长度len=1

（2）取得第二个元素为1，1<2，贪心策略如下：如果2可以构成一个最长递增的序列，则1必然能构成最长递增序列，且1比2有更大的可能性，所以更新LIS[0]=2,len=1

（3）取得第三个元素为3，3>1，所以可以增加序列，此时LIS={0,3}，len=2

（4）取得第四个元素为5，5>3，增加序列，此时LIS={0,3,5}，len=3

（5）取得第五个元素为4，4在3和5之间，运用贪心策略，4比5更可能构成递增序列，所以更新5，有LIS={0,3,4},len=3

结束，输出len

可以看出，LiST中的元素始终是有序序列，所以在查找元素时，采用二分法

注：LIS数组中的元素并不是最长递增序列的解，保存的只是一种临时状态

//最长递增子序列二分法
#include <iostream>
#include <algorithm>
#include <string>
#include <functional>
using namespace std;

#define MAX 100
#define len 10
int main()
{
int LIS[MAX]={0};
int arr[len];

generate(arr,arr+len,[](){return rand()%100;});
for_each(arr,arr+len,[](int i){cout<<i<<" ";});
cout<<endl;

int maxC=1;
LIS[0]=arr[0];
for(int i = 1;i < len;++i)
{
int left = 0;
int right = maxC;
while(left <=right)
{
int mid = (left+right)/2;
if(LIS[mid] < arr[i])
left = mid +1;
else
right = mid -1;
}
LIS[left] = arr[i];//插入
if(left > maxC)
{
maxC++;
}
}
cout<<maxC<<endl;
return 0;
}

二、双端LIS问题

问题描述：

从一列数中筛除尽可能少的数使得从左往右看，这些数是从小到大再从大到小的。（网易）

这里采用动规求解，二分类似

设LIS1[i]保存的是0到i（包括i）递增子序列的元素个数，LIS2[i]保存的n到i（包括i）的递增子序列元素个数

则maxC=max{maxC,LIS1[i]+LIS2[i]-1} PS：因为i在这里算了两遍，所以-1

时间复杂度O(n^2)

//最长递增子序列
#include <iostream>
#include <algorithm>
#include <string>
#include <functional>
using namespace std;

#define MAX 100
#define len 10
int main()
{
int LIS1[MAX]={0};
int LIS2[MAX]={0};
int arr[len];
int maxC=INT_MIN;
generate(arr,arr+len,[](){return rand()%100;});
for_each(arr,arr+len,[](int i){cout<<i<<" ";});
cout<<endl;

for(int i = 0;i < len;++i)
{
LIS1[i] = 1;
for(int j = 0; j < i;++j)
{
if(arr[i] > arr[j] && LIS1[j] + 1 > LIS1[i])
{
LIS1[i] = LIS1[j] + 1;
}
}
}
for(int i = len-1;i >= 0;--i)
{
LIS2[i] = 1;
for(int j = len-1; j > i;--j)
{
if(arr[i] > arr[j] && LIS2[j] + 1 > LIS2[i])
{
LIS2[i] = LIS2[j] + 1;
}
}
maxC = max(maxC,LIS1[i]+LIS2[i]-1);
}
cout<<maxC;
return 0;
}