luoguP3358 最长k可重区间集问题（网络流之经典问题）

题目链接

分析：
之前在网络流建图经典建模第3类中介绍过

方法一

按左端点排序所有区间，把每个区间拆分看做两个点$A_i,B_i$（左右端点），建立附加源$S$汇$T$，以及附加顶点$S’$。

• 连接$S$到$S’$一条容量为$K$，费用为0的有向边
• 从$S’$到每个$A_i$连接一条容量为1，费用为0的有向边
• 从每个$B_i$到$T$连接一条容量为1，费用为0的有向边
• 从每个点$A_i$到$B_i$连接一条容量为1，费用为区间长度的有向边
• 对于每个区间$i$的$B_i$与ta右边的不相交的所有区间$j$的$A_j$各连一条容量为1，费用为0的有向边

求最大费用最大流，最大费用流值就是最长k可重区间集的长度

方法二

离散化所有区间的端点，把每个端点看做一个点，建立附加源$S$汇$T$

• 从$S$到顶点1 （最左边顶点）连接一条容量为$K$，费用为0的有向边
• 从顶点2N （最右边顶点）到$T$连接一条容量为K，费用为0的有向边
• 从顶点$i$到顶点$i+1(i+1<=2N)$，连接一条容量为无穷大，费用为0的有向边
• 对于每个区间$[a,b]$，从$a$对应的顶点$i$到$b$对应的顶点$j$连接一条容量为1，费用为区间长度的有向边

求最大费用最大流，最大费用流值就是最长k可重区间集的长度

解释

这个问题可以看做是求$K$条权之和最大的不想交路径，每条路径为一些不相交的区间序列
由于是最大费用流，两条路径之间一定有一些区间相交，可以看做事相交部分重复了2次，而$K$条路经就是最多重复了$K$次
最简单的想法就是把区间排序后，不相交的区间之间连接一条边，由于每个区间只能用一次，所以要拆点，点内限制流量

如果我们改变一下思路，把端点作为网络中的顶点，区间恰恰是特定一些端点之间的边，这样建模的复杂度更小
（可以说，对于数轴上的点，覆盖次数是不会超过区间端点的，所以就只维护端点即可）
方法1的边数是$O(N^2)$的，而方法2的边数是$O(N)$的，可以解决更大规模的问题

方法二code

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>

using namespace std;

const int INF=0x33333333;
const int N=1500;
int n,nn,m,s,t,st[N],tot=0,V[N];
int dis[N],pre[N];
bool in[N];
struct node{
    int x,y,v,c,nxt;
};
node way[N<<1];
struct po{
    int x,y;
};
po a[N];

void add(int u,int w,int z,int cc) {
    tot++;way[tot].x=u;way[tot].y=w;way[tot].v=z;way[tot].c=cc;way[tot].nxt=st[u];st[u]=tot;
    tot++;way[tot].x=w;way[tot].y=u;way[tot].v=0;way[tot].c=-cc;way[tot].nxt=st[w];st[w]=tot;
}

int spfa(int s,int t) {
    queue<int> Q;
    memset(dis,0x33,sizeof(dis));
    memset(pre,0,sizeof(pre));
    memset(in,0,sizeof(in));
    Q.push(s); dis[s]=0; in[s]=1;
    while (!Q.empty()) {
        int now=Q.front(); Q.pop();
        in[now]=0;
        for (int i=st[now];i!=-1;i=way[i].nxt)
            if (way[i].v&&dis[way[i].y]>dis[now]+way[i].c) {
                dis[way[i].y]=dis[now]+way[i].c;
                pre[way[i].y]=i;
                if (!in[way[i].y]) {
                    in[way[i].y]=1;
                    Q.push(way[i].y);
                }
            }
    }
    return dis[t]!=INF;
}

void solve() {
    int ans=0;
    while (spfa(s,t)) {
        int sum=INF;
        for (int i=t;i!=s;i=way[pre[i]].x) sum=min(sum,way[pre[i]].v);
        ans+=sum*dis[t];
        for (int i=t;i!=s;i=way[pre[i]].x)
            way[pre[i]].v-=sum,way[pre[i]^1].v+=sum;
    }
    printf("%d\n",-ans);
}

void build() {
    memset(st,-1,sizeof(st)); tot=-1;
    s=0,t=nn+1;
    for (int i=1;i<=n;i++) {
        int x=lower_bound(V+1,V+1+nn,a[i].x)-V;
        int y=lower_bound(V+1,V+1+nn,a[i].y)-V;
        add(x,y,1,-(a[i].y-a[i].x));
    }
    add(s,1,m,0); add(nn,t,m,0);
    for (int i=1;i<nn;i++) add(i,i+1,INF,0);
}

int main() 
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) {
        scanf("%d%d",&a[i].x,&a[i].y);
        if (a[i].x>a[i].y) swap(a[i].x,a[i].y);
        V[i]=a[i].x; V[i+n]=a[i].y;
    }
    sort(V+1,V+1+n+n);
    nn=unique(V+1,V+1+n+n)-V-1;
    build();
    solve();
    return 0;
}