网络流 ( ISAP+建图 )——A Plug for UNIX ( POJ 1087 )

• 题目链接：
  http://poj.org/problem?id=1087

• 分析：给出k个设备，每个设备对应一种插头，再给出n种插板（每种一个）和m种适配器（每种数量无限），只有插头插板相同编号才能插入，适配器可以转换插头编号，求最少由几个设备插不上。

• 题解：
  因为输入的设备名称和插头插板都是字符串所以，需要用到map转换乘数字。

  从S建立到k个设备的边，容量为1；
  从k个设备建立到其对应插头的边，容量为1；
  遍历适配器，建立可以转换的插头之间的边，容量为INF；
  然后建立和插板相同编号的 插头到对应插板的边，容量为1；
  建立插板到T的边，容量为1。

  PS：在POJ上又是C++ WA，G++AC，不上很懂这个OJ

  建图完毕后之间套用ISAP模板即可

• AC代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
using namespace std;

//POJ G++才可以过
#define Maxn 2000
#define INF 99999

struct node
{
    int v, cap;
    int next;
}edge[2000];

int n,m,k;
int cont;
int head[Maxn];
int dis[Maxn];
int num[Maxn];
int cur[Maxn];
int pre[Maxn];

map<string, int> P;
map<string, int>D;

void add(int u, int v, int cap)
{
    edge[cont].v = v;
    edge[cont].cap = cap;
    edge[cont].next = head[u];
    head[u] = cont++;

    edge[cont].v=u;
    edge[cont].cap=0;
    edge[cont].next=head[v];
    head[v] = cont++;
}

void BFS(int source,int sink)
{
    queue<int>q;
    while(q.empty()==false)
    q.pop();
    memset(num,0,sizeof(num));
    memset(dis,-1,sizeof(dis));
    q.push(sink);
    dis[sink]=0;
    num[0]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v = edge[i].v;
            if(dis[v] == -1)
            {
                dis[v] = dis[u] + 1;
                num[dis[v]]++;
                q.push(v);
            }
        }
    }
}

int ISAP(int source,int sink,int n)
{
    memcpy(cur,head,sizeof(cur));

    int flow=0, u = pre[source] = source;
    BFS( source,sink);
    while( dis[source] < n )
    {
        if(u == sink)
        {
            int df = INF, pos;
            for(int i =source;i != sink;i = edge[cur[i]].v)
            {
                if(df > edge[cur[i]].cap)
                {
                    df = edge[cur[i]].cap;
                    pos = i;
                }
            }
            for(int i = source;i != sink;i = edge[cur[i]].v)
            {
                edge[cur[i]].cap -= df;
                edge[cur[i]^1].cap += df;
            }
            flow += df;
            //cout << flow << endl;
            u = pos;
        }
        int st;
        for(st = cur[u];st != -1;st = edge[st].next)
        {
            if(dis[edge[st].v] + 1 == dis[u] && edge[st].cap)
            {
                break;
            }
        }
        if(st != -1)
        {
            cur[u] = st;
            pre[edge[st].v] = u;
            u = edge[st].v;
        }
        else
        {
            if( (--num[dis[u]])==0 ) break;
            int mind = n;
            for(int id = head[u];id != -1;id = edge[id].next)
            {
                if(mind > dis[edge[id].v] && edge[id].cap != 0)
                {
                    cur[u] = id;
                    mind = dis[edge[id].v];
                }
            }
            dis[u] = mind+1;
            num[dis[u]]++;
            if(u!=source)
            u = pre[u];
        }
    }
    return flow;
}

void init()
{
    P.clear();
    D.clear();

       memset(head,-1,sizeof(head));
       cont=0;
}

#define Num 200

int main()
{
    string plug;
    string name;
    string device;

    while(scanf("%d",&n)!=EOF)
    {
        init();
        int S = 0;
        int T = 1111;
        int type = 1;
        for(int i=1;i<=n;i++)
        {
            cin >> plug;
            if(!P.count(plug))
                P[plug] = Num + type++;

            add(P[plug], P[plug]+Num, 1);
            add( P[plug]+Num, T, 1);
        }

        scanf("%d", &m);
        for(int i=1;i<=m;i++)
        {
            cin >>name;
            cin >> plug;
            D[name] = i;
            if(!P.count(plug))
                P[plug] = Num + type++;
            add(S, D[name], 1 );
            add(D[name], P[plug], 1);
        }

        scanf("%d", &k);
        for(int i=1;i<=k;i++)
        {
            cin >> plug;
            if(!P.count(plug))
                P[plug] = Num + type++;
            cin >> device;
            if(!P.count(device))
                P[device] = Num + type++;
            add( P[plug], P[device] , INF);//转换器
        }
        int ans = ISAP(S, T, k+n+m+1);
        printf("%d\n", m-ans);

    }

}