poj 2195 二分图带权匹配+最小费用最大流

题意：有一个矩阵，某些格有人，某些格有房子，每个人可以上下左右移动，问给每个人进一个房子，所有人需要走的距离之和最小是多少。

貌似以前见过很多这样类似的题，都不会，现在知道是用KM算法做了

KM算法目前还没弄懂，先套模板做

Sample Input

2 2
.m
H.
5 5
HH..m
.....
.....
.....
mm..H
7 8
...H....
...H....
...H....
mmmHmmmm
...H....
...H....
...H....
0 0

Sample Output

2
10
28

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int MAXN=120;
const int INF=0x3fffffff;
int g[MAXN][MAXN],match1[MAXN],match2[MAXN];
int KM(int m,int n)
{
    int i,j,k,p,q;
    int l1[MAXN],l2[MAXN];
    int s[MAXN],t[MAXN];
    int ret=0;
    for(i=0;i<m;i++)
    {
        l1[i]=-INF;
        for(j=0;j<n;j++)
          if(g[i][j]>l1[i])
             l1[i]=g[i][j];
        if(l1[i]==-INF) return -1;//无法匹配
    }
    for(i=0;i<n;i++)l2[i]=0;

    memset(match1,-1,sizeof(match1));
    memset(match2,-1,sizeof(match2));
    for(i=0;i<m;i++)
    {
        memset(t,-1,sizeof(t));
        for(s[p=q=0]=i;p<=q&&match1[i]<0;p++)
            for(k=s[p],j=0;j<n&&match1[i]<0;j++)
                if(l1[k]+l2[j]==g[k][j]&&t[j]<0)
                {
                    s[++q]=match2[j],t[j]=k;
                    if(s[q]<0)
                      for(p=j;p>=0;j=p)
                         match2[j]=k=t[j],p=match1[k],match1[k]=j;
                }

        if(match1[i]<0)
        {
            for(i--,p=INF,k=0;k<=q;k++)
               for(j=0;j<n;j++)
                 if(t[j]<0&&l1[s[k]]+l2[j]-g[s[k]][j]<p)
                     p=l1[s[k]]+l2[j]-g[s[k]][j];


            for(j=0;j<n;j++)if(t[j]>=0)l2[j]+=p;
            for(k=0;k<=q;k++)l1[s[k]]-=p;
        }
    }
    for(i=0;i<m;i++)
    {
        if(match1[i]<0)return -1;//无法匹配
        if(g[i][match1[i]]<=-INF)return -1;
        ret+=g[i][match1[i]];
    }
    return ret;
}
struct Node
{
    int x,y;
};
Node node1[MAXN],node2[MAXN];
char str[MAXN];
int main()
{
    int n,m;
    int nx,ny;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)break;
        nx=0;
        ny=0;
        for(int i=0;i<n;i++)
        {
            scanf("%s",&str);
            for(int j=0;j<m;j++)
            {
                if(str[j]=='m')
                {
                    node1[nx].x=i;
                    node1[nx].y=j;
                    nx++;
                }
                else if(str[j]=='H')
                {
                    node2[ny].x=i;
                    node2[ny].y=j;
                    ny++;
                }
            }
        }
        for(int i=0;i<nx;i++)
        for(int j=0;j<ny;j++)
        {
            g[i][j]=-abs(node1[i].x-node2[j].x)-abs(node1[i].y-node2[j].y);
        }
        printf("%d
",-KM(nx,ny));
    }
    return 0;
}

/*
POJ 2195 Going Home
邻接矩阵形式最小费用最大流
*/

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;


//************************************************************
//最小费用最大流算法
//SPFA求最短路
//邻接矩阵形式
//初始化:cap:容量，没有边为0
//cost:耗费，对称形式，没有边的也为0
//c是最小费用
//f是最大流
//*******************************************************
const int MAXN=500;
const int INF=0x3fffffff;
int cap[MAXN][MAXN];//容量，没有边为0
int flow[MAXN][MAXN];
//耗费矩阵是对称的，有i到j的费用，则j到i的费用为其相反数
int cost[MAXN][MAXN];


int n;//顶点数目0~n-1
int f;//最大流
int c;//最小费用
int start,end;//源点和汇点

bool vis[MAXN];//在队列标志
int que[MAXN];
int pre[MAXN];
int dist[MAXN];//s-t路径最小耗费
bool SPFA()
{
    int front=0,rear=0;
    for(int u=0;u<=n;u++)
    {
        if(u==start)
        {
            que[rear++]=u;
            dist[u]=0;
            vis[u]=true;
        }
        else
        {
            dist[u]=INF;
            vis[u]=false;
        }
    }
    while(front!=rear)
    {
        int u=que[front++];
        vis[u]=false;
        if(front>=MAXN)front=0;
        for(int v=0;v<=n;v++)
        {
            if(cap[u][v]>flow[u][v]&&dist[v]>dist[u]+cost[u][v])
            {
                dist[v]=dist[u]+cost[u][v];
                pre[v]=u;
                if(!vis[v])
                {
                    vis[v]=true;
                    que[rear++]=v;
                    if(rear>=MAXN)rear=0;
                }
            }
        }
    }
    if(dist[end]>=INF)return false;
    return true;
}

void minCostMaxflow()
{
    memset(flow,0,sizeof(flow));
    c=f=0;
    while(SPFA())
    {
        int Min=INF;
        for(int u=end;u!=start;u=pre[u])
           Min=min(Min,cap[pre[u]][u]-flow[pre[u]][u]);
        for(int u=end;u!=start;u=pre[u])
        {
            flow[pre[u]][u]+=Min;
            flow[u][pre[u]]-=Min;
        }
        c+=dist[end]*Min;
        f+=Min;
    }
}
//************************************************************

struct Node
{
    int x,y;
};
Node node1[MAXN],node2[MAXN];
char str[MAXN][MAXN];
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int N,M;
    while(scanf("%d%d",&N,&M))
    {
        if(N==0&&M==0)break;
        int tol1=0,tol2=0;
        for(int i=0;i<N;i++)
        {
            scanf("%s",&str[i]);
            for(int j=0;j<M;j++)
            {
                if(str[i][j]=='m')
                {
                    tol1++;
                    node1[tol1].x=i;
                    node1[tol1].y=j;
                }
                else if(str[i][j]=='H')
                {
                    tol2++;
                    node2[tol2].x=i;
                    node2[tol2].y=j;
                }
            }
        }
        start=0;
        n=tol1+tol2+1;
        end=tol1+tol2+1;
        memset(cap,0,sizeof(cap));
        memset(cost,0,sizeof(cost));
        for(int i=1;i<=tol1;i++)
        {
            cost[0][i]=cost[i][0]=0;
            cap[0][i]=1;
        }
        for(int i=1;i<=tol2;i++)
        {
            cost[tol1+i][end]=0;
            cap[tol1+i][end]=1;
        }
        for(int i=1;i<=tol1;i++)
          for(int j=1;j<=tol2;j++)
          {
              cost[i][tol1+j]=abs(node1[i].x-node2[j].x)+abs(node1[i].y-node2[j].y);
              cost[tol1+j][i]=-cost[i][tol1+j];
              cap[i][tol1+j]=1;
          }
        minCostMaxflow();
        printf("%d
",c);
    }
    return 0;
}

/*
POJ 2195 Going Home
邻接表形式最小费用最大流
*/

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;

const int MAXN=1000;
const int MAXE=100000;
const int INF=0x3f3f3f3f;
struct Edge
{
    int from;
    int to;
    int next;
    int re;//记录逆边的下标
    int cap;//容量
    int cost;//费用
}edge[MAXE];
int pre[MAXN];
int head[MAXN];
bool vis[MAXN];
int que[MAXN];
int dist[MAXN];
int tol;//边的总数
void add(int u,int v,int ca,int co)
{
    edge[tol].from=u;
    edge[tol].to=v;
    edge[tol].cap=ca;
    edge[tol].cost=co;
    edge[tol].re=tol+1;
    edge[tol].next=head[u];
    head[u]=tol++;

    edge[tol].from=v;//加逆边
    edge[tol].to=u;
    edge[tol].cap=0;
    edge[tol].cost=-co;
    edge[tol].re=tol-1;
    edge[tol].next=head[v];
    head[v]=tol++;
}
int n;
int start;
int end;
bool SPFA()
{
    int front=0,rear=0;
    for(int v=0;v<=n;v++)
    {
        if(v==start)
        {
            que[rear++]=v;
            vis[v]=true;
            dist[v]=0;
        }
        else
        {
            dist[v]=INF;
            vis[v]=false;
        }
    }
    while(front!=rear)
    {
        int u=que[front++];
        vis[u]=false;
        if(front>=MAXN)front=0;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap&&dist[v]>dist[u]+edge[i].cost)
            {
                dist[v]=dist[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    que[rear++]=v;
                    vis[v]=true;
                    if(rear>=MAXN)rear=0;
                }
            }
        }
    }
    if(dist[end]==INF)return false;
    return true;
}
int c;//费用
int f;//最大流

void minCostMaxflow()
{
    c=f=0;
    int u,p;
    while(SPFA())
    {
        int Min=INF;
        for(u=end;u!=start;u=edge[p].from)
        {
            p=pre[u];
            Min=min(Min,edge[p].cap);
        }
        for(u=end;u!=start;u=edge[p].from)
        {
            p=pre[u];
            edge[p].cap-=Min;
            edge[edge[p].re].cap+=Min;

        }
        c+=dist[end]*Min;
        f+=Min;
    }
}


struct Node
{
    int x,y;
};
Node node1[MAXN],node2[MAXN];
char str[MAXN][MAXN];
int main()
{
   // freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int N,M;
    while(scanf("%d%d",&N,&M))
    {
        if(N==0&&M==0)break;
        int tol1=0,tol2=0;
        for(int i=0;i<N;i++)
        {
            scanf("%s",&str[i]);
            for(int j=0;j<M;j++)
            {
                if(str[i][j]=='m')
                {
                    tol1++;
                    node1[tol1].x=i;
                    node1[tol1].y=j;
                }
                else if(str[i][j]=='H')
                {
                    tol2++;
                    node2[tol2].x=i;
                    node2[tol2].y=j;
                }
            }
        }
        start=0;
        n=tol1+tol2+1;
        end=tol1+tol2+1;

        //加边之前一定要初始化
        tol=0;//边数
        memset(head,-1,sizeof(head));//一定要初始化为-1


        for(int i=1;i<=tol1;i++)
        {
            add(0,i,1,0);
        }
        for(int i=1;i<=tol2;i++)
        {
            add(tol1+i,end,1,0);
        }
        for(int i=1;i<=tol1;i++)
          for(int j=1;j<=tol2;j++)
          {
              int temp=abs(node1[i].x-node2[j].x)+abs(node1[i].y-node2[j].y);
              add(i,tol1+j,1,temp);
          }
        minCostMaxflow();
        printf("%d
",c);
    }
    return 0;
}