poj1087&hdu1526A Plug for UNIX(最大流)

题目请戳这里

题目大意：房间里有n个插座，每个插座都不一样。有m个不同的用电器，每个用电器有一个插头，每个插头只能插相对应的插座。再给k类转换器，每类转换器能把A插头转化成B插头，每类转换器无限个。求不能充电的用电器最少的个数。

题目分析：最少不能充电的用电器就是最多能充电的用电器数量。最大流。设一个源点一个汇点，源点到每个用电器连一条权为1的边，因为每种用电器只有一个。每个插座到汇点连一条边权1的边，因为每个插座也只有一个。对于m个用电器，每个用电器到相应的插座连一条边权为1的边。对于第i类转换器，Ai到Bi连一条边权为无穷大的边，因为转换器个数不限。然后就跑一遍最大流即可。

trick：

1。跟汇点建边的点只能是提供的n个插座，其他新出现的插头都不能向汇点建边。

2。数组开大点，600+吧。

3。hdu是多case，每两个case直接一个空行。

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
using namespace std;
const int N = 600;
const int M = 800000;
const int inf = 0x3f3f3f3f;
int n,m,k,sum,num;
struct node
{
    int to,c,next,pre;
}arc[M];
int head[N],sta[N],que[N],cnt[N],dis[N],rpath[N];
map<string,int>mp1,mp2;
void build(int s,int e,int cap)
{
    arc[num].to = e;
    arc[num].c = cap;
    arc[num].next = head[s];
    head[s] = num ++;
    arc[num - 1].pre = num;
    arc[num].pre = num - 1;
    arc[num].to = s;
    arc[num].next = head[e];
    arc[num].c = 0;
    head[e] = num ++;
}
void init()
{
    memset(head,-1,sizeof(head));
    num = 0;
    int i;
    string s1,s2;
    mp1.clear();
    mp2.clear();
    scanf("%d",&n);
    for(i = 2;i < n + 2;i ++)
    {
        cin>>s1;
        mp2[s1] = i;
        build(i,1,1);
    }
    scanf("%d",&m);
    sum = m + n + 2;
    for(i = n + 2;i <= m + 1 + n;i ++)
    {
        cin>>s1>>s2;
        mp1[s1] = i;
        build(0,i,1);
        if(mp2[s2] == 0)
        {
            mp2[s2] = sum ++;
        }
        build(i,mp2[s2],1);
    }
    scanf("%d",&k);
    for(i = 1;i <= k;i ++)
    {
        cin>>s1>>s2;
        if(mp2[s1] == 0)
        {
            mp2[s1] = sum ++;
        }
        if(mp2[s2] == 0)
        {
            mp2[s2] = sum ++;
        }
        build(mp2[s1],mp2[s2],inf);
    }
    sum --;
}
void re_Bfs()
{
    int i,front,rear;
    for(i = 0;i <= sum;i ++)
    {
        cnt[i] = 0;
        dis[i] = inf;
    }
    front = rear = 0;
    que[rear ++] = 1;
    cnt[0] ++;
    dis[1] = 0;
    while(front != rear)
    {
        int u = que[front ++];
        for(i = head[u];i != -1;i = arc[i].next)
        {
            if(arc[arc[i].pre].c == 0 || dis[arc[i].to] < inf)
                continue;
            dis[arc[i].to] = dis[u] + 1;
            cnt[dis[arc[i].to]] ++;
            que[rear ++] = arc[i].to;
        }
    }
}
void ISAP()
{
    re_Bfs();
    int i,u,v,maxflow = 0;
    for(i = 0;i <= sum;i ++)
        sta[i] = head[i];
    u = 0;
    while(dis[0] < sum)
    {
        if(u == 1)
        {
            int curflow = inf;
            for(i = 0;i != 1;i = arc[sta[i]].to)
                curflow = min(curflow,arc[sta[i]].c);
            for(i = 0;i != 1;i = arc[sta[i]].to)
            {
                arc[sta[i]].c -= curflow;
                arc[arc[sta[i]].pre].c += curflow;
            }
            maxflow += curflow;
            u = 0;
        }
        for(i = sta[u];i != -1;i = arc[i].next)
            if(arc[i].c > 0 && dis[u] == dis[arc[i].to] + 1)
                break;
        if(i != -1)
        {
            sta[u] = i;
            rpath[arc[i].to] = arc[i].pre;
            u = arc[i].to;
        }
        else
        {
            if((-- cnt[dis[u]]) == 0)
                break;
            sta[u] = head[u];
            int Min = sum;
            for(i = sta[u];i != -1;i = arc[i].next)
                if(arc[i].c > 0)
                    Min = min(Min,dis[arc[i].to]);
            dis[u] = Min + 1;
            cnt[dis[u]] ++;
            if(u != 0)
                u = arc[rpath[u]].to;
        }
    }
    printf("%d\n",m - maxflow);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t --)
    {
        init();
        ISAP();
        if(t)//hdu 格式
            puts("");
    }
    return 0;
}
//hdu 0MS	336K
//poj 296K	16MS