[LIS] 动态规划及其简单优化

{

好久不写文章了

前些日子 在搞联赛 再加上写的都是DP题

自己还没掌握 所以不好写

这次把比较基础的LIS问题写写

}

 

动态规划

Dynamic Programming

简称DP 是解决 决策过程(decision process)最优化  的方法

本文结合一个简单的例子探讨DP的简单优化方法

LIS问题 Longest Increasing Subsequence

这个问题的变种很多 为讨论方便

我们下面的LIS问题 都是指最长不下降子序列的问题

譬如 对于一个序列{1 2 3 3 5 4 6 2}

{1 2 3} {1 5 6} {1 2 2} {1 2 3 3 5 6}

都是它的不下降子序列 其中最后一个是最长的不下降子序列

 

一.经典DP——朴素做法

由于是经典例子 很多人都知道解决这个问题的DP方程

Opt[i]=MAX{Opt[j]}+1 (A[i]>=A[j],1<=j<i)

也很好理解 不再赘述

给出O(N^2)的代码 感觉常数方面做的很好

N最大可以到12000左右

 

LIS-O(N*N)
//LIS N^2 DP
//16~05 2010-11-26
const maxn=100000; {Max_N=12000,Time Limit=1s}
var i,j,n,ans:longint;
opt,a:
array[1..maxn]of longint;
begin
assign(input,
'lis.in'); reset(input);
assign(output,
'lis3.out'); rewrite(output);
readln(n);
for i:=1 to n do
read(a[i]);
readln;
opt[
1]:=1;
for i:=2 to n do
begin
for j:=1 to i-1 do
if (a[i]>=a[j])and(opt[j]>opt[i])
then opt[i]:=opt[j];
inc(opt[i]);
if opt[i]>ans
then ans:=opt[i];
end;
writeln(ans);
close(input); close(output);
end.

 

 

二.数据结构优化——通用做法

这个朴素的实现 时间复杂度是O(N^2)

我们还可以把它优化到O(NLog2N)

最好想的思路是优化MAX{}的决策

对于要从第一关键字A[]满足小于等于一个数的所有节点中

取得一个第二关键字Opt[]最大的节点

我们考虑运用平衡二叉树优化这种限制范围最大值操作 使单次决策复杂度达到O(Log2N)

这个思路比较通用 很多动态规划都可以用数据结构优化

具体考虑限制范围最大值操作的做法

我们选用严格平衡的平衡树来解决问题以提高效率 我选用了SBT

节点的排序关键字就是A[] 为记录第二关键字 我们给每个节点多记录一个域F[]

记录以当前节点为根的子树的最大第二关键字

SBT在插入和旋转的同时要注意同时更新F[]

可以对平衡二叉树的查询操作Find(x,v)加以修改得到我们需要的操作

先看图

如果最下面的红点是我们普通查询得到的节点的话

这张图描述了从根节点到所查节点的一条路径

不难发现 所有红色节点红色子树的A[]都是小于等于所查节点的A[]值的

而所有蓝色节点蓝色子树都不满足这个限制条件

还可以发现红色部分就是在路径上接下来向右走的节点及其左子树

比较红色节点的Opt[]值和红色子树的F[]值取最大即可

给出平衡树优化过的代码

 

LIS-SBT
//LIS NLogN DP
//Based On SBT
//19~02 2010-11-26
const maxn=300000; {Max_N=12w,Time Limit=1s}
oo
=maxlongint;
var l,r,f,s,n,a,opt:array[0..maxn]of longint;
k,i,ans,t,tt:longint;
procedure update(x:longint);
var temp:longint;
begin
f[x]:
=opt[n[x]];
if f[l[x]]>f[r[x]]
then temp:=f[l[x]]
else temp:=f[r[x]];
if temp>f[x] then f[x]:=temp;
end;
procedure zig(var x:longint);
var y:longint;
begin
y:
=l[x]; l[x]:=r[y]; r[y]:=x;
s[y]:
=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
f[y]:
=f[x]; update(x);
x:
=y;
end;
procedure zag(var x:longint);
var y:longint;
begin
y:
=r[x]; r[x]:=l[y]; l[y]:=x;
s[y]:
=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
f[y]:
=f[x]; update(x);
x:
=y;
end;
procedure maintain(var x:longint; flag:boolean);
begin
if flag
then if s[l[l[x]]]>s[r[x]] then zig(x)
else if s[r[l[x]]]>s[r[x]]
then begin zag(l[x]); zig(x); end
else exit
else if s[r[r[x]]]>s[l[x]] then zag(x)
else if s[l[r[x]]]>s[l[x]]
then begin zig(r[x]); zag(x); end
else exit;
maintain(l[x],true); maintain(r[x],false);
maintain(x,true); maintain(x,false);
end;
procedure insert(var x:longint; i:longint);
begin
if x=0
then begin
inc(tt); x:
=tt;
n[x]:
=i; s[x]:=1;
f[x]:
=opt[i];
end
else begin
inc(s[x]);
if a[i]<=a[n[x]]
then insert(l[x],i)
else insert(r[x],i);
update(x);
maintain(x,a[i]
<=a[n[x]]);
end;
end;
function find(x,i:longint):longint;
var temp:longint;
begin
temp:
=0;
while x<>0 do
if a[i]<a[n[x]]
then x:=l[x]
else begin
if f[l[x]]>temp
then temp:=f[l[x]];
if opt[n[x]]>temp
then temp:=opt[n[x]];
if a[i]=a[n[x]] then break;
x:
=r[x];
end;
find:
=temp;
end;
begin
assign(input,
'lis.in'); reset(input);
assign(output,
'lis2.out'); rewrite(output);
readln(k);
for i:=1 to k do
read(a[i]);
readln;
opt[
1]:=1;
insert(t,
1);
for i:=2 to k do
begin
opt[i]:
=find(t,i)+1;
if opt[i]>ans
then ans:=opt[i];
insert(t,i);
end;
writeln(ans);
close(input); close(output);
end.

 

事实上 运用Splay Tree的Splay操作可以写出更为简洁的代码

不过常数也会随之变大

 

三.单调性优化——最好的做法

上面第二种做法的复杂度已经达到O(NLog2N)

但是常数比较大 只能做到N=12w左右

下面介绍基于单调性的二分查找优化的决策方法

首先对于两个Opt[]相同的决策 我们应当选择A[]较小的 位置更靠前的

于是我们新增数组C[1..ans] 且C[i]记录长度为i的不降子序列A[]值最小为多少 A[]相等取最靠前的

每次只要从C里面查找一个满足条件的节点转移即可

注意到C具有单调性 (证明用反证法+LIS的定义即可)

再加上二分查找即可

给出这种实现的代码 常数比平衡树优化有优势 N=100w没问题

 

LIS-Dichotomy
//LIS NLogN DP
//Based On Dichotomy
//16~35 2010-11-26
const maxn=1000000; {Max_N=100w,Time Limit 1s}
oo
=maxlongint;
var opt,a,c:array[0..maxn]of longint;
n,i,k,l,r,ans:longint;
begin
assign(input,
'lis.in'); reset(input);
assign(output,
'lis1.out'); rewrite(output);
readln(n);
for i:=1 to n do
read(a[i]);
readln;
ans:
=1;
opt[
1]:=1; c[1]:=1;
for i:=2 to n do
begin
l:
=0; r:=ans;
while l<r do
begin
k:
=(l+r+1)shr 1;
if a[c[k]]<=a[i]
then l:=k
else r:=k-1;
end;
opt[i]:
=l+1;
if (c[opt[i]]=0)or(a[i]<a[c[opt[i]]])
then c[opt[i]]:=i;
if opt[i]>ans
then ans:=opt[i];
end;
writeln(ans);
close(input); close(output);
end.

 

本文只是对LIS问题的基本优化作一个简单介绍

如有不足 欢迎指正

 

BOB HAN原创 转载请注明出处http://www.cnblogs.com/Booble/

posted on 2010-11-27 10:27  Master_Chivu  阅读(6709)  评论(0编辑  收藏  举报

导航