「网络流24题」「LuoguP3358」 最长k可重区间集问题（费用流

题目描述

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

输入输出格式

输入格式：

的第 1 行有 2 个正整数 n和 k，分别表示开区间的个数和开区间的可重迭数。接下来的 n行，每行有 2 个整数，表示开区间的左右端点坐标。

输出格式：

将计算出的最长 k可重区间集的长度输出

输入输出样例

输入样例#1：
复制

4 2
1 7
6 8
7 10
9 13 

输出样例#1： 复制

15

说明

对于100%的数据，1<=n<=500，1<=k<=3

题解

建图：从$S$往$L$左端点连容量为k，费用为0；

从$L$上每个点$i$往点$i+1$连容量为INF，费用为0；

从$L$右端点往$T$连容量INF，费用为0。

>然后从每个区间的左端点往右端点连边，容量为1，费用为右端点$-$左端点（这道题区间长度的定义是右端点$-$左端点

然后跑最大费用最大流就行啦～

这样跑出来的费用会尽量大，而因为S处控制了流量，最大流就是k。

答案就是费用。

然后最大费用最大流就是把费用存负，跑最小费用最大流，输出答案的时候再取反就行了。

然后这道题长度没个范围，所以还要搞个离散。

 /*
     qwerta
     P3358 最长k可重区间集问题
     Accepted
     100
     代码 C++，2.16KB
     提交时间 2018-10-09 18:19:08
     耗时/内存
     31ms, 936KB
 */
 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 #include<queue>
 using namespace std;
 const int INF=2e9;
 struct emm{
     int e,f,v,c;
 }a[];
 int h[];
 int tot=;
 void con(int x,int y,int v,int c)
 {
     a[++tot].f=h[x];
     h[x]=tot;
     a[tot].e=y;
     a[tot].v=v;
     a[tot].c=c;
     a[++tot].f=h[y];
     h[y]=tot;
     a[tot].e=x;
     a[tot].c=-c;
     return;
 }
 struct ahh{
     int l,r;
 }b[];
 int ls[];
 int s,t;
 queue<int>q;
 bool sf[];
 int dis[];
 inline bool spfa()
 {
     memset(sf,,sizeof(sf));
     memset(dis,,sizeof(dis));
     sf[s]=;dis[s]=;q.push(s);
     while(!q.empty())
     {
         int x=q.front();q.pop();
         for(int i=h[x];i;i=a[i].f)
         if(dis[a[i].e]>dis[x]+a[i].c&&a[i].v)
         {
             dis[a[i].e]=dis[x]+a[i].c;
             if(!sf[a[i].e])
             {
                 sf[a[i].e]=;
                 q.push(a[i].e);
             }
         }
         sf[x]=;
     }
     return dis[t]<INF;
 }
 long long ans=;
 int dfs(int x,int al)
 {
     sf[x]=;
     if(x==t||!al)return al;
     int fl=;
     for(int i=h[x];i;i=a[i].f)
     if(dis[a[i].e]==dis[x]+a[i].c&&a[i].v&&!sf[a[i].e])
     {
         int f=dfs(a[i].e,min(al,a[i].v));
         if(f)
         {
             fl+=f;
             al-=f;
             ans+=f*a[i].c;
             a[i].v-=f;
             a[i^].v+=f;
             if(!al)break;
         }
     }
     if(!fl)dis[x]=-INF;
     return fl;
 }
 int main()
 {
     //freopen("a.in","r",stdin);
     int n,k;
     scanf("%d%d",&n,&k);
     int tol=;
     for(int i=;i<=n;++i)
     {
         scanf("%d%d",&b[i].l,&b[i].r);
         ls[++tol]=b[i].l;
         ls[++tol]=b[i].r;
     }
     //离散
     sort(ls+,ls+tol+);
     int len=(unique(ls+,ls+tol+)-ls)-;//用unique去重
     for(int i=;i<=n;++i)
     {
         int ll=lower_bound(ls+,ls+len+,b[i].l)-ls;
         int rr=lower_bound(ls+,ls+len+,b[i].r)-ls;
         con(ll,rr,,-(b[i].r-b[i].l));//建边
     }
     //
     s=,t=len+;
     for(int i=;i<len;++i)
     con(i,i+,INF,);
     con(s,,k,);
     con(len,t,INF,);
     //
     while(spfa())
     {
         sf[t]=;
         while(sf[t])
         {
             memset(sf,,sizeof(sf));
             dfs(s,INF);
         }
     }
     cout<<-ans;//输出再取个负就好了
     return ;
 }