UVa live6525Attacking rooks（二分最大匹配之最大匹配）

最新推荐文章于 2021-11-28 17:31:24 发布

Aerolite坠落

最新推荐文章于 2021-11-28 17:31:24 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏：二分图匹配文章标签： c语言二分图匹配算法编程 poj

本文链接：https://blog.youkuaiyun.com/scf0920/article/details/28853503

二分图匹配专栏收录该内容

20 篇文章

订阅专栏

本文介绍了如何通过二分匹配算法高效解决N-rooks问题，并详细解释了建图方法和代码实现。从文章中学习到的优化技巧包括避免不必要的初始化操作和采用前向星优化来提高运行速度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目地址：https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4536

Chess inspired problems are a common source of exercises in algorithms classes. Starting with the well
known 8-queens problem, several generalizations and variations were made. One of them is the N -rooks
problem, which consists of placing N rooks in an N by N chessboard in such a way that they do not
attack each other.
Professor Anand presented the N -rooks problem to his students. Since rooks only attack each other
when they share a row or column, they soon discovered that the problem can be easily solved by placing
the rooks along a main diagonal of the board. So, the professor decided to complicate the problem by
adding some pawns to the board. In a board with pawns, two rooks attack each other if and only if
they share a row or column and there is no pawn placed between them. Besides, pawns occupy some
squares, which gives an additional restriction on which squares the rooks may be placed on.
Given the size of the board and the location of the pawns, tell Professor Anand the maximum
number of rooks that can be placed on empty squares such that no two of them attack each other.
Input
The input le contains several test cases, each of them as described below.
The rst line contains an integer N (1 N 100) representing the number of rows and columns
of the board. Each of the next N lines contains a string of N characters. In the i-th of these strings,
the j -th character represents the square in the i-th row and j-th column of the board. The character
is either `.' (dot) or the uppercase letter `X', indicating respectively an empty square or a square
containing a pawn.
Output
For each test case, output a line with an integer representing the maximum number of rooks that can
be placed on the empty squares of the board without attacking each other.
Sample Input
5
X....
X....
..X..
.X...
....X
4
....
.X..
....
....
1
X
Sample Output
7
5
0

这个题也是以前做过的，当时用的暴搜。。不用说。。结果自然是该超的都超了。。超内存超时限。现在用二分匹配做真心简单啊。。从一篇文章中有这题的建图方法。。看了好长时间才发现这个建图方法跟我刚做过的一道题的建图方法本质上是一样的。（详情见我上一篇博客。。）由于上一篇博客中有建图方法也有原因，这里就不多说了。。。

这题20s的时限，第一次因为忘记初始化而TLE了好几次。。。sad。。（为什么每个题都要如此手残一番。。）后来加上了之后以19.369s的时间AC了。。。后来发现定的数组过大，光在初始化上就浪费很长时间，改成5000*5000后，时间立即来到了11秒。。。据说用前向星更快，下次再来个前向星版本的，这博文有待更新。上代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include<algorithm>
using namespace std;
int n, mp1[101][101], mp2[101][101], mpp[101][101], mp[4001][4001], vis[4001], link[4001], k1, k2;
int dfs(int a)
{
    int i;
    for(i=1;i<=k2;i++)
    {
        if(!vis[i]&&mp[a][i])
        {
            vis[i]=1;
            if(link[i]==-1||dfs(link[i]))
            {
                link[i]=a;
                return 1;
            }
        }
    }
    return 0;
}
int hungary()
{
    int i, ans=0;
    memset(link,-1,sizeof(link));
    for(i=1;i<=k1;i++)
    {
        memset(vis,0,sizeof(vis));
        if(dfs(i))
            ans++;
    }
    return ans;
}
int main()
{
    int i, j, a;
    char s[200];
    while(scanf("%d",&n)!=EOF)
    {
        a=0;
        memset(mp,0,sizeof(mp));
        memset(mp1,0,sizeof(mp1));
        memset(mp2,0,sizeof(mp2));
        memset(mpp,0,sizeof(mpp));
        for(i=0;i<n;i++)
        {
            scanf("%s",s);
            for(j=0;j<n;j++)
            {
                if(s[j]=='.')
                    {
                        mpp[i][j]=1;
                        a++;
                    }
            }
        }
        k1=k2=0;
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(mpp[i][j])
                {
                    if(j==0||(mpp[i][j-1]==0&&mpp[i][j]))
                    {
                        mp1[i][j]=++k1;
                    }
                    if(j!=0&&mpp[i][j-1]&&mpp[i][j])
                        mp1[i][j]=k1;
                }
            }
        }
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(mpp[j][i])
                {
                    if(j==0||(mpp[j-1][i]==0&&mpp[j][i]))
                    {
                        mp2[j][i]=++k2;
                    }
                    if(j!=0&&mpp[j-1][i]&&mpp[j][i])
                        mp2[j][i]=k2;
                }
            }
        }
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                mp[mp1[i][j]][mp2[i][j]]=1;
            }
        }
        printf("%d\n",hungary());
    }
    return 0;
}

更快的前向星写法新鲜出炉啦！！快了100倍！！从11秒马上变成了0.119秒。。。。太爽了。。。

前后对比：

简直炫酷。。。上代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
int n, mp1[101][101], mp2[101][101], mpp[101][101], cnt,  vis[4001], link[4001], k1, k2, head[10000];
struct node
{
    int u, v;
    int next;
} edge[10001];
void add(int u, int v)
{
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
int dfs(int u)
{
    int i;
    for(i=head[u]; i!=-1; i=edge[i].next)
    {
        if(!vis[edge[i].v])
        {
            vis[edge[i].v]=1;
            if(link[edge[i].v]==-1||dfs(link[edge[i].v]))
            {
                link[edge[i].v]=u;
                return 1;
            }
        }
    }
    return 0;
}
int hungary()
{
    int i, ans=0;
    memset(link,-1,sizeof(link));
    for(i=1; i<=k1; i++)
    {
        memset(vis,0,sizeof(vis));
        if(dfs(i))
            ans++;
    }
    return ans;
}
int main()
{
    int i, j;
    char s[200];
    while(scanf("%d",&n)!=EOF)
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        memset(mp1,0,sizeof(mp1));
        memset(mp2,0,sizeof(mp2));
        memset(mpp,0,sizeof(mpp));
        for(i=0; i<n; i++)
        {
            scanf("%s",s);
            for(j=0; j<n; j++)
            {
                if(s[j]=='.')
                {
                    mpp[i][j]=1;
                }
            }
        }
        k1=k2=0;
        for(i=0; i<n; i++)
        {
            for(j=0; j<n; j++)
            {
                if(mpp[i][j])
                {
                    if(j==0||(mpp[i][j-1]==0&&mpp[i][j]))
                    {
                        mp1[i][j]=++k1;
                    }
                    if(j!=0&&mpp[i][j-1]&&mpp[i][j])
                        mp1[i][j]=k1;
                }
            }
        }
        for(i=0; i<n; i++)
        {
            for(j=0; j<n; j++)
            {
                if(mpp[j][i])
                {
                    if(j==0||(mpp[j-1][i]==0&&mpp[j][i]))
                    {
                        mp2[j][i]=++k2;
                    }
                    if(j!=0&&mpp[j-1][i]&&mpp[j][i])
                        mp2[j][i]=k2;
                }
            }
        }
        for(i=0; i<n; i++)
        {
            for(j=0; j<n; j++)
            {
                if(mpp[i][j])
                    add(mp1[i][j],mp2[i][j]);
            }
        }
        printf("%d\n",hungary());
    }
    return 0;
}