【网络流24题】最长 k 可重区间集（费用流）

链接：【网络流24题】最长 k 可重区间集

题意：

给定实直线 $L$上 $n$个开区间组成的集合 $I$，和一个正整数 $k$，试设计一个算法，从开区间集合 $I$中选取出开区间集合 $S\subseteq I$，使得在实直线 $L$的任何一点 $x$， $S$中包含点 $x$的开区间个数不超过 $k$。且 $\displaystyle\sum_{z\in S}|z|$达到最大。这样的集合 $S$称为开区间集合 $I$的最长 $k$可重区间集。 $\displaystyle\sum_{z\in S}|z|$称为最长 $k$可重区间集的长度。

对于给定的开区间集合 $I$和正整数 $k$，计算开区间集合 $S$的最长 $k$可重区间集的长度。

---

分析：

读入数据，先离散化，可以得到区间端点均在 $1\sim m$之间

先建立一个数轴，从 $1$开始，直到 $m$，连边 $i\rarr i+1$，容量定为 $\infin$，费用定为 $0$；

对于给定的开区间 $(L,R)$，连边 $L\rarr R$，容量定为 $1$，费用即为长度 $R-L$；

对于源点，连边 $s\rarr 1$，容量定为 $k$，费用为 $0$；
对于汇点，连边 $m\rarr t$，容量为 $\infin$，费用为 $0$。

这样只有带有费用的 $L\rarr R$连边才会对答案有贡献，可以发现，对于有交集的 $x$个区间，若同时选中（同时有流量通过），那么允许通过的最大流量即为 $x$， 所以只要 $s\rarr 1$连边限流为 $k$，就保证了这是最多 $k$可重。

所以求最大费用最大流即可，将费用转为负，跑一遍费用流。

---

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF=0x3f3f3f3f;
const int maxn=1e5+10;
int s=0,t=maxn-1;
int head[maxn],cnt;
struct edge
{
    int w;    //边的流量（残量）
    int c;    //边的每单位花费
    int to;
    int next;
}e[maxn];
void add_edge(int u,int v,int w,int c)
{
    e[cnt].w=w;
    e[cnt].c=c;
    e[cnt].to=v;
    e[cnt].next=head[u];
    head[u]=cnt;
    cnt++;
    e[cnt].w=0;        //有些图是需要建立双向边，则反向边的初始残量不为0
    e[cnt].c=(-1)*c;   //反向边的花费是 -c
    e[cnt].to=u;
    e[cnt].next=head[v];
    head[v]=cnt;
    cnt++;
}
int pre[maxn];    //记录路径
int flow[maxn];   //记录到达该点的最大流量
int last[maxn];   //路径上，以该点结束的边（便于找到v对应的边,更新残量）
bool SPFA()       //SPFA算法，找到总的每单位花费最小的增广路
{
    bool inq[maxn];     //记录是否在队列中
    int cost[maxn];     //记录总的每单位花费
    memset(pre,-1,sizeof(pre));
    memset(inq,false,sizeof(inq));
    memset(cost,0x3f,sizeof(cost));    //赋初值为INF
    queue<int> q;
    q.push(s);
    flow[s]=INF;        //流入源点s最大流量为INF
    inq[s]=true;
    cost[s]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        inq[u]=false;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].w>0&&cost[u]+e[i].c<cost[v])    //可达&&花费更小
            {
                cost[v]=cost[u]+e[i].c;
                pre[v]=u;
                last[v]=i;
                flow[v]=min(flow[u],e[i].w);
                if(!inq[v])       //若v不在队列q中在中，则入列
                {
                    inq[v]=true;
                    q.push(v);
                }
            }
        }
    }
    return pre[t]!=-1;  //pre[t]!=-1说明t可达
}
int max_flow,min_cost;
void min_cost_flow()
{
    max_flow=min_cost=0;
    while(SPFA())
    {
        for(int i=t;i!=s;i=pre[i])     //利用pre数组从t向s搜索
        {
            e[last[i]].w-=flow[t];     //同时更新残量
            e[last[i]^1].w+=flow[t];
            min_cost+=e[last[i]].c*flow[t];   //统计花费，即各边每单位花费*最大流
        }
        max_flow+=flow[t];             //统计最大流量
    }
}
int n,k,L[maxn],R[maxn],X[maxn],m;
void pre_work()
{
    sort(X+1,X+2*n+1);
    m=unique(X+1,X+2*n+1)-(X+1);
    for(int i=1;i<=n;i++)
    {
        L[i]=lower_bound(X+1,X+m+1,L[i])-X;
        R[i]=lower_bound(X+1,X+m+1,R[i])-X;
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    cnt=0;
    scanf("%d %d",&n,&k);
    for(int i=1;i<=n;i++)
    {
        scanf("%d %d",&L[i],&R[i]);
        if(L[i]>R[i])
            swap(L[i],R[i]);
        X[2*i-1]=L[i];
        X[2*i]=R[i];
    }
    pre_work();
    for(int i=2;i<=m;i++)
        add_edge(i-1,i,INF,0);
    add_edge(s,1,k,0);
    add_edge(m,t,INF,0);
    for(int i=1;i<=n;i++)
        add_edge(L[i],R[i],1,-(X[R[i]]-X[L[i]]));   //费用为原长度的负数
    min_cost_flow();
    printf("%d\n",-min_cost);
    return 0;
}