poj 2159||hdu 1533 Going Home

poj 2159||hdu 1533 Going Home

最小费用最大流
或KM算法求二分图最优匹配

//KM算法：想在网上找一些证明，可惜都看不懂，还对KM很陌生···
//
//建图,矮人为x部,house为y部,x部的点顶标初始化为该
//点跟y部连边的边权值.y不顶标为0。由于这题要求的是最小值所
//以把边权加负号,KM求得的最优匹配加负号就相当于最小值了,
//求完备匹配的话就进行n次匹配,for过去,每次从迭代变量开始匹配，
//若匹配不成功则对x部和y部顶标进行松弛。Hungary时，标记x部的点，
//要先判断x部顶标加上y部顶标要等于边权值时才标记y部点，
//然后看y部点是否已匹配，跟普通匈牙利一样。
//顶标和大于边权值(不可能小于)，用一个松弛数组保存y部点最小的
//松弛量即顶标和减去边权值。若匹配没成功则在松弛数组中找出最小
//的做为松弛量，把刚才hungary时有遍历到的x部点顶标减去松弛量，
//有遍历到的y部点加上松弛量，这里y部点其实是已匹配成功的点，所以
//更新完顶标后已匹配的点对的顶标和还是等于边权值；没遍历到的y部点
//对应的松弛数组的值要减去松弛量，然后继续hungary
//
//
//注意：
//1、先判断x部顶标加上y部顶标要等于边权值时才标记y部点，表示该y部点
//有遍历到
//2、没遍历到的y部点对应的松弛数组的值要记得减去松弛量
//3、KM对x部点逐个遍历进行匈牙利前要对松弛数组slack初始化为INF，
//匹配一个点只能初始化一次，不是每次hungary都要初始化，
//不管hungary有没有成功只初始化一次。遍历下一个点时才可以再初始化
//
//还有就是要先保证完备匹配，即有x1->y1, x1->y2, x2->y1这三条边，权值分别为
//5,1,1 这时x1 先跟y1匹配，然后匹配x2时，先找到y1。而x1找到y2时
//发现顶标和不等于边权值，所以松弛量为lx[x1] + ly[y1] - w[x1][y1]= 5+0-1=4
//然后顶标lx[x1]=1,lx[x1]=1,ly[y1]=0,ly[y2]=4
//再次hungary匹配结果(x1,y2),(x2,y1),虽然权值和比较小，但我们是要先确保
//完备匹配
#define in freopen("in.txt", "r", stdin);
#include <stdio.h>
#include <string.h>

#define INF (1<<30)
#define N 105

struct Point
{
    int x, y;
}man[N], house[N];

int map[N][N], lx[N], ly[N];
int slack[N];   //y部的松弛量
int right[N];   //y部匹配到的x部某个点的下标
bool visx[N], visy[N];

int abs(int num)
{
    return num >= 0 ? num : -num;
}

bool hungary(int x, int n)
{
    visx[x] = true;
    for(int i = 0; i < n; ++i)
    {
        if(visy[i] == true)
            continue;
        int slk = lx[x] + ly[i] - map[x][i];
        if(slk == 0)    //要当x 与 y的顶标和等于 边权值时
        {           //表示这两点可以匹配,
            visy[i] = true;
            if(right[i] == -1 || hungary(right[i], n))
            {
                right[i] = x;
                return true;
            }
        }//当x 与 y的顶标和 大于(不可能小于)边权时,
        else    //就更行y部该点的最小松弛量
            slack[i] = slack[i] > slk ? slk : slack[i];
    }
    return false;
}

int KM(int n)
{
    for(int i = 0; i < n; ++i)  //要找n次增广路，一次匹配一对，总的n对
    {
        for(int j = 0; j < n; ++j)
            slack[j] = INF; //不知道为什么 这里要初始化松弛量
        while(1)
        {
            for(int j = 0; j < n; ++j)
                visx[j] = visy[j] = false;

            if(hungary(i, n) == true)
                break;

            int slk = INF;
            for(int j = 0; j < n; ++j)
                if(visy[j] == false && slk > slack[j])
                    slk = slack[j]; //找到最小松弛量

            for(int j = 0; j < n; ++j)
            {
                if(visx[j] == true) //x部有遍历到的要减去松弛量
                    lx[j] -= slk;
                if(visy[j] == true) //y部有遍历到的要加上松弛量
                    ly[j] += slk;   //注意若之前hungary时顶标和大于边权值的
                else    //y部点是当做没有遍历的，这样该顶标就不会被更改(其实
                    slack[j] -= slk;//就是有匹配成功的y部就是有遍历到的)
            }               //更改后的x部的顶标加上y部的顶标就可能等于边权值了
        }           //而原本匹配的y部也有更改顶标所以加上x不的顶标还是等于边权值
    }               //所以这样就有可能多匹配一对
    int ans = 0;
    for(int i = 0; i < n; ++i)
        ans += map[right[i]][i];
    printf("%d\n", -ans);
}

int main()
{
    int row, col;
    while(scanf("%d%d", &row, &col), row||col)
    {
        int n_man = 0, n_house = 0;
        for(int i = 0; i < row; ++i)
        {
            getchar();
            for(int j = 0; j < col; ++j)
            {
                char ch = getchar();
                if(ch == 'm')
                {
                    man[n_man].x = i;
                    man[n_man++].y = j;
                }
                if(ch == 'H')
                {
                    house[n_house].x = i;
                    house[n_house++].y = j;
                }
            }
        }
        for(int i = 0; i < n_man; ++i)
        {
            right[i] = -1;
            lx[i] = -INF;
            ly[i] = 0;
            for(int j = 0; j < n_house; ++j)
            {   //因为这题要求的是最小值，所以在把边权值变为负的
                //求出最大值输出时加个负号就是答案了
                map[i][j] = -(abs(man[i].x - house[j].x) +
                              abs(man[i].y - house[j].y));

                //把x部的顶标设为该点与y部连边中的最大值
                lx[i] = lx[i] > map[i][j] ? lx[i] : map[i][j];
            }
        }
        KM(n_man);
    }
    return 0;
}

//最小费用最大流，是费用优先考虑，然后才是最大流
//直接spfa找到sink的最小费用就可以，流量根据容量建反向边就会
//自己调整，挺神奇的，也不知道这样理解对还是错···

#define infile freopen("in.txt", "r", stdin);
#include <stdio.h>
#include <string.h>
#include <queue>

using namespace std;

#define N 20010

struct POINT
{
    int x, y;
}man[N], house[N];

struct EDGE
{
    int from, to, cap, cost, next;
}edge[2*N];   //有反向边

int eid, n;
int head[N], fa[N], dis[N];
bool vis[N];

int abs(int num)
{
    return num > 0 ? num : -num;
}

void add_edge(int from, int to, int cap, int cost)
{
    edge[eid].from = from;
    edge[eid].to = to;
    edge[eid].cap = cap;
    edge[eid].cost = cost;
    edge[eid].next = head[from];
    head[from] = eid++;

    edge[eid].from = to;
    edge[eid].to = from;        //建反向边
    edge[eid].cap = 0;
    edge[eid].cost = -cost;
    edge[eid].next = head[to];
    head[to] = eid++;
}

bool spfa(int now)
{
    memset(vis, false, sizeof(vis));
    memset(dis, -1, sizeof(dis));
    queue<int>que;
    que.push(now);
    vis[now] = true;
    dis[now] = 0;
    while(!que.empty())
    {
        now = que.front();
        que.pop();
        for(int i = head[now]; i != -1; i = edge[i].next)
        {
            int to = edge[i].to;
            if(edge[i].cap > 0 && (dis[to] == -1 || dis[to] - dis[now] > edge[i].cost))
            {
                dis[to] = dis[now] + edge[i].cost;
                fa[to] = i;
                if(vis[to] == false)
                {
                    que.push(to);
                    vis[to] = true;
                }
            }
        }
        vis[now] = false;
    }
    if(dis[20005] == -1)
        return false;
    return true;    //有找到路在这返回true，不是一找到sink就返回
}

void max_flow()
{
    int ans = 0;
    while(spfa(0))
    {
        for(int i = 20005; i != 0; i = edge[fa[i]].from)
        {
            edge[fa[i]].cap -= 1;   //下标从0开始，奇数为逆向边
            edge[fa[i]^1].cap += 1; //所以偶数异或完刚好是奇数
        }
        ans += dis[20005];  //累加最小费用
    }
    printf("%d\n", ans);
}

int main()
{
    infile
    int row, col;
    while(scanf("%d%d", &row, &col), row||col)
    {
        eid = 0;
        memset(head, -1, sizeof(head));
        int n_man = 0, n_house = 0;
        for(int i = 0; i < row; ++i)
        {
            getchar();
            for(int j = 0; j < col; ++j)
            {
                char ch = getchar();
                if(ch == 'm')
                {
                    man[++n_man].x = i;
                    man[n_man].y = j;
                }
                if(ch == 'H')
                {
                    house[++n_house].x = i;
                    house[n_house].y = j;
                }
            }
        }
        n = n_man;
        for(int i = 1; i <= n_man; ++i)
        {
            add_edge(0, i, 1, 0);   //设source为0,source到人
            add_edge(i+n_man, 20005, 1, 0); //设sink为20005,house 到汇点
            for(int j = 1; j <= n_house; ++j)
            {
                add_edge(i, n_man+j, 1,
                abs(man[i].x - house[j].x) + abs(man[i].y - house[j].y));
            }
        }
        max_flow();
    }
    return 0;
}