2020.11.10大二练习：网络流（更新中）

• 经过几天的“折磨”，我一刚入门图论的菜鸡终于摸索出了一点门道呜呜呜
• 网络流的题难就难在建图上
• 不知道为啥文章目录有点问题将就着看看吧/捂脸

---

A：Going Home

最小费用最大流模板题

题意没有绕圈子说的很直白，我就不再复述了。
一开始我看见就想为啥不直接bfs找最短路，再一想其实这里bfs的话局部最优解的加和不一定等于全局最优解的。

于是我们需要找最小费用最大流，这里我是这样建图的：

1. 设置一个源点和一个汇点：源点指向所有人，容量为1费用为0；所有房子都指向汇点，容量为1费用为0（源点就相当于所有人的集合，因为每一个人其实都是一个独立的“源点”，而找到一一对应的房子就等价于到了它的“汇点”，所以费用为0；而每一个房子只能容纳一个人，所以容量为1）
2. 在人和房子之间建立关系：每一个人指向所有的房子，容量为1，费用为相隔最短路径的长度（坐标之差绝对值得和）

于是我们得到了这样一张图：

有了图我们就可以愉快的套模板了！
由于这里有负权边所以我采用EK+SPFA发挥余热 来求解

同时这里注意：
最多有100个人，也就最多有100个房子；算上源点和汇点我们要保证点数>=202；
而边数要>=(100*100+100+100)*2=20400;

具体见代码：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N=210,M=40400,INF=1e8;
int n,m,S,T;//S为源点，T为汇点
int men_num,house_num;//记录人的数量和房子的数量
int e[M],f[M],w[M],ne[M],h[N],idx;//邻接表建图
int q[N],d[N],pre[N],incf[N];//q模拟对列，d记录当前点路径最小容量，pre找反向边
bool st[N];

struct node
{
    int x,y;
}men_id[N],house_id[N];//记录人和房子坐标，用来建立人和房子之间的关系

void init()//每次初始化
{
    memset(h, -1, sizeof h);
    men_num=0,house_num=0,idx=0;
}

void add(int a, int b, int c, int d)
{
    e[idx] = b, f[idx] = c, w[idx] = d, ne[idx] = h[a], h[a] = idx ++ ;
    e[idx] = a, f[idx] = 0, w[idx] = -d, ne[idx] = h[b], h[b] = idx ++ ;
}

bool spfa()
{
    int hh = 0, tt = 1;
    memset(d, 0x3f, sizeof d);
    memset(incf, 0, sizeof incf);
    q[0] = S, d[S] = 0, incf[S] = INF;
    while (hh != tt)
    {
        int t = q[hh ++ ];
        if (hh == N) hh = 0;
        st[t] = false;

        for (int i = h[t]; ~i; i = ne[i])
        {
            int ver = e[i];
            if (f[i] && d[ver] > d[t] + w[i])
            {
                d[ver] = d[t] + w[i];
                pre[ver] = i;
                incf[ver] = min(f[i], incf[t]);
                if (!st[ver])
                {
                    q[tt ++ ] = ver;
                    if (tt == N) tt = 0;
                    st[ver] = true;
                }
            }
        }
    }

    return incf[T] > 0;
}

void EK(int& flow, int& cost)
{
    flow = cost = 0;
    while (spfa())
    {
        int t = incf[T];
        flow += t, cost += t * d[T];
        for (int i = T; i != S; i = e[pre[i] ^ 1])
        {
            f[pre[i]] -= t;
            f[pre[i] ^ 1] += t;
        }
    }
}

int main()
{
    while(~scanf("%d%d",&n,&m)&&n!=0&&m!=0)
    {
        init();
        S=0,T=202;
        char str[N];
        for(int i=1;i<=n;i++)
        {
            scanf("%s",str);
            for(int j=0;j<m;j++)
            {
                if(str[j]=='m')
                    men_id[++men_num].x=i,men_id[men_num].y=j+1;
                else if(str[j]=='H')
                    house_id[++house_num].x=i,house_id[house_num].y=j+1;
            }
        }
        //人化为点，编号从1～men_num
        for(int i=1;i<=men_num;i++)
            add(S,i,1,0);
        //房子化为点，编号从men_num+1~men_num+house_num
        for(int i=1;i<=men_num;i++)
            for(int j=1;j<=house_num;j++)
                add(i,men_num+j,1,abs(men_id[i].x-house_id[j].x)+abs(men_id[i].y-house_id[j].y));
        
        for(int i=1;i<=house_num;i++)
            add(men_num+i,T,1,0);
            
        int flow,cost;
        EK(flow,cost);
        printf("%d\n",cost);
    }
    
    return 0;
}

---

B：Dining

dinic/最大流/拆点建图

这题建图有点意思，题目意思是：
先输入三个整数N、F、D，表示牛的数量、食物数量、饮料数量；
再有从2～N+1行，头两个数fi、di，后面跟fi个食物种类、di个饮料种类，表示第i头牛可以从其中挑选食物和饮料各一种；
每一种食物或饮料只能使用一次，即对应一头牛，求最大能满足的数量。

考虑到食物和饮料与牛是一一对应的关系，所以摆点的顺序是：
源点 -> 食物 -> 牛 -> 饮料 -> 汇点

但是！单纯把一个牛在图中仅用一个点是有问题的！这样无法保证在求最大流时一个牛只吃了一种食物和一种饮料：

显然这个流网络的最大流为2，但我们知道它应该等于1才对；

所以重点来了，我们需要把一个牛拆成两半，让牛自己与自己对应建立一条容量为1的边，来保证牛与食品饮料一一对应的关系：

这样保证了含有每个牛的可行路只用到了一个食物及饮料。

再考虑数据范围，点数应>=1+100+1002+100+1=402，边数应>=(100+100100+100+100*100+100)*2=40600;

根据上述图，取0为源点，1000为汇点，1～F为食物，F+1～F+N为牛1，F+N+1～F+N+N为牛2，F+N+N+1~F+N+N+D为饮料

其余详情见代码：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int V=1010,M=50000,INF=1e8;
int N,F,D,S,T;
int e[M],f[M],ne[M],h[V],idx;//邻接表
int q[V],d[V],cur[V];//dinic
bool stS[V],stT[V];	//判重边，已经与源点连接过的食物或者已经与汇点连接过饮料不能再进入add函数更新邻接表(会导致错误答案！)

void add(int a,int b,int c)
{
    e[idx]=b,f[idx]=c,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,ne[idx]=h[b],h[b]=idx++;
}

bool bfs()
{
    int hh=0,tt=0;
    memset(d, -1, sizeof d);
    q[0]=S,d[S]=0,cur[S]=h[S];
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int ver=e[i];
            if(d[ver]==-1 && f[i])
            {
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver == T)
                    return true;
                q[++tt]=ver;
            }
        }
    }
    return false;
}

int find(int u,int limit)
{
    if(u==T)
        return limit;
    int flow=0;
    for(int i=h[u];i!=-1 && flow<limit;i=ne[i])
    {
        cur[u]=i;
        int ver=e[i];
        if(d[ver]==d[u]+1 && f[i])
        {
            int t=find(ver,min(f[i],limit-flow));
            if(!t)
                d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

int dinic()
{
    int ans=0,flow;
    while(bfs())
        while(flow=find(S,INF))
            ans+=flow;
    return ans;
}

int main()
{
    scanf("%d%d%d",&N,&F,&D);
    S=0,T=1000;
    memset(h, -1, sizeof h);
    
    for(int i=1;i<=N;i++)
    {
        int fi,di,x;
        scanf("%d%d",&fi,&di);
        while(fi--)
        {
            scanf("%d",&x);
            if(!stS[x])//判重
                add(S,x,1),stS[x]=true;
            add(x,F+i,1);
        }
	        add(F+i,F+N+i,1);//牛与自身相连
        while(di--)
        {
            scanf("%d",&x);
            add(F+N+i,F+N+N+x,1);
            if(!stT[x])//判重
                add(F+N+N+x,T,1),stT[x]=true;
        }
    }
    
    printf("%d\n",dinic());
    
    return 0;
}

本题报告中图片来源：网页链接

---

正在更新！