bzoj5185 [Usaco2018 Jan]Lifeguards（dp+单调队列优化）

真是太神了orz
我们先贪心地把被包含的线段删掉，把剩下的线段按左端点排序，这样的话右端点显然也是有序的。

设dp[i][k],表示前i个线段,删了k个,且必须保留i线段的最大覆盖长度。枚举上一个线段的位置j，那么我们有转移$dp[i][k]=max\{dp[j][k-(i-j-1)]+w(i,j)\}$
w(i,j)表示把线段i接在线段j后面增加的长度。 这样的复杂度是$O(nk^2)$的，需要优化。

我们发现如果dp[x][y]能够转移到dp[i][j]，则有j=y+i-x-1，即x-y=i-j-1.因此我们在转移dp[i][j]时，所有的决策就是满足x-y=i-j-1的dp[x][y]，并且分成两类：
1、线段x，i不相交，则w(i,j)=len[i]，我们只需维护所有不相交的最大的dp[x][y]即可。
2、线段x，i相交，则贡献为dp[x][y]+b[i].r-b[x].r，我们维护dp[x][y]-b[x].r的最大值即可。
我们用n个单调队列来维护即可。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;
#define inf 0x3f3f3f3f
#define ll long long
#define N 100010
#define pa pair<int,int>
inline char gc(){
    static char buf[1<<16],*S,*T;
    if(S==T){T=(S=buf)+fread(buf,1,1<<16,stdin);if(T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0,f=1;char ch=gc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=gc();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=gc();
    return x*f;
}
int n,K,dp[N][110];//dp[i][k],前i个区间,删了k个,且必须保留i区间的最大覆盖长度 
struct interval{
    int l,r;
}a[N],b[N];
inline bool cmp(interval a,interval b){return a.l==b.l?a.r>b.r:a.l<b.l;}
deque<pa>q[N];
int mx[N];//用单调队列维护相交情况的最优决策,用mx记录不相交情况的最优决策
int main(){
//  freopen("a.in","r",stdin);
    n=read();K=read();
    for(int i=1;i<=n;++i) a[i].l=read(),a[i].r=read();
    sort(a+1,a+n+1,cmp);int mxr=0,tot=0;
    for(int i=1;i<=n;++i){
        if(a[i].r>mxr) b[++tot]=a[i],mxr=a[i].r;
        else K--;
    }if(K<0) K=0;n=tot;
    for(int i=1;i<=n;++i){
        for(int j=0;j<=K;++j){
            if(j>=i) break;int id=i-j-1;
            while(!q[id].empty()&&b[q[id].front().second].r<=b[i].l){//不相交了就弹出来
                int x=q[id].front().second;q[id].pop_front();
                mx[id]=max(mx[id],dp[x][x-id]);
            }dp[i][j]=max(dp[i][j],mx[id]+b[i].r-b[i].l);
            if(!q[id].empty()) dp[i][j]=max(dp[i][j],q[id].front().first+b[i].r);
            id=i-j;int val=dp[i][j]-b[i].r;
            while(!q[id].empty()&&q[id].back().first<=val) q[id].pop_back();
            q[id].push_back(make_pair(val,i));
        }
    }int ans=0;
    for(int i=1;i<=n;++i)
        if(K-(n-i)>=0) ans=max(ans,dp[i][K-(n-i)]);
    printf("%d\n",ans);
    return 0;
}