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

最新推荐文章于 2020-01-26 17:41:24 发布

墓华

最新推荐文章于 2020-01-26 17:41:24 发布

阅读量225

点赞数

CC 4.0 BY-SA版权

分类专栏： ★水题之路 ★图论 # 【网络流】

本文链接：https://blog.csdn.net/Ratina/article/details/102238488

★水题之路同时被 3 个专栏收录

178 篇文章

订阅专栏

★图论

40 篇文章

订阅专栏

【网络流】

13 篇文章

订阅专栏

该博客介绍了如何使用网络流解决最长 k 可重区间集问题。首先离散化区间，然后建立数轴网络图，通过设置不同边的容量和费用，确保最多选取 k 个区间。最后，通过最大费用最大流算法求解，将费用转负后运行费用流算法得出最优解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

链接：【网络流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;
}