luogu4182 [USACO18JAN] Lifeguards P (单调队列优化dp)

显然可以先把被覆盖掉的区间去掉，然后排个序，左、右端点就都是单调的

设f[i][j]表示前i个区间中删掉j个，而且钦定i不能删的最大覆盖长度

（如果不钦定，就要有一个删掉的状态，那我无法确定前面的到底到哪是没删的）

那么有$f[i][j]=max\{f[k][j-(i-k-1)]+R[i]-max(L[i],R[k])\} ,k<i$

稍微理解一下：k是我们下一次钦定要选的，中间的区间就都扔掉，然后有两种情况：k和i重合或不重合，那新增加一个i区间多覆盖的长度就要从i的左端点和k的右端点挑一个较大的减一减

复杂度$O(nk^2)$，显然需要优化

现在我们考虑f[i][j]到底能从哪些状态转移过来

设能转移到f[i][j]的状态是f[k][l]，然后根据上面的式子，我们发现k-l=i-j-1 ，就是说当i和j固定时，l只和k有关

而且在这些状态中，对于一些比较小的k，它是和i区间不相交的，也就是它的贡献只和它的f有关

那我们就在这些k中先取一个最大的f[k][l]，然后加上i区间的长度，作为一个可选的答案

对于剩下那些k，它的贡献就变成了f[k][l]-R[k]，也是和i无关的

那我们就可以用一些单调队列，每个单调队列q[i]维护k-l=i的k,l的最大贡献

我们每次求f[i][j]的时候，先把q[i-j-1]中队头表示的区间不与i相交的踢出去，然后这个要求的最大值就是队头，然后再把f[i][j]加到q[i-j]里就完事了

为了方便统计答案，我们增加一个从1e9到1e9的区间，然后钦定它要选就可以了

 #include<bits/stdc++.h>
 #define pa pair<int,int>
 #define ll long long
 using namespace std;
 const int maxn=,maxk=;

 inline ll rd(){
     ll x=;char c=getchar();int neg=;
     while(c<''||c>''){if(c=='-') neg=-;c=getchar();}
     while(c>=''&&c<='') x=x*+c-'',c=getchar();
     return x*neg;
 }

 struct POS{
     int l,r;
 }pos[maxn],p[maxn];
 int N,K;
 int f[maxn][maxk];
 int que[maxn][maxk],qh[maxn],qt[maxn],ma[maxn];

 inline bool cmp(POS a,POS b){
     return a.l==b.l?a.r>b.r:a.l<b.l;
 }

 int main(){
     int i,j,k;
     //freopen("testdata.in","r",stdin);
     N=rd(),K=rd();
     for(i=;i<=N;i++){
         pos[i].l=rd(),pos[i].r=rd();
     }sort(pos+,pos+N+,cmp);
     int mm=;
     for(i=,j=;i<=N;i++){
         if(mm<pos[i].r) p[++j]=pos[i],mm=pos[i].r;
     }K-=N-j;N=j;
     if(K<=){
         int ans=;
         for(i=;i<=N;i++){
             ans+=max(,p[i].r-max(p[i-].r,p[i].l));
         }printf("%d\n",ans);
     }else{
         p[N+].l=1e9,p[N+].r=1e9;N++;
         for(i=;i<=N;i++){
             for(j=;j<=min(i-,K);j++){
                 int ii=i-j-;
                 while(qh[ii]<qt[ii]&&p[que[ii][qh[ii]]].r<=p[i].l){
                     ma[ii]=max(ma[ii],f[que[ii][qh[ii]]][que[ii][qh[ii]]-ii]);qh[ii]++;
                 }int hh=que[ii][qh[ii]];
                 f[i][j]=max(ma[ii]+p[i].r-p[i].l,f[hh][hh-ii]+p[i].r-max(p[hh].r,p[i].l));
                 ii=i-j;int qq=que[ii][qt[ii]];
                 while(qh[ii]<qt[ii]&&f[qq][qq-ii]-p[qq].r<=f[i][j]-p[i].r){
                     qt[ii]--;qq=que[ii][qt[ii]];
                 }que[ii][++qt[ii]]=i;if(!qh[ii]) qh[ii]++;
             }
         }
         printf("%d\n",f[N][K]);
     }
     return ;
 }