NEUQOJ 2053 Birthday（费用流）

NEUQOJ 2053 Birthday（费用流）

题意

中文题还写个p题意，复制粘贴在这里：

题目

思路

参加camp的时候还不会网络流（真鸡儿丢人），所以一直鸽着，然后就记得讲题人说是网络流了，一直想补了来着，这次想着如果再不补就没机会了，就补了。我就记得是网络流，于是用ISAP无脑跑了个最大流，发现样例怎么跑都是3啊（废话，三根蜡烛能不是3吗？！这么一想凭什么跑最大流啊，不是要求时间最短嘛），然后想了想，流到蛋糕里的蜡烛不是应该优先选择蜡烛少的去插么，贪心优化一个？去查了题解，恍然大悟（md难道不应该自己想出来嘛废物？又不难想），原来是费用流啊。

建边的话我一开始是这么干的：

超级源点给每一根蜡烛连容量为1的边，每根蜡烛跟两个蛋糕区域分别连容量为1的边，最后每个蛋糕区域和超级汇点连容量无穷大的边。

确实，这样能够保证所有的蜡烛都有地方插，跑出来的流量最大能把所有的蜡烛插满（废话）

然而真正的做法是这样的：

超级源点给每一根蜡烛连容量为1，费用为0的边（必须得插一根蜡烛啊），每根蜡烛跟两个蛋糕区域分别连容量为1费用为0的边，最后每个蛋糕区域和超级汇点连n根（最多也就是把n根蜡烛都插同一个地方）容量为1的边，他们的费用和要满足跑满几根流量就要用多少平方的费用（即：1、3、5、7、9… 化简一下其实就是第j条边费用$j^2-(j-1{)}^2$ )。

代码

这次顺便把费用流也更新为了链式前向星，而且把增广添流量的过程封装到函数里了

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct edge
{
    int from;
    int to;
    int flow;
    int cap;
    int cost;
    int nxt;
    edge(int f,int t,int c,int co,int n):from(f),to(t),cap(c),cost(co),nxt(n){
        flow=0;
    }
};
int egs[50005];
vector<edge> edges;
void addedge(int f,int t,int c,int co){
    edges.emplace_back(f,t,c,co,egs[f]);
    egs[f]=edges.size()-1;
    edges.emplace_back(t,f,0,-co,egs[t]);
    egs[t]=edges.size()-1;
}
int dis[50005];
bool vis[50005];
int pre[50005];
int visitor[50005];
int flower[50005];
int total;

int bellmanford(int s,int t)
{
    memset(dis,0x3f,sizeof dis);
    memset(vis,0,sizeof vis);
    memset(pre,-1,sizeof pre);//编号为0的边是存在的，所以初始化为-1
    memset(visitor,0,sizeof visitor);
    memset(flower,0,sizeof flower);
    dis[s]=0;
    flower[s]=0x3f3f3f3f;
    deque<int> qq;
    qq.push_back(s);
    vis[s]=true;
    while(!qq.empty())
    {
        int now=qq.front();
        qq.pop_front();
        visitor[now]++;
        if(visitor[now]>total)//因为一条路最多才n-1条边，如果超过n次遍历同一边肯定有负环
        {
            return -1;
        }
        for(int i=egs[now];i!=-1;i=edges[i].nxt)
        {

            int nxt=edges[i].to;
            int tempflow=min(flower[now],edges[i].cap-edges[i].flow);
            int lener=edges[i].cost;
            if(edges[i].cap-edges[i].flow>0 && dis[nxt]>dis[now]+lener)
            {
                dis[nxt]=dis[now]+lener;
                pre[nxt]=i;//松弛了的且不在队列的点才能进队列哦
                flower[nxt]=tempflow;
                if(!vis[nxt])
                {
                    if((!qq.empty()) && dis[nxt]<dis[qq.front()])//小的优先遍历
                        qq.push_front(nxt);
                    else
                        qq.push_back(nxt);
                    vis[nxt]=true;
                }
            }
        }
        vis[now]=false;
    }
    if(dis[t]<0x3f3f3f3f)
        return flower[t];//dis[t]如果是无穷大则说明到不了终点，没有增广路了
    else
        return -1;
}
pair<int,int> mfmc(int s,int t){
    long long maxflow=0;
    long long mincost=0;
    long long nowflow=0;
    while((nowflow=bellmanford(s,t))>0)//找不到增广路的时候才停止
    {
        //cout<<nowflow<<endl;
        maxflow+=nowflow;
        mincost+=dis[t]*nowflow;
        int now=t;
        while(now!=s)
        {
            edges[pre[now]].flow+=nowflow;
            edges[pre[now]^1].flow-=nowflow;//负边相应减去流量
            now=edges[pre[now]].from;
        }
    }
    return make_pair(maxflow,mincost);
}
int main() {
    int n,m;
    while(cin>>n>>m) {
        memset(egs, -1, sizeof egs);
        edges.empty();
        total=n+m+1;
        for (int i = 1; i <= n; i++) {
            int a, b;
            cin >> a >> b;
            addedge(0, i, 1,0);
            addedge(i, a+n, 1,0);
            addedge(i, b+n, 1,0);
        }
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                addedge(i+n,m+n+1,1,j*j-(j-1)*(j-1));
            }

        }
        //cout<<"hello?"<<endl;
        memset(pre,-1,sizeof pre);
        cout<<mfmc(0,total).second<<endl;
    }
    return 0;
}

参考了以下文章，在此表示感谢：

https://blog.csdn.net/vocaloid01/article/details/81367091