HDU4292 网络流

大致题意：

    有F种食物和D种饮料，每种食物或饮料只能供有限次，且每个人只享用一种食物和一种饮料。现在有n头牛，每个人都有自己喜欢的食物种类列表和饮料种类列表，问最多能使几个人同时享用到自己喜欢的食物和饮料。

 

大致思路：

    把人给拆点，把食物和水的点放在人的两侧

求出s到t的网络流即可

非递归调用：

#include<cstdio>
#include<cstring>
using namespace std;
const int inf=1<<30;
const int nMax=100105;
const int mMax=3000005;
struct Node
{
	int c,u,v,next;
	void insert(int nu,int nv,int nc,int nnext)
	{
		u=nu;
		v=nv;
		c=nc;
		next=nnext;
	}
}edge[mMax];
int ne,head[nMax];
int cur[nMax],ps[nMax],dep[nMax];

void addedge(int u,int v,int w) //加边
{
	edge[ne].insert(u,v,w,head[u]);
	head[u]=ne++;
	edge[ne].insert(v,u,0,head[v]);
	head[v]=ne++;
}

int dinic(int s, int t){                       //  dinic
    int tr, res = 0;
    int i, j, k, f, r, top;
    while(1){
        memset(dep, -1, sizeof(dep));
        for(f = dep[ps[0]=s] = 0, r = 1; f != r;)
        {
            for(i = ps[f ++], j = head[i]; j; j = edge[j].next)
            {
                if(edge[j].c && dep[k=edge[j].v] == -1)
                {
                    dep[k] = dep[i] + 1;
                    ps[r ++] = k;
                    if(k == t)
                    {
                        f = r; break;
                    }
                }
            }
        }
        if(dep[t] == -1) break;
        memcpy(cur, head, sizeof(cur));
        i = s, top = 0;
        while(1)
        {
            if(i == t)
            {
                for(tr =inf, k = 0; k < top; k ++)
                {
                    if(edge[ps[k]].c < tr)
                    {
                        tr = edge[ps[f=k]].c;
                    }
                }
                for(k = 0; k < top; k ++)
                {
                    edge[ps[k]].c -= tr;
                    edge[ps[k]^1].c += tr;
                }
                i = edge[ps[top=f]].u;
                res += tr;
            }
            for(j = cur[i]; cur[i]; j = cur[i] =edge[cur[i]].next)
            {
                if(edge[j].c && dep[i]+1 == dep[edge[j].v])
                {
                	break;
                }
            }
            if(cur[i])
            {
                ps[top ++] = cur[i];
                i = edge[cur[i]].v;
            }
            else
            {
                if(top == 0)
                {
                	break;
                }
                dep[i] = -1;
                i = edge[ps[-- top]].u;
            }
        }
    }
    return res;
}

int main()
{
	int i,j,a,b,s,t,f,n,d;
	char str[205];
	while(~scanf("%d%d%d",&n,&f,&d))
	{
		s=0;
		t=f+n+d+10+n;
		ne=2;
		memset(head,0,sizeof(head));
		for(i=1;i<=f;i++)
		{
			scanf("%d",&a);
			addedge(s,i,a);
		}
		for(i=1;i<=d;i++)
		{
			scanf("%d",&a);
			addedge(f+n+n+i,t,a);
		}

		for(i=1;i<=n;i++)
		{
			addedge(f+i,f+n+i,1);
		}

		for(i=1;i<=n;i++)
		{
			scanf("%s",str);
			for(j=1;j<=f;j++)
			{
				if(str[j-1]=='Y')
				{
					addedge(j,f+i,inf);
				}
			}
		}
		for(i=1;i<=n;i++)
		{
			scanf("%s",str);
			for(j=1;j<=d;j++)
			{
				if(str[j-1]=='Y')
				{
					addedge(f+n+i,f+n+n+j,inf);
				}
			}
		}
		printf("%d\n",dinic(s,t));
	}
	return 0;
}

递归调用：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int n_max=10105;
const int m_max=300005;
const int inf=1<<30;

int s,t,num,adj[n_max],dis[n_max],q[n_max];
struct edge
{
	int v,w,pre;
	edge()
	{
		pre=0;
	}
	void insert(int vv,int ww,int ppre)
	{
		v=vv;
		w=ww;
		pre=ppre;
	}
}e[m_max];

void insert(int u,int v,int w)
{
	e[num].insert(v,w,adj[u]);
	adj[u]=num++;
	e[num].insert(u,0,adj[v]);
	adj[v]=num++;
}

bool bfs()
{
	int i,x,v,tail=0,head=0;
	memset(dis,0,sizeof(dis));
	dis[s]=1;
	q[tail++]=s;
	while(head<tail)
	{
		x=q[head++];
		for(i=adj[x];i!=-1;i=e[i].pre)
		{
			if(e[i].w&&dis[v=e[i].v]==0)
			{
				dis[v]=dis[x]+1;
				if(v==t)
				{
					return true;
				}
				q[tail++]=v;
			}
		}
	}
	return false;
}

int dfs(int s,int limit)
{
	if(s==t)
	{
		return limit;
	}
	int i,v,tmp,cost=0;
	for(i=adj[s];i!=-1;i=e[i].pre)
	{
		if(e[i].w&&dis[s]+1==dis[v=e[i].v])
		{
			tmp=dfs(v,min(limit-cost,e[i].w));
			if(tmp>0)
			{
				e[i].w-=tmp;
				e[i^1].w+=tmp;
				cost+=tmp;
				if(limit==cost)
				{
					break;
				}
			}
			else
			{
				dis[v]=-1;
			}
		}
	}
	return cost;
}

int Dinic()
{
	int ret=0;
	while(bfs())
	{
		ret+=dfs(s,inf);
	}
	return ret;
}

int main()
{
	int np,nf,nd,x;
	int i,j;
	char str[305];
	while(~scanf("%d%d%d",&np,&nf,&nd))
	{
		num=0;
		memset(adj,-1,sizeof(adj));
		s=nf+np+np+nd+1;
		t=s+1;
		for(i=1;i<=nf;i++)
		{
			scanf("%d",&x);
			insert(s,i,x);
		}
		for(i=1;i<=nd;i++)
		{
			scanf("%d",&x);
			insert(i+nf+np+np,t,x);
		}
		for(i=1;i<=np;i++)
		{
			insert(i+nf,i+nf+np,1);
		}
		for(i=1;i<=np;i++)
		{
			scanf("%s",str);
			for(j=1;j<=nf;j++)
			{
				if(str[j-1]=='Y')
				{
					insert(j,nf+i,inf);
				}
			}
		}
		for(i=1;i<=np;i++)
		{
			scanf("%s",str);
			for(j=1;j<=nd;j++)
			{
				if(str[j-1]=='Y')
				{
					insert(i+nf+np,j+nf+np+np,inf);
				}
			}
		}
		printf("%d\n",Dinic());
	}
	return 0;
}