P4890 Never·island（dp）

P4890 Never·island

求门开的最小时间，其实也就是求门关的最大时间。

坐标这么大....显然坐标要离散化

离散化排序后，我们发现x轴被这些点划分成若干条线段$(l,r)$，并且有4种情况

我们用$v[i]$数组表示给队$i$钥匙的贡献

1.左端点为$i$队的起点，右端点为$i$队的终点：显然队$i$钥匙的贡献包括这一段，$v[i]+=r-l$

2.左端点为$i$队的终点，右端点为$j$队的起点：无论如何分配钥匙，这一段都可以关门，于是答案可直接算上$r-l$

3.左端点为$i$队的终点，右端点为$j$队的终点：如果我们给$j$队钥匙，$i$队就可以关门，$v[j]+=r-l$

4.左端点为$i$队的起点，右端点为$j$队的终点：我们只有给$i,j$各一把钥匙，才能算上这一段的贡献

于是我们就在$i,j$之间先连边，边权为$r-l$

蓝后我们又发现，这些点由一些互不相干的链组成。

于是我们按$x轴$从左到右dfs一遍求出dp的优先顺序

最后我们用$f[i][j][0/1]$表示前$i$个点，已给$j$个点钥匙，是否选择了第$i$个（当前）点的最优解

这就是一个二维dp辣

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#define rint register int
using namespace std;
inline int Max(int a,int b){return a>b?a:b;}
inline int Min(int a,int b){return a<b?a:b;}
void read(int &x){
    char c=getchar();x=;
    while(c<''||c>'') c=getchar();
    while(''<=c&&c<='') x=x*+(c^),c=getchar();
}
#define N 4005
int n,m,pos[N],tp,h[N],nxt[N],v[N],sv[N];
int f[N][N][],tot; bool vis[N];
map <int,int> mp;
void dfs(int x){vis[h[++tp]=x]=; if(nxt[x])dfs(nxt[x]);}
int main(){
    read(n);read(m); int l,r,L,R,tn=n<<;
    for(rint i=;i<=n;++i){
        read(l), read(r);
        pos[i]=l, pos[i+n]=r;
        mp[l]=i<<, mp[r]=i<<|;
    }sort(pos+,pos+tn+);//离散化
    for(rint i=;i<tn;++i){
        l=pos[i], r=pos[i+];
        L=mp[l], R=mp[r];
        if((L&)&&(R&)) v[R>>]+=r-l;
        if((L&)&&!(R&)) tot+=r-l;
        if(!(L&)&&!(R&)) v[L>>]+=r-l;
        if(!(L&)&&(R&)){
            if((L>>)==(R>>)) v[L>>]+=r-l;
            else nxt[R>>]=L>>,sv[R>>]=r-l;
        }
    }
    for(rint i=;i<=tn;++i){
        int p=mp[pos[i]];
        if(!(p&)&&!vis[p>>]) dfs(p>>);
    }//dfs确定dp顺序
    memset(f,0xbf,sizeof(f));//-inf
    f[n+][][]=;
    for(rint i=n;i;--i){
        f[i][][]=;
        for(rint j=Min(n-i+,m);j;--j){
            f[i][j][]=Max(f[i+][j][],f[i+][j][]);
            f[i][j][]=Max(f[i+][j-][],f[i+][j-][]+sv[h[i]])+v[h[i]];
        }
    }printf("%d",pos[tn]-pos[]-tot-Max(f[][m][],f[][m][]));
    return ;
}