POJ2373 Dividing the Path——动态规划＋单调队列优化

利用单调队列进行动态规划。

状态转移方程很容易写出来的：

f[i]=Min{f[j]}+1(i-2*b<=j<=i-2*a)

这样，时间复杂度最坏情况下是O(n^2)的，对于n<=1000000的数据来说，程序根本无法承受

怎么办呢？单调队列很强大！

维护一个单调队列，队列里存的是按符合条件的f数组内值严格单调递增的下标值。很显然，利用队首元素就可以直接转移了。

队首元素要满足的条件很简单嘛，i-2*b<=seq[h]<=1-2*a

中间有一些小小的技巧，比如说，计算每个f值的时候，不是计算出来就将它插入到队列里，而是在计算f[i+2*a]之前把它插入队列中。

不过说了，CODE：

Program POJ2373;//By_Poetshy
Const
maxn=1000006;
Var
i,m,n,maxinum,mininum,j				:Longint;
f									:Array[0..maxn]of Longint;
b,e									:Longint;
seq									:Array[0..maxn*2]of Longint;
flag								:Array[0..maxn]of Boolean;
h,t									:Longint;
p									:Longint;

BEGIN
readln(n,m);
readln(mininum,maxinum);
fillchar(flag,sizeof(flag),1);
for i:=1 to n do
begin
readln(b,e);
for j:=b+1 to e-1 do flag[j]:=false;
end;
fillchar(f,sizeof(f),127);
f[0]:=0;h:=0;t:=0;
for i:=mininum to (m >> 1) do
begin
p:=i << 1;
dec(p,2*mininum);
if (p>=0)and(f[p]<(maxlongint>>2)) then
begin
while (h<=t)and(f[seq[t]]>=f[p])do dec(t);
inc(t);
seq[t]:=p;
end;
inc(p,2*mininum);
f[p]:=maxlongint;
while (h<=t)and(seq[h]<p-2*maxinum)do inc(h);
if (h>t)or(not flag[p]) then continue;
f[p]:=f[seq[h]]+1;
end;
if f[m]<(maxlongint>>2) then writeln(f[m])else writeln(-1);
END.