BZOJ1986: [USACO2004 Dec] Dividing the Path 划区灌溉

L<=1000000的土地上用长度在2*A~2*B的线段覆盖所有点，且给定n<=1000个区间，每个区间上只允许有一条线段，求最少多少线段，无解-1。

f[i]表示填前i个土地最少线段，f(i)=f(j)+1，2*A<=i-j<=2*B，用个单调队列就行。注意区间是左闭右开。

至于那些坏区间，如果某个状态在覆盖了该点的区间的最远的右端点，那是合法的，否则一旦它被覆盖就是不合法状态。

为了处理这种情况，将区间按左端点排序，走到一个点时，若该点满足上面的情况，那就说明有一些区间的左端点<=i，把这些区间的右端点取个最大值来比较即可。出现这种情况后，把当前状态，以及当前状态到最远被覆盖区间右端点这些状态全部变成inf，然后i跳到那个右端点就可以做了。

不过，单调队列的节点添加不稳定，因此记个“单调队列加到哪里了”，这样就不怕跳来跳去的i了。

 #include<stdio.h>
 #include<string.h>
 #include<stdlib.h>
 #include<algorithm>
 #include<iostream>
 using namespace std;

 int n,L,A,B;
 #define maxn 1000011
 struct Cow
 {
     int l,r;
     bool operator < (const Cow &b) const {return l<b.l;}
 }a[maxn];
 int f[maxn],que[maxn],head,tail;
 const int inf=0x3f3f3f3f;
 int main()
 {
     scanf("%d%d%d%d",&n,&L,&A,&B);
     for (int i=;i<=n;i++)
         scanf("%d%d",&a[i].l,&a[i].r),a[i].l++;
     sort(a+,a++n);
     head=tail=;
     int last=,k=;
     if (L&) puts("-1");
     else
     {
         for (int i=;i<=L;i+=)
         {
             while (head<tail && que[head]<i-*B) head++;
             for (int j=last;j<=i-*A;j+=)
             {
                 while (head<tail && f[que[tail-]]>=f[j]) tail--;
                 que[tail++]=j;
             }
             last=max(last,i-*A+);
             int far=;
             while (k<=n && i>=a[k].l)
             {
                 far=max(far,a[k].r);
                 k++;
             }
             if (i<far)
             {
                 int tmp=((far&)?far+:far)-;
                 for (;i<tmp;i+=) f[i]=inf;f[i]=inf;
                 last=max(last,i-*B+);
                 continue;
             }
             if (head<tail) f[i]=f[que[head]]+;
             else f[i]=inf;
         }
         printf(f[L]>=inf?"-1\n":"%d\n",f[L]);
     }
     return ;
 }