[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 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 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 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/