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.