1250：The Castle（广度优先搜索）

【题目描述】
一座城堡被分成ｍ*ｎ个方块（m≤50，n≤50），每个方块可有0～4堵墙（0表示无墙）。下面示出了建筑平面图：

图中的加粗黑线代表墙。几个连通的方块组成房间，房间与房间之间一定是用黑线（墙）隔开的。

现在要求你编一个程序，解决以下2个问题：

1、该城堡中有多少个房间?

2、最大的房间有多大?

【输入】
平面图用一个数字表示一个方块(第1个房间用二进制1011表示，0表示无东墙，用十进制11表示)。

第一行一个整数m（m≤50），表示房子南北方向的长度。

第二行一个整数n（n≤50），表示房子东西方向的长度。

后面的m行，每行有n个整数，每个整数都表示平面图对应位置的方块的特征。每个方块中墙的特征由数字P来描述（0≤P≤15）。数字P是下面的可能取的数字之和：

1（西墙 west）

2（北墙 north）

4（东墙 east）

8（南墙 south）

室内的墙被定义两次： 例如方块（1，1）中的南墙也被位于其南面的方块（2，1）定义了一次。

建筑中至少有两个房间。

【输出】
第1行：一个整数，表示房间总数；

第2行：一个整数，表示最大房间的面积（方块数）。

【输入样例】
4
7
11 6 11 6 3 10 6
7 9 6 13 5 15 5
1 10 12 7 13 7 5
13 11 10 8 10 12 13
【输出样例】
5
9
题目分析：
这个题 只要信心一点就能发现最后会出现16个数，并且每个数都代表着一个房间有不同的墙。而我们只要在搜索的时候给不同的情况分别添加上特殊判断，就和正常的搜索一样的。做完这个题之后看了一下别人的代码，发现用了位运算，但很遗憾，我还没碰过位运算，以后补上。。
这里我们假设从第一个格子开始走，走的第一个方向是向南走，那么就要保证要走到的那个格子没有北墙阻挡你，如果有就选择下一个方向。我们可以用一个二维数组来表示走的方向（这个学过搜索的应该都会）。

int d[4][2]={1,0,-1,0,0,1,0,-1};

第一个下标为0表示要向南走，1表示北，2表示东，3表示西。
那么怎么判断下一个格子有没有阻挡自己的墙呢？

int nan[20]={1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0};
int bei[20]={1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0};
int xi[20]={1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0};
int dong[20]={1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0};

于是就出现了我这么一个不懂位运算的写法，1表示可以通行，即没有对应方向的墙。0表示有对应方向的墙。
经过这些处理后这个问题就转化成了一个求连通块的题，很简单。
完整代码：

#include<iostream>
#include<queue>
using namespace std;
int n,m,sum=0,maxs=-1;
int d[4][2]={1,0,-1,0,0,1,0,-1};//四个方向
int tu[100][100];//房间地图
int nan[20]={1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0};//对应不同方向的墙
int bei[20]={1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0};
int xi[20]={1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0};
int dong[20]={1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0};
void bfs(int,int);
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        cin>>tu[i][j];
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            if(tu[i][j]!=-1)
            {
                sum++;//遇到一个连通块的开头就房间数加一并进行搜索覆盖处理
                bfs(i,j);
            }
        }
    cout<<sum<<endl;
    cout<<maxs;
    return 0;
}
void bfs(int x,int y)
{
    int s=0;
    queue<int>nx,ny;
    nx.push(x);
    ny.push(y);
    tu[x][y]=-1;//-1表示这个房间已经走过了，注意不能赋值为0因为0表示四周无墙，赋值为0会出现错误
    s++;
    while(!nx.empty())
    {
        for(int i=0;i<4;i++)
        {
            int xx=nx.front()+d[i][0];
            int yy=ny.front()+d[i][1];
            if(i==0&&bei[tu[xx][yy]]&&tu[xx][yy]!=-1&&xx>0&&xx<=n&&yy>0&&yy<=m)//符号不越界且能同行条件就入队
            {
                nx.push(xx);
                ny.push(yy);
                tu[xx][yy]=-1;
                s++;
            }
            if(i==1&&nan[tu[xx][yy]]&&tu[xx][yy]!=-1&&xx>0&&xx<=n&&yy>0&&yy<=m)
            {
                nx.push(xx);
                ny.push(yy);
                tu[xx][yy]=-1;
                s++;
            }
            if(i==2&&xi[tu[xx][yy]]&&tu[xx][yy]!=-1&&xx>0&&xx<=n&&yy>0&&yy<=m)
            {
                nx.push(xx);
                ny.push(yy);
                tu[xx][yy]=-1;
                s++;
            }
            if(i==3&&dong[tu[xx][yy]]&&tu[xx][yy]!=-1&&xx>0&&xx<=n&&yy>0&&yy<=m)
            {
                nx.push(xx);
                ny.push(yy);
                tu[xx][yy]=-1;
                s++;
            }
        }
        nx.pop();
        ny.pop();
    }
    if(s>maxs) maxs=s;//遇到大面积房间就覆盖maxs
}

结果：

输入：
4
7
11 6 11  6  3 10  6
7  9  6 13  5 15  5
1 10 12  7 13  7  5
13 11 10 8 10 12 13
输出：
5
9
Process returned 0 (0x0)   execution time : 2.250 s
Press any key to continue.