poj3020 匈牙利算法+建图

转自网络的题解:(写的很好)

转载请注明出处:優YoU http://user.qzone.qq.com/289065406/blog/1299322779

提示:别被图片的圈圈误导了,看清楚题目,'*'是城市,'o'是空地,椭圆的天线覆盖范围要覆盖的是城市'*',而不是覆盖空地

 

题目大意:

一个矩形中,有N个城市’*’,现在这n个城市都要覆盖无线,若放置一个基站,那么它至多可以覆盖相邻的两个城市。
问至少放置多少个基站才能使得所有的城市都覆盖无线?


解题思路:

思前想后,依稀可以认为是一道求二分图的最小路径覆盖问题

(注意不是最小点覆盖)

 

那么接下来需要确认的是,

究竟是求 有向二分图的最小路覆盖,还是求 无向二分图的最小路覆盖

因为有向和无向是截然不同的计算方法。

 

要确认是构造有向图,还是构造无向图,那么就需要先根据题意,看看构造二分图时所使用的方式,更适合构造哪一种二分图。

 

然后就进入了本题难点:如何构造二分图

 

首先要明确的是,输入的一堆“圈圈星星”可以看做是一张大地图,地图上有所有城市的坐标,但是这里有一个误区:不能简单地把城市的两个x、y坐标作为准备构造的二分图的两个顶点集。

城市才是要构造的二分图的顶点!

构造方法如下:

例如输入:

*oo

***

O*o

时,可以抽象为一个数字地图:

100

234

050

数字就是根据输入的城市次序作为该城市的编号,0代表该位置没有城市。

然后根据题目的“范围”规则,从第一个城市开始,以自身作为中心城市,向四个方向的城市进行连线(覆盖)

因此就能够得到边集:

e12  e21     e32     e43    e53

     e23     e34

             e35

可以看到,这些边都是有向边,但是每一条边都有与其对应的一条相反边。

任意两个城市(顶点)之间的边是成对出现的

那么我们就可以确定下来,应该 构造无向二分图(其实无向=双向)

因为若要构造有向的二分图时,需要判断已出现的边,是很麻烦的工作

 

为了把有向图G构造为无向二分图,这里需要引入一个新名词“拆点”

其实就是把原有向图G的每一个顶点都”拆分(我认为复制更准确)”为2个点,分别属于所要构造的二分图的两个顶点集

 

例如在刚才的例子中抽出一条有向边e12举例说明:

复制顶点1和顶点2,使得1,2∈V1;  1’,2’∈V2 ,不难发现|V1|=|V2|

根据边e12和e21,得到无向二分图:


 

那么同理就可以得到刚才的例子的 无向二分图为:


 

再继而通过无向二分图,以V1的元素作为row,V2的元素作为col,构造 可达矩阵 存储到计算机

   1’  2’  3’  4’  5’

1  F  T   F   F   F

2  T  F   T   F   F

3  F  T   F   T   T

4  F  F   T   F   F

5  F  F   T   F   F

 

接下来就是要求这个 无向二分图的最小路径覆盖 了

利用公式:

 

无向二分图的最小路径覆盖 = 顶点数 – 最大二分匹配数/2

 

顶点数:就是用于构造无向二分图的城市数,即进行“拆点”操作前的顶点数量

最大二分匹配书之所以要除以2,是因为进行了“拆点”擦奥做做使得匹配总数多了一倍,因此除以2得到原图的真正的匹配数

 

最后剩下的问题就是求最大二分匹配数了,用匈牙利算法,这就不多说了,参考POJ3041的做法,基本一摸一样。

 


从这道题得出了一个结论:

当二分图的两个顶点子集基数相等时,该二分图所有顶点的匹配数 等于 任意一个顶点子集匹配数的2倍 

其实匈牙利算法解题是极为简单的,但是图论的难并不是难在解答,而是建图的过程,也难怪会有牛曰:用匈牙利算法,建图是痛苦的,最后是快乐的。

 题解代码:

 
//Memory Time 
//420K   16MS 
#include<iostream>
using namespace std;
int ipmap[41][11];   //标记存在城市'*'的位置,并依次记录城市的编号
int ip;     //城市编号(最终是城市数量)
int V1,V2;  //二分图的两个顶点集
int M;      //最大二分匹配
bool city[401][401];   //标记两个城市之间是否能连通
                      //通过“拆点”操作,把每一个城市拆分为2个,分别属于所构造的二分图的两个点集
bool vist[401];
int link[401];
int dire_r[4]={-1,1,0,0};
int dire_c[4]={0,0,-1,1};   //分别对应四个方位 上 下 左 右
/*Hungary Algorithm*/
bool dfs(int x)
{
    for(int y=1;y<=V2;y++)
        if(city[x][y] && !vist[y])
        {
            vist[y]=true;
            if(link[y]==0 || dfs(link[y]))
            {
                link[y]=x;
                return true;
            }
        }
    return false;
}
void search(void)
{
    for(int x=1;x<=V1;x++)
    {
        memset(vist,false,sizeof(vist));
        if(dfs(x))
            M++;
    }
    return;
}
int main(void)
{
    int test,h,w;
    cin>>test;
    while(test--)
    {
        /*Initial*/
        memset(ipmap,0,sizeof(ipmap));
        memset(city,false,sizeof(city));
        memset(link,0,sizeof(link));
        ip=0;
        M=0;
        /*Read in the maps*/
        cin>>h>>w;
        int i,j;
        char temp;
        for(i=1;i<=h;i++)
            for(j=1;j<=w;j++)
            {
                cin>>temp;
                if(temp=='*')
                    ipmap[i][j]=++ip;
            }
        /*Structure the Bipartite Graphs*/
        for(i=1;i<=h;i++)
            for(j=1;j<=w;j++)
                if(ipmap[i][j])
                    for(int k=0;k<4;k++)
                    {
                        int x=i+dire_r[k];
                        int y=j+dire_c[k];
                        if(ipmap[x][y])
                            city[ ipmap[i][j] ][ ipmap[x][y] ]=true;      //"拆点"操作是"顺便"被完成的
                    }                                                    //二分图构造完毕后,之后的问题就和POJ3041一样处理了
        V1=V2=ip;
        /*增广轨搜索*/
        search();
        /*Output*/
        cout<<ip-M/2<<endl;   //无向二分图:最小路径覆盖数 = "拆点"前原图的顶点数 - 最大匹配数/2
    }
    return 0;
}
我自己的代码:匈牙利算法
#include<stdio.h>
#include<string.h>
#include <iostream>
using namespace std;
#define maxn 500
int edge[maxn][maxn];
char s[maxn][maxn];
int ma[maxn][maxn];
int gril[maxn];
int used[maxn];
int ans=0;
int v1,v2;
int t;
int dirx[4]= {-1,1,0,0};
int diry[4]= {0,0,-1,1};
int dfs(int x)
{
    for(int i=1; i<=v2; i++) //历遍每一个右端点
    {
        if(edge[x][i]==1&&used[i]==0) //如果有边并且该端点还未使用就检验是否能构成增广路
        {
            used[i]=1;
            if(gril[i]==0||dfs(gril[i]))//如果该点是为匹配点或者能形成增广路,
            {
                gril[i]=x;//那么给予该点匹配
                return 1;
            }
        }
    }
    return 0;
}
void hungrian()
{
    for(int i=1; i<=v1; i++)
    {
        memset(used,0,sizeof(used));  //dfs初始化
        if(dfs(i))
            ans++;
    }
}
int main()
{
    int m,n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&m,&n);
        memset(edge,0,sizeof(edge));
        memset(gril,0,sizeof(gril));
        memset(ma,0,sizeof(ma));
        int cnt=0;
        ans=0;
        for(int i=0;i<m;i++)
        {
            scanf("%s",s[i]);
            for(int j=0;j<n;j++)
            {
                if(s[i][j]=='*')
                {
                    ma[i][j]=++cnt;
                }
            }
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(ma[i][j])
                {
                    for(int  k=0;k<4;k++)
                    {
                        int tx=i+dirx[k];
                        int ty=j+diry[k];
                        if(ma[tx][ty])
                        {
                            edge[ma[i][j]][ma[tx][ty]]=1;
                        }
                    }
                }
            }
        }
        v1=v2=cnt;
        hungrian();
        printf("%d\n",cnt-ans/2);
    }
}

用hc算法啊的(不会拼  以后写简写 )
#include<bits/stdc++.h>
using namespace std;
#define maxn 500
#define inf INT_MAX
char s[maxn][maxn];
int ma[maxn][maxn];
int ans=0;
int t;
int dirx[4]= {-1,1,0,0};
int diry[4]= {0,0,-1,1};
int bmap[maxn][maxn];
int cy[maxn];
int cx[maxn];
int nx,ny;
int dx[maxn];
int dy[maxn];
int dis;
bool bmask[maxn];
bool ser()
{
    queue<int>Q;
    dis=inf;
    memset(dx,-1,sizeof(dx));  //层数初始化
    memset(dy,-1,sizeof(dy));
    for(int i=1;i<=nx;i++) //没匹配的进队列
    {
        if(cx[i]==-1)
        {
            Q.push(i);
            dx[i]=0;
        }
    }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        for(int v=1;v<=ny;v++)  //历遍每一个y集合
        {
            if(bmap[u][v]&&dy[v]==-1)  //如果有边且无层数
            {
                dy[v]=dx[u]+1;
                if(cy[v]==-1)dis=dy[v];  //如果未匹配,记录层数
                else //如果匹配了,更改v匹配的那个人的层数。并进队列。
                {
                    dx[cy[v]]=dy[v]+1;
                    Q.push(cy[v]);
                }
            }
        }
    }
    return dis!=inf;
}
int findpath(int u)
{
    for(int v=1;v<=ny;v++)
    {
        if(!bmask[v]&&bmap[u][v]&&dy[v]==dx[u]+1)  //如果v未vis,并且有边,且是u的下一层
        {
            bmask[v]=1;
            if(cy[v]!=-1&&dy[v]==dis)  //如果v匹配了,并且是最后一层,continue
            {
                continue;
            }
            if(cy[v]==-1||findpath(cy[v])) //如果v未匹配或者能腾出来位置就更新匹配
            {
                cy[v]=u;
                cx[u]=v;
                return 1;
            }
        }
    }
    return 0;
}
int maxmatch()
{
    int res=0;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));
    while(ser()) //只要存在增广路
    {
        memset(bmask,0,sizeof(bmask));
        for(int i=1;i<=nx;i++)
        {
            if(cx[i]==-1)
            {
                res+=findpath(i);
            }
        }
    }
    return res;
}
int main()
{
    int m,n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&m,&n);
        memset(bmap,0,sizeof(bmap));
        memset(ma,0,sizeof(ma));
        int cnt=0;
        ans=0;
        for(int i=0;i<m;i++)
        {
            scanf("%s",s[i]);
            for(int j=0;j<n;j++)
            {
                if(s[i][j]=='*')
                {
                    ma[i][j]=++cnt;
                }
            }
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(ma[i][j])
                {
                    for(int  k=0;k<4;k++)
                    {
                        int tx=i+dirx[k];
                        int ty=j+diry[k];
                        if(ma[tx][ty])
                        {
                            bmap[ma[i][j]][ma[tx][ty]]=1;
                        }
                    }
                }
            }
        }
        nx=ny=cnt;
        ans=maxmatch();
        printf("%d\n",cnt-ans/2);
    }
}



  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值