POJ3281,最大流拆点

最新推荐文章于 2021-05-02 21:17:07 发布

原创最新推荐文章于 2021-05-02 21:17:07 发布 · 235 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#最大流 #c拆点

最大流专栏收录该内容

8 篇文章

订阅专栏

本文介绍如何使用最大流算法解决牛的食物和饮料需求分配问题，通过拆点技巧确保每头牛仅能获得一种食物和一种饮料，提供详细的算法实现代码。

题目链接：Dining
入手的最大流第一题。
题目的意思是说，每个牛都有喜欢的饮料和食物，怎样分配才能最大限度地满足牛的需求。
如果去掉一个饮料，那么就是每个牛都有喜欢的食物，怎样最大限度地分配。这就是最大二分图匹配问题，用最大流做就是，从源点向每头牛连一条容量为1的边，然后每头牛向喜欢的食物连一条容量为1的边，最后由食物向汇点连一条容量为1的边，最后求最大流即可解决问题。
但是这道题多了饮料，我们可以模仿上面，源点向食物连边，食物向牛连边，牛向饮料连边，饮料向汇点连边，再求最大流。但是，这样做出来的答案是不对的，因为题目要求的是一头牛只可以拥有一种食物和饮料，如果按照那样做，就有可能一头牛拥有多种食物和饮料。所以，我们将牛进行拆点，然后这两点间连一条容量为1的边，表示牛只能选择一种食物和饮料，然后跑最大流就行了。
代码如下：

/*************************************************************************
	> File Name: main.cpp
	> Author:Eagles 
	> Mail:None 
	> Created Time: 2018年09月26日 星期三 10时58分40秒
	> Description:POJ3281 
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
using namespace std;
#define N 1000

struct node
{
    int to;
    int nex;
    int val;
}E[N*N];

int head[N],lev[N];
int cnt,n,f,d;
int S,T;

void addEdge(int a, int b, int c)
{
    E[cnt].to=b;
    E[cnt].val=c;
    E[cnt].nex=head[a];
    head[a]=cnt++;

    E[cnt].to=a;
    E[cnt].val=0;
    E[cnt].nex=head[b];
    head[b]=cnt++;
}

void init()//[0,f+d]这个区间的点是食物和饮料，之后的每队点代表一头牛
{
    memset(head,-1,sizeof(head));
    cnt=0;
    S=0;
    T=2*n+f+d+1;

    for (int i=1; i<=f; i++)
        addEdge(S,i,1);
    for (int i=f+1; i<=f+d; i++)
        addEdge(i,T,1);

    for (int i=1; i<=n; i++)
    {
        int le=f+d+i*2-1; 
        int ri=le+1;

        int num1, num2;
        scanf("%d%d",&num1,&num2);
        while (num1--)
        {
            int a;
            scanf("%d",&a);
            addEdge(a,le,1);
        }
        
        while (num2--)
        {
            int b;
            scanf("%d",&b);
            addEdge(ri,f+b,1);
        }

        addEdge(le,ri,1);
    }
}

bool bfs()
{
    memset(lev,0,sizeof(lev));
    queue<int>q;
    q.push(S);
    lev[S]=1;

    while (!q.empty())
    {
        int u=q.front();
        q.pop();

        for (int i=head[u]; i!=-1; i=E[i].nex)
        {
            int v=E[i].to;

            if (E[i].val>0&&lev[v]==0)
            {
                lev[v]=lev[u]+1;
                q.push(v);

                if (v == T)
                    return true;
            }
        }
    }

    return false;
}

int dfs(int u, int f)
{
    if (u==T)
        return f;

    int tag=0;

    for (int i=head[u]; i!=-1; i=E[i].nex)
    {
        int v=E[i].to;

        if (E[i].val>0 && lev[v]==lev[u]+1)
        {
            int d=dfs(v,min(f-tag,E[i].val));

            E[i].val-=d;
            E[i^1].val+=d;
            tag+=d;

            if (tag==f)
                return f;
        }
    }

    return tag;
}

int Dinic()
{
    int ans=0;
    int inf=1000000;

    while (bfs())
    {
        ans+=dfs(S,inf);
    }

    return ans;
}

int main()
{
    while (~scanf("%d%d%d",&n,&f,&d))
    {
        init();
        printf("%d\n",Dinic());
    }
    return 0;
}

拆点----一个有用的技巧。