poj1087 網路最大流

http://poj.org/problem?id=1087

Description

Input

Output

Sample Input

4 
A 
B 
C 
D 
5 
laptop B 
phone C 
pager B 
clock B 
comb X 
3 
B X 
X A 
X D 

Sample Output

1

/**
poj 1087  網路最大流
題目大意：（思路摘自網上）這題題目意思實在太難懂，不過題目意思搞清楚之後還是比較好做的
在這個題目裡有兩種物品，一個是插座，一個是電器
插座只有一個插孔和一個插頭，電器只有一個插頭
首先有n種插座，n種插座用字串表示，這n種插座可以理解為是插在電源上的插座
然後有m個電器，現在電器要充電，電器用字串表示，每個電器都有自己可以插的插座
(這個插座可以不是那n個插在電源上的插座，可以是其他的插座)
現在有k個資訊
s1 s2代表s1插座可以插到s2插座上去，這裡類似於將插頭轉換了一下
這些s1與s2也可以不是那n個插在電源上的插座
給出這些個資訊問你還有多少個電器沒有插座可以用

解題思路：
建一個源點，指向所有電器，容量為1
所有電器指向他們可以插的那個插頭上，容量為1
如果一個插頭可以插到另一個插頭，那麼將s1指向s2，容量為無限大
將所有插在電源上的插頭指向匯點，容量為1

然後從源點到匯點求最大流即可
*/
#include<cstdio>
#include <string.h>
#include<iostream>
using namespace std;
const int oo=1e9;
/**oo 表示無窮大*/
const int mm=111111;
/**mm 表示邊的最大數量，記住要是原圖的兩倍，在加邊的時候都是雙向的*/
const int mn=999;
/**mn 表示點的最大數量*/

char name[3000][30];
int k;
int node,src,dest,edge;
/**node 表示節點數，src 表示源點，dest 表示匯點，edge 統計邊數*/
int ver[mm],flow[mm],next[mm];
/**ver 邊指向的節點，flow 邊的容量，next 連結串列的下一條邊*/
int head[mn],work[mn],dis[mn],q[mn];
/**head 節點的連結串列頭，work 用於演算法中的臨時連結串列頭，dis 計算距離*/

/**初始化連結串列及圖的資訊*/
void prepare(int _node,int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0; i<node; ++i)head[i]=-1;
    edge=0;
}
/**增加一條u 到v 容量為c 的邊*/
void addedge(int u,int v,int c)
{
    ver[edge]=v,flow[edge]=c,next[edge]=head[u],head[u]=edge++;
    ver[edge]=u,flow[edge]=0,next[edge]=head[v],head[v]=edge++;
}
/**廣搜計算出每個點與源點的最短距離，如果不能到達匯點說明演算法結束*/
bool Dinic_bfs()
{
    int i,u,v,l,r=0;
    for(i=0; i<node; ++i)dis[i]=-1;
    dis[q[r++]=src]=0;
    for(l=0; l<r; ++l)
        for(i=head[u=q[l]]; i>=0; i=next[i])
            if(flow[i]&&dis[v=ver[i]]<0)
            {
                /**這條邊必須有剩餘容量*/
                dis[q[r++]=v]=dis[u]+1;
                if(v==dest)return 1;
            }
    return 0;
}
/**尋找可行流的增廣路演算法，按節點的距離來找，加快速度*/
int Dinic_dfs(int u,int exp)
{
    if(u==dest)return exp;
    /**work 是臨時連結串列頭，這裡用i 引用它，這樣尋找過的邊不再尋找*/
    for(int &i=work[u],v,tmp; i>=0; i=next[i])
        if(flow[i]&&dis[v=ver[i]]==dis[u]+1&&(tmp=Dinic_dfs(v,min(exp,flow[i])))>0)
        {
            flow[i]-=tmp;
            flow[i^1]+=tmp;
            /**正反向邊容量改變*/
            return tmp;
        }
    return 0;
}
int Dinic_flow()
{
    int i,ret=0,delta;
    while(Dinic_bfs())
    {
        for(i=0; i<node; ++i)work[i]=head[i];
        while(delta=Dinic_dfs(src,oo))ret+=delta;
    }
    return ret;
}

int sol(char *str)
{
    int i;
    if(k==0)
    {
        strcpy(name[1],str);
        k=1;
        return  1;
    }
    for(i=1; i<=k; i++)
        if(strcmp(name[i],str)==0)
            return i;
    k++;
    strcpy(name[k],str);
    return k;
}

int main()
{
    int n1,n2,n3;
    int st,ed;
    int a,b;
    int num1[105][2],num2[105][2],num3[105][2];
    char str1[30],str2[30];
    while(~scanf("%d",&n1))
    {
        k=0;
        for(int i=0;i<n1;i++)
        {
            scanf("%s",str1);
            num1[i][0]=sol(str1);
        }
        scanf("%d",&n2);
        for(int i=0;i<n2;i++)
        {
            scanf("%s%s",str1,str2);
            num2[i][0]=sol(str1);
            num2[i][1]=sol(str2);
        }
        scanf("%d",&n3);
        for(int i=0;i<n3;i++)
        {
            scanf("%s%s",str1,str2);
            num3[i][0]=sol(str1);
            num3[i][1]=sol(str2);
        }
        prepare(k+2,0,k+1);

        for(int i=0;i<n1;i++)
        {
            addedge(num1[i][0],dest,1);
        }
        for(int i=0;i<n2;i++)
        {
            addedge(num2[i][0],num2[i][1],1);
            addedge(src,num2[i][0],1);
        }
        for(int i=0;i<n3;i++)
        {
            addedge(num3[i][0],num3[i][1],oo);
        }
        printf("%d\n",n2-Dinic_flow());
    }
    return 0;
}