UVA 753 A Plug for UNIX

题意：输入n，有n个插座，下面n行是每个插座的类型（最后24个字母来表示一个插座，没有空格放心用scanf，但是有可能插座会相同，但是这个没有什么影响）

         输入m，有m个电器，下面m行每行两个单词分别是电器的名字和插头类型（同样24个字母单词内没空格，两个单词空格隔开）

         输入k，有k个转换器，下面k行每行两个单词，分别表示转换器的入口类型和插头类型

每种转换器的个数是无限的，转换器本身可以与转换器相连

要你求，让最多的电器能够插在插座上（可以用转换器辅助也可以直接插上去），输入不能插上去的电器的数量

#include <iostream>
#include <cstdio>
#include <string>
#include <utility>
#include <queue>
#include <vector>
//#define T
using namespace std;
const int infinity = 1000000000;
int count = 0;
struct Edge
{
    int from,to, flow, capacity;
    Edge(const int &v,const int &a, const int &c,const int &f)
    {
        from=v,to = a, capacity = c,flow=f;
    }
};

int vexnum, edgenum;//表示顶点个数和边个数
int receptacle, device, adapter;//表示插座数，电器数，转换器种类
vector<string>table_receptacle;
vector<string>table_device;
vector<pair<string,string> >table_adapter;
int src, sink;//表示源点和汇点
int max_flow;//最大流
vector<Edge>edge;//边数的两倍
vector<vector<int> >adjList;//邻接表

void addEdge(const int& from, const int& to,const int& capacity)
{
    edge.push_back(Edge(from,to,capacity,0));
    adjList[from].push_back(edge.size()-1);
    edge.push_back(Edge(to,from,0,0));
    adjList[to].push_back(edge.size()-1);
}


void init()
{
    table_adapter.clear();
    table_device.clear();
    table_receptacle.clear();
    edge.clear();
    adjList.clear();
}
void network()
{
    max_flow = 0;
    src = 0;//源点设置成0
    //接受插座
    cin >> receptacle;
    table_receptacle.resize(1);
    for (int i = 0; i < receptacle; i++)
    {
        string type;
        cin >> type;//插座的类型
        table_receptacle.push_back(type);
    }
    //接受电器
    cin >> device;
    table_device.resize(1);
    for (int i = 0; i < device; i++)
    {
        string name, type;
        cin >> name >> type;
        table_device.push_back(type);
    }
    //接受适配器
    cin >> adapter;
    table_adapter.resize(1);
    for (int i = 0; i < adapter; i++)
    {
        string type1, type2;
        cin >> type1 >> type2;
        table_adapter.push_back(make_pair(type1,type2));
    }
    //初始化源点，汇点，邻接表，顶点数
    src = 0, sink = device + receptacle + adapter+1, vexnum = 1 + sink;
    adjList.resize(vexnum);
    //连边
    for (int i = 1; i<=device; i++)
    {
        addEdge(src, i, 1);
        for (int j = 1; j <= receptacle; j++)
        {
            if (table_device[i]== table_receptacle[j])
            {
                addEdge(i, device + j, 1);
            }
        }
        for (int j = 1; j <= adapter; j++)
        {
            if (table_device[i] == table_adapter[j].first)
            {
                addEdge(i, device + receptacle + j, infinity);
            }
        }
    }
    for (int i = 1; i <= receptacle; i++)
    {
        addEdge(device + i, sink, 1);
        for (int j = 1; j <= adapter; j++)
        {
            if (table_receptacle[i] == table_adapter[j].second)
            {
                addEdge(device + receptacle + j, device + i,1);
            }
        }
    }
    for (int i = 1; i <= adapter; i++)
    {
        for (int j = 1; j <= adapter; j++)
        {
            if (i == j)
            {
                continue;
            }
            if (table_adapter[i].first == table_adapter[j].second)
            {
                addEdge(device + receptacle + j, device + receptacle + i,infinity);
            }
        }
    }
}

void getMaxFlow()
{
    vector<int>path(vexnum);
    while (1)
    {
        vector<int>augument(vexnum);
        queue<int>Q;
        Q.push(src);
        augument[src] =infinity;
        while (!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for (unsigned int i = 0; i < adjList[x].size(); i++)
            {
                Edge&e = edge[adjList[x][i]];
                if (!augument[e.to]&&e.capacity>e.flow)
                {
                    path[e.to] = adjList[x][i];
                    augument[e.to] = std::min(augument[x],e.capacity-e.flow);
                    Q.push(e.to);
                }
            }
            if (augument[sink])
            {
                break;
            }
        }
        if (!augument[sink])
        {
            break;
        }
        for (int u = sink; u!=src; u=edge[path[u]].from)
        {
            edge[path[u]].flow += augument[sink];
            edge[path[u]^1].flow-= augument[sink];
        }
        max_flow += augument[sink];
    }
}
void print()
{
    cout << device-max_flow << endl;
    count++;
}

int main()
{
    #ifdef T
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // T
    int n;
    cin >> n;
    while (n--)
    {
        init();
        network();
        getMaxFlow();
        print();
        if (n)
        {
            cout << endl;
            count++;
        }
    }
    return 0;
}