[网络流24题]最长k可重区间集问题（费用流）

题目

传送门

题解

考试的时候想到了费用流的一点东西，但是没有写出来，现在看来建图也挺简单的。
S向1，n向T分别连一条容量为k，费用为0的边，表示最多可以重叠k次；
每个点向下一个点连一条容量为inf，费用为0的边，表示一种连接关系；
对于每个区间，左端点向右端点连边，容量为1，费用为区间长度；
求最大费用最大流即可，注意离散化；

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<iostream>
using namespace std;
const int maxn=10001;
const int inf=1e9;

queue <int> q;
int n,k,maxflow,mincost,l[maxn],r[maxn],a[maxn];//a数组用于离散化 
struct Edge{
    int next,to,dis,flow;//flow流量 dis话费 
}edge[maxn<<1];
int head[maxn],num_edge=-1,pre[maxn],last[maxn],dis[maxn],flow[maxn];
bool vis[maxn];

void add_edge(int from,int to,int flow,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].flow=flow;
    edge[num_edge].to=to;
    head[from]=num_edge;
}
void add(int x,int y,int z,int f) {add_edge(x,y,z,f); add_edge(y,x,0,-f);}

bool spfa(int s,int t)
{
    memset(dis,0x7f,sizeof(dis));
    memset(flow,0x7f,sizeof(flow));
    memset(vis,0,sizeof(vis));
    while (!q.empty()) q.pop();
    q.push(s); vis[s]=1; dis[s]=0; pre[t]=-1;

    while (!q.empty())
    {
        int now=q.front(); q.pop();
        vis[now]=0;
        for (int i=head[now]; i!=-1; i=edge[i].next)
        {
            int to=edge[i].to;
            if (edge[i].flow>0 && dis[to]>dis[now]+edge[i].dis)
            {
                dis[to]=dis[now]+edge[i].dis;
                flow[to]=min(flow[now],edge[i].flow);//注意更新flow 
                pre[to]=now;
                last[to]=i;
                if (!vis[to])
                {
                    q.push(to); vis[to]=1;
                }
            }
        }
    }
    return pre[t]!=-1;
}

void MCMF(int s,int t)
{
    while (spfa(s,t))
    {
        int now=t;//注意不要记忆代码 
        maxflow+=flow[t];
        mincost+=dis[t]*flow[t];
        while (now!=s)
        {
            edge[last[now]].flow-=flow[t];
            edge[last[now]^1].flow+=flow[t];
            now=pre[now];
        }
    }
}

int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&k);
    for (int i=1; i<=n; i++)
    {
        scanf("%d%d",&l[i],&r[i]);
        a[i]=l[i]; a[i+n]=r[i];
    }
    sort(a+1,a+1+2*n);
    int nn=unique(a+1,a+1+2*n)-a-1;
    int S=0,T=nn+1;
    add(S,1,k,0); add(nn,T,k,0);
    for (int i=1; i<=nn-1; i++) add(i,i+1,inf,0);
    for (int i=1; i<=n; i++)
    {
        int L=lower_bound(a+1,a+1+nn,l[i])-a;
        int R=lower_bound(a+1,a+1+nn,r[i])-a;
        int len=r[i]-l[i];
        add(L,R,1,-len);
    }
    MCMF(S,T);
    printf("%d",-mincost);
    return 0;

}

总结

要sort之后再使用unique；注意lower_bound的应用；
感觉网络流和动态规划有相似之处，你把图建好了，她就会给你求出最优状态