POJ

原题链接

题意：

给定 N 个不同类型插座，每个插座只能插一个相对应的设备 ；

现有 M 个人，给出每个人名字和设备的插头类型，然后给定 K 种转换器，每种转换器的数量都是无限的，每种转化器描述为： 插座类型，插头类型；

现在问至少有多少个人的设备无法插入。

思路：

一个典型的最大流问题，设定超级源点 S , 超级汇点 T ，将每种插座与 S 相连，流量为1；将所有人的插头类型统计一下，并记录数量，然后将其与汇点相连，流量为每种插头的数量；

记录所有的转换器，用 Floyd 算出 每种插头最终可以转化插头并将这个插头与对应的插座相连（如果都存在的话），最后跑一遍最大流，就是能够使用插座的人数，剩下的即为答案；

/*
* @Author: windystreet
* @Date:   2018-07-31 20:57:04
* @Last Modified by:   windystreet
* @Last Modified time: 2018-08-01 11:57:21
*/

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <vector>
#include <iostream>
#include <map>
#include <string>
#include <queue>
#include <utility>

using namespace std;

#define X first
#define Y second
#define eps  1e-2
#define gcd __gcd
#define pb push_back
#define PI acos(-1.0)
#define lowbit(x) (x)&(-x)
#define bug printf("!!!!!
");
#define mem(x,y) memset(x,y,sizeof(x))


typedef long long LL;
typedef long double LD;
typedef pair<int,int> pii;
typedef unsigned long long uLL;

const int maxn = 1000+2;
const int INF  = 1<<30;
const int mod  = 1e9+7;

struct Edge{
     int from,to,cap,flow;
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge>edge;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];
    void init(int n){
        this->n = n;
        for(int i=0;i<=n;i++)G[i].clear(),edge.clear();
    }
    void addedge(int from,int to,int cap){
        edge.pb((Edge){from,to,cap,0});
        edge.pb((Edge){to,from,0,0});
        m = edge.size();
        G[from].pb(m-2);
        G[to].pb(m-1);
    }
    bool bfs(){
        mem(vis,0);
        queue<int>Q;
        Q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while(!Q.empty()){
            int x = Q.front(); Q.pop();
            int sz = G[x].size();
            for(int i=0;i<sz;++i){
                Edge &e = edge[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;
        int sz = G[x].size();
        for(int &i = cur[x];i<sz;i++){
            Edge &e = edge[G[x][i]];
            if(d[x] + 1 == d[e.to] && (f = dfs(e.to,min(a,e.cap - e.flow)))>0){
                e.flow += f;
                edge[G[x][i]^1].flow -=f;
                flow += f;
                a -= f;
                if(a==0)break;
            }
        }
        if(!flow) d[x] = -2;
        return flow;
    }
    int maxflow(int s,int t){
        this->s = s; this -> t = t;
        int flow = 0;
        while(bfs()){
            mem(cur,0);
            flow += dfs(s,INF);
        }
        return flow;
    }
};
int vis1[410];
int vis2[420];
int dp[400][400];
int n,m,c,s = 0 ,t = 808;
map<string,int>id;
string s1,s2,name;
Dinic dinic;
void solve(){
    id.clear();
    int cnt = 1;
      mem(dp,0x3f3f3f3f);
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>s1;
        id[s1] = cnt;                     // 记录每一个插座的id
        dinic.addedge(s,cnt,1);
        vis1[cnt++] = 1;                // 标记该类型的插座已经存在
    }
    cin>>m;
    map<int,int>mp;
    mp.clear();
    for(int i=1;i<=m;i++){
        cin>>name>>s1;
        if(!id[s1]){
            id[s1]=cnt;
            cnt++;
        }
        mp[id[s1]]++;                    // 记录每种插头出现的次数
    }
    map<int,int>::iterator it = mp.begin();
    for(;it!=mp.end();it++){
        dinic.addedge(it->X+400,t,it->Y);// 插头与汇点相连，流量为插头数量
        vis2[it->X] = 1;                // 标记该类型的插头已经存在
    }
    cin>>c;
    for(int i=1;i<=c;i++){
        cin>>s1>>s2;
        if(!id[s1]) id[s1] = cnt++;
        if(!id[s2]) id[s2] = cnt++;
        dp[id[s1]][id[s2]] = 1;
    }
    for(int k = 1 ;k <= cnt;k++){        // floyd处理可转化的结果
        for(int i = 1;i <= cnt;i++ ){
            for(int j = 1;j<=cnt;j++){
                if(dp[i][k]==1&&dp[k][j]==1){
                    dp[i][j] =  1;
                }
            }
        }
    }         
    for(int i=1;i<=cnt;i++){
        if(vis1[i]&&vis2[i]){
            dinic.addedge(i,i+400,1);   // 如果该类型的插座和插头都存在，就相连
        }
    }
    for(int i=1;i<=cnt;i++){
        for(int j=1;j<=cnt;j++){
            if(dp[i][j]==1&&vis1[j]&&vis2[i]){
                dinic.addedge(j,i+400,1); // 转化之后的结果
            }
        }
    }
    int ans = dinic.maxflow(s,t);
    printf("%d
",m-ans );
    return;
}

int main()
{
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
    ios::sync_with_stdio(false);
    int t = 1;
    //scanf("%d",&t);
    while(t--){
    //    printf("Case %d: ",cas++);
        solve();
    }
    return 0;
}