[網絡流24題（3/24）] 最長k可重區間集問題（洛谷P3358）

傳送門

分析：

這是一個很是經典的費用流的模型。

首先由於題目中限制咱們每一個點最多隻能選取\(k\)次，所以，由於會有\(k\)次的限制，所以咱們不妨用最大流進行限流，即咱們將源點拆成兩個點\(S_0\)以及\(S_1\)，從\(S_0\)點向\(S_1\)點連一條流量爲k，費用爲\(0\)的邊。表明最多有大小爲\(k\)的流通過全部的邊。這樣咱們就可以保證，最終經過終點的流量被限死在k，而又由於要求的是最大價值，所以咱們須要求的是最大費用最大流，這個咱們只須要將價值變成負數。

由於最多會有\(n\)對區間，\(2n\)個點，所以咱們考慮將着\(2n\)個點離散化。離散化後，咱們將這離散化後的\(2n\)個點中離散化後相鄰的點都連一條流量爲\(inf\)，費用爲\(0\)的邊，表明相鄰的點均可以互相到達。以後咱們再將以前的\(n\)對區間的每個區間\([l,r]\)，將點\(l\)和點\(r\)之間連一條費用爲\(-len_{lr}\)，流量爲\(1\)的邊，表明若是要選取當前區間，則將會花費\(-len{lr}\)的費用以及區間中的全部點都將佔用\(1\)點流量。創建好圖以後，咱們跑一邊最小費用最大流以後取最小費用的相反數便可。

代碼：

// luogu-judger-enable-o2
#include <bits/stdc++.h>
#define maxn 1006
#define maxm 10005
using namespace std;
int head[maxn],cnt=0;
int dis[maxn],vis[maxn],sp,ep,maxflow,cost;
int n,k;
const int INF=0x3f3f3f3f;
struct Node{
    int to,next,val,cost;
}q[maxm<<1];
int L[maxn],R[maxn];
vector<int>vec;
void init(){
    memset(head,-1, sizeof(head));
    cnt=2;
    maxflow=cost=0;
}
void addedge(int from,int to,int val,int cost){
    q[cnt].to=to;
    q[cnt].next=head[from];
    q[cnt].val=val;
    q[cnt].cost=cost;
    head[from]=cnt++;
}
void add_edge(int from,int to,int val,int cost){
    addedge(from,to,val,cost);
    addedge(to,from,0,-cost);
}
bool spfa(){
    memset(vis,0,sizeof(vis));
    memset(dis,0x3f,sizeof(dis));
    dis[sp]=0;
    vis[sp]=1;
    queue<int>que;
    que.push(sp);
    while(!que.empty()){
        int x=que.front();
        que.pop();
        vis[x]=0;
        for(int i=head[x];i!=-1;i=q[i].next){
            int to=q[i].to;
            if(dis[to]>dis[x]+q[i].cost&&q[i].val){
                dis[to]=dis[x]+q[i].cost;
                if(!vis[to]){
                    que.push(to);
                    vis[to]=1;
                }
            }
        }
    }
    return dis[ep]!=0x3f3f3f3f;
}
int dfs(int x,int flow){
    if(x==ep){
        vis[ep]=1;
        maxflow+=flow;
        return flow;
    }//能夠到達t，加流
    int used=0;//該條路徑可用流量
    vis[x]=1;
    for(int i=head[x];i!=-1;i=q[i].next){
        int to=q[i].to;
        if((vis[to]==0||to==ep)&&q[i].val!=0&&dis[to]==dis[x]+q[i].cost){
            int minflow=dfs(to,min(flow-used,q[i].val));
            if(minflow!=0){
                cost+=q[i].cost*minflow;
                q[i].val-=minflow;
                q[i^1].val+=minflow;
                used+=minflow;
            }
            //能夠到達t，加費用，扣流量
            if(used==flow)break;
        }
    }
    return used;
}
int mincostmaxflow(){
    while(spfa()){
        vis[ep]=1;
        while(vis[ep]){
            memset(vis,0,sizeof(vis));
            dfs(sp,INF);
        }
    }
    return maxflow;
}
int main()
{
    scanf("%d%d",&n,&k);
    init();
    for(int i=1;i<=n;i++){
        scanf("%d%d",&L[i],&R[i]);
        if(L[i]>R[i]) swap(L[i],R[i]);
        vec.push_back(L[i]);
        vec.push_back(R[i]);
    }
    sort(vec.begin(),vec.end());
    int sz=vec.size();
    sp=sz+1,ep=sz+2;
    add_edge(sp,1,k,0);
    add_edge(sz,ep,k,0);
    for(int i=1;i<sz;i++) add_edge(i,i+1,k,0);
    for(int i=1;i<=n;i++){
        int l=lower_bound(vec.begin(),vec.end(),L[i])-vec.begin();
        int r=lower_bound(vec.begin(),vec.end(),R[i])-vec.begin();
        add_edge(l+1,r+1,1,vec[l]-vec[r]);
    }
    mincostmaxflow();
    printf("%d\n",-cost);
    return 0;
}