前言
本篇博客主要介绍了有关最长上升子序列(LIS)的三种DP解决方法,分别是O(n^2)和O(nlogn)(贪心加二分)两种DP
问题介绍
对于一个有序序列
x1,x2,x3,...,xn
x
1
,
x
2
,
x
3
,
.
.
.
,
x
n
我们可以从其中得到一序列
ai1,ai2,ai3,...,aim
a
i
1
,
a
i
2
,
a
i
3
,
.
.
.
,
a
i
m
满足
ai1<ai2<ai3<...<aim
a
i
1
<
a
i
2
<
a
i
3
<
.
.
.
<
a
i
m
且
1≤i1<i2<i3<...<im≤n
1
≤
i
1
<
i
2
<
i
3
<
.
.
.
<
i
m
≤
n
这样的字序列被称为该序列的上升子序列,也称单调递增子序列,而我们目标就是求一个序列中最长的单调递增的子序列。
如对于一有序序列{1,6,2,5,4,2,1,6},{1,5,6}为其一的上升子序列,而{1,2,4,6}就为其最长上升子序列.
求解方法
1. O(n2) O ( n 2 ) 朴素算法
那么既然这是一道DP问题,我们可以发现它具有无后效性和最优子结构,因为它这个序列首先不会改变,而对于它的子序列求出的LIS会也会对答案有贡献。
那么f[i]定义为:以
xi
x
i
结尾的最长上升子序列的长度
我们首先可以发现,单个位置的f[i]肯定为1因为它可以以自己作为一[1,i]的上升子序列
然后我们假设f[1],f[2],…,f[i-1]的值都已求出,而我们的目标就是求f[i]的值.也就是要求状态转移方程式.
我们现在已知道在1~j(1<=j< i)的最长上升子序列,我们的目标就是在一合法的1~j且该子序列的LIS最长的后添加一i,那是不是如果
xj<xi
x
j
<
x
i
就可以进行拼接?也就是转移。那我们就可以得到状态转移方程式;
最后答案就是f[n]
代码
#include<cstdio>
#include<algorithm>
#define LL long long
using namespace std;
int read(){
int f=1,x=0;char s=getchar();
while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
return x*f;
}
#define MAXN 1000
int x[MAXN+5],f[MAXN+5];
int main()
{
int n=read(),ans=1;
for(int i=1;i<=n;i++)
x[i]=read();
for(int i=1;i<=n;i++){
f[i]=1;
for(int j=1;j<=i-1;j++)
if(x[j]<x[i]&&f[j]+1>f[i])
f[i]=f[j]+1;
ans=max(ans,f[i]);
}
printf("%d\n",ans);
return 0;
}
2. O(n⋅logn) O ( n · l o g n ) 贪心+二分优化
我们的状态定义就会变得跟之前的不一样了,但我们还是可以通过刚才的定义来观察一下:
我们对于
i
i
将会找到它之前满足条件的最大的f[j]转移过来也就是长度最大,那其实我们可以来建一个一长度为下标的数组f,我们的目标是每次能直接将low数组中小于i的最大的一个下标直接加1就能得到1~i中以i结尾的最长的LIS,f[i]在这里定义为:
因为这样是一贪心策略,对于一定位置i,当一上升子序列长度一定是,末尾元素越小越利于后面元素的选择
也就是大于等于i的第一个数的下标,同时由于这里i在这里必然小于f[i]还可以顺带更新f[i],我们这样做了过后整个f数组是呈严格上升的,于是我们就能直接二分答案,在这里我们可以直接调用algoriethm里的lower_bound函数,二分一次low数组的时间复杂度的
O(logn)
O
(
l
o
g
n
)
,所以总的时间复杂度是
O(n⋅logn)
O
(
n
·
l
o
g
n
)
来一次完整演示:
这是原数组
首先将f[1]更新
然后发现f[1]还是比当前元素大,继续更新
同上
这里发现2比1大,于是更新了f[2]
同上
这里最后就返回了3
程序写起来也极为简洁.
代码
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int read(){
int f=1,x=0;char s=getchar();
while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
return x*f;
}
#define MAXN 1000
#define INF 0x3f3f3f3f
int a[MAXN+5],dp[MAXN+5];
int main(){
int n=read();
memset(dp,0x3f,sizeof(dp));
for(int i=1;i<=n;i++)
a[i]=read(),*lower_bound(dp+1,dp+n+1,a[i])=a[i];
printf("%d\n",lower_bound(dp+1,dp+n+1,INF)-(dp+1));
return 0;
}