POJ 1087 UNIX dinic

将设备和插座都看成节点，并增加源点和终点。从源点s到每个设备连一条线，容量为1；从设备到该设备应该插入的插座连一条线，容量为1；对于适配器，假设输入的为a b，a表示该适配器的插座（即提供的插孔），b表示插头（即往插孔上插的插头），从a到b连一条线，容量为无穷大，表示a可以插在b上，向外提供a插座；从以前室内拥有的插座到终点t连一条线，容量为1；如下图所示：

//11168017	c00h00g	1087	Accepted	824K	16MS	G++	5184B	2013-01-10 10:40:18
//dinic模板
//因为点的个数最多为500，所以设置了maxn为600，但是终点不能用maxn，而要用maxn-1，因为maxn在数组中是没有意义的（超数组范围了） 
#include<stdio.h>
#include<stdlib.h>
#include<map>
#include<string.h>
#include<vector>
#include<queue>
#include<iostream>

#define INF 0x7FFFFFFF
#define maxn 600
using namespace std;

map<string,int> Map;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
struct Edge{
    int from,to,cap,flow;
    Edge(int x,int y,int z,int w):from(x),to(y),cap(z),flow(w){}
};

int s,t;
vector<Edge> edges;
vector<int> G[maxn];
bool vis[maxn];
int d[maxn];
int cur[maxn];

void AddEdge(int from,int to,int cap){
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int m=edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

bool BFS(){
    memset(vis,0,sizeof(vis));
    queue<int> q;
    q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=0;i<G[x].size();i++){
            Edge& e=edges[G[x][i]];
            if(!vis[e.to]&&e.cap>e.flow){
                vis[e.to]=1;
                d[e.to]=d[x]+1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}
int DFS(int x,int a){
    if(x==t||a==0) return a;
    int flow=0,f;
    for(int& i=cur[x];i<G[x].size();i++){
        Edge& e=edges[G[x][i]];
        if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
            e.flow+=f;
            edges[G[x][i]^1].flow-=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}

int main(){
    int n,m,num;
    string a,b;
    while(scanf("%d",&n)!=EOF){
        Map.clear();
        int cnt=1;
        for(int i=0;i<n;i++){
            cin>>a;
            if(Map[a]==0)
                Map[a]=cnt++;
            AddEdge(Map[a],maxn-1,1);
        }
        scanf("%d",&m);
        num=m;
        for(int i=0;i<m;i++){
            cin>>a>>b;
            Map[a]=cnt++;
            if(Map[a]==0)
                Map[a]=cnt++;
            if(Map[b]==0)
                Map[b]=cnt++;
            AddEdge(Map[a],Map[b],1);
            AddEdge(0,Map[a],1);
        }
        scanf("%d",&m);
        for(int i=0;i<m;i++){
            cin>>a>>b;
            if(Map[a]==0)
               Map[a]=cnt++;
            if(Map[b]==0)
               Map[b]=cnt++;
            AddEdge(Map[a],Map[b],INF);
        }
        //处理
        s=0,t=maxn-1;
        int flow=0;
        while(BFS()){
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        printf("%d\n",num-flow);
    }    
    return 0;
}