poj2195 bfs+最小权匹配

     题意：给个矩阵，矩阵里有一些人和房子（人数和房子数相等），一个人只进一个房子（可以路过房子而不进），每走一步花费1美金，求所有人都进入房子的最小花费，这是典型的二分图带权匹配问题。

     这题就是建图有点麻烦，但绝不抽象，直接用BFS遍历每个人到所有房子的距离，遍历出一个就拉一条人到房子有向边，建完图就是套模板了。

     注意：KM算法是求最大权匹配的，要求最小权就要把所有边取相反数，最后结果再取相反数，但这只能是完美匹配，不完美匹配还要变一些。

    

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#define maxn 500

using namespace std;


char group[101][101];
int index[101][101];
struct pos
{
    int x,y;
}people[maxn],house[maxn];
struct edge
{
    int to,cap;
};
vector<edge> g[maxn];
int a,b,sum_m,sum_h;

const int mir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int vis[101][101];
struct step
{
    int x,y,s;
};
void init()
{
    sum_m=sum_h=0;
    memset(people,0,sizeof(people));
    memset(house,0,sizeof(house));
    memset(index,0,sizeof(index));
    for(int i=0;i<maxn;i++)
        g[i].clear();
}
void add_edge(int from,int to,int cap)
{
    g[from].push_back((edge){to,cap});
}
void bfs(int sx,int sy,int ex,int ey)
{
    memset(vis,0,sizeof(vis));
    step now,next;
    queue<step> q;
    now.x=sx,now.y=sy,now.s=0;
    vis[sx][sy]=1;
    q.push(now);
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==ex&&now.y==ey)
        {
            add_edge(index[sx][sy],index[now.x][now.y],~now.s+1);
            return;
        }
        for(int i=0;i<4;i++)
        {
            int x=now.x+mir[i][0];
            int y=now.y+mir[i][1];
            if(x>=0&&y>=0&&x<a&&y<b)
            {
                if(!vis[x][y])
                {
                    vis[x][y]=1;
                    next.x=x,next.y=y,next.s=now.s+1;
                    q.push(next);
                }
            }
        }
    }
}
int x[maxn], y[maxn], link[maxn],sx[maxn], sy[maxn];
int slack;
int DFS(int t)
{
    int i, tmp;
    sx[t] = 1;
    for (i = 0; i < g[t].size(); i++)
    {
        edge e=g[t][i];
        if (!sy[e.to])
        {
            tmp = x[t] + y[e.to] - e.cap;
            if (tmp == 0)
            {
                sy[e.to] = 1;
                if (link[e.to] == -1 || DFS(link[e.to]))
                {
                    link[e.to] = t;
                    return 1;
                }
            }
            else if (tmp < slack)
                slack = tmp;
        }
    }
    return 0;
}
void KM()
{
    int i, j;
    for(int w=0;w<sum_m;w++)
    {
        x[w]=0;
        for(int v=0;v<g[w].size();v++)
        {
            if(g[w][v].cap>x[w])
                x[w]=g[w][v].cap;
        }
    }
    for (j = 0; j < sum_h; j++)
    {
        y[j] = 0;
    }
    memset(link, -1, sizeof(link));
    for (i = 0; i < sum_m; i++)
    {
        while (1)
        {
            memset(sx, 0, sizeof(sx));
            memset(sy, 0, sizeof(sy));
            slack = 0xfffffff;
            if (DFS(i)) break;
            for (j = 0; j < sum_m; j++)
            {
                if (sx[j])
                    x[j] -= slack;
            }
            for (j = 0; j < sum_h; j++)
            {
                if (sy[j])
                    y[j] += slack;
            }
        }
    }
}

int main()
{
    while(scanf("%d%d",&a,&b)!=EOF,a&&b)
    {
        getchar();
        init();
        for(int i=0;i<a;i++)
        {
            gets(group[i]);
            for(int j=0;j<b;j++)
            {
                if(group[i][j]=='m')
                {
                    people[sum_m].x=i;
                    people[sum_m].y=j;
                    index[i][j]=sum_m;
                    sum_m++;
                }
                else if(group[i][j]=='H')
                {
                    house[sum_h].x=i;
                    house[sum_h].y=j;
                    index[i][j]=sum_h;
                    sum_h++;
                }
            }
        }
        for(int n=0;n<sum_m;n++)
        {
            for(int m=0;m<sum_h;m++)
            {
                bfs(people[n].x,people[n].y,house[m].x,house[m].y);
            }
        }
  /*     for(int i=0;i<sum_m;i++)
        {
            cout<<i<<" ";
            for(int j=0;j<g[i].size();j++)
                cout<<g[i][j].to<<" "<<g[i][j].cap<<endl;
        }*/
        KM();
        int ans=0;
        int coun = 0,t=0;
        for (int i = 0; i < sum_h; i++)
        {
            t = link[i];
            if (t >= 0)
            {
                coun ++;
                ans += g[t][i].cap;
            }
        }
        printf("%d
",~ans+1);
    }
    return 0;
}