uva 657 The die is cast

图的搜索，双重搜索

题意：（折腾的UVA又是好难懂的题意），给你一个h行w列的矩阵输入（标准的）,注意输出w h，别颠倒过来。然后只有三种点 '*' , '.' , 'X'

其中X和*一起称为区域I，在区域I中相连的X称为区域II ， 输出就是输出m个数字，其中m就是区域I的个数，这m个数字中第i个数字num[i]表示某块区域I一面又多少个区域II

其中相连是两个格子有公共边，只有点不行，所以对于一个格子而言有4个相连的格子，分别就是上下左右

另外区域I可能是任意形状的，可以看sample

sample中就是有4块区域I

左上角的区域I有两个X，但是这个两个X不是相连的，算为2个，所以这个区域I对应的数字是2

右上角的区域II有两个X，不过这两个X是相连的，算为1个，所以这个区域I对应的数字是1

左下角的区域I有两个X，不过这两个X不想连，算为2个，所以这个区域I对应的数字是2

右下角的区域有四个X，不过这4个X都不相连，算为4，所以这个区域对应的数字是4

所以最优的数字是2 1 2 4  ，输出要求排序后输出，所以是1 2 2 4

 

题意说完了就说算法

双重搜索，DFS和BFS都行，我用了DFS+BFS，其实怎么搭配都可以的，应该都不会TLE或者什么

图中只有X和*的点会被访问

对于当前点如果没被访问过而且是X或者*，就准备访问它

优先判断它是不是X，如果是，则先执行BFS，把和这个X相连的X全部找出来，找这些X的时候并不是标记他们被访问过，而是不用标记被访问过，而在在图中将它们改为*

然后BFS结束后，那一部分X已经变为*，然后再从起点开始DFS所有的*，并且标记被访问，注意这时候才标记被访问

所以可以看到*只会被访问一次，是被DFS访问的

X会被访问两次，首先被BFS访问并改为*，再被DFS访问一次

 

统计有图中多少个区域I是看主函数中调用了多少次DFS，主函数每调用一次DFS就计数一次，其实就是判断图中有多少个连通分量

而每调用一个BFS，就给区域II计数一次，BFS只会在DFS中被调用

所以再啰嗦一句就是DFS是访问区域I的，BFS是在区域I中访问区域II的

另外注意，一个区域I中的区域II的个数只能是1到6,0和6以上的不能算进去，相当于忽略掉这整块区域I

然后看代码

//只有vis[i][j]为0，而且s[i][j]='*'或者s[i][j]='X'的点会被访问
//对于确定要访问的点，优先判断s[i][j]是不是'X',是的话进行BFS访问到所有的'X'
//访问过程中，不用标记vis[i][j]，也是将'X',改为'*'
//BFS结束后相当于很多'X'都变成了没有标记过的'*'，然后就简单的DFS所有的'*'
//每进行一次BFS就计数
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
#define N 60
struct node 
{ int x,y; };
queue <struct node> q; 
char s[N][N];
int vis[N][N];
int w,h;
int dx[5]={0,-1,1,0,0} , dy[5]={0,0,0,-1,1};
int ccount;

void BFS(int i , int j)
{
    int xx,yy;
    struct node tmp,ttmp;

    while(!q.empty()) q.pop();  //清空队列
    s[i][j]='*';
    tmp.x=i;  tmp.y=j;
    q.push(tmp);  //初始化队列先放一个点进去
    while(!q.empty())
    {
        tmp=q.front();
        q.pop();
        for(int k=1; k<=4; k++)
        {
            xx=tmp.x+dx[k];
            yy=tmp.y+dy[k];
            if(!vis[xx][yy] && s[xx][yy]=='X')
            {
                s[xx][yy]='*';
                ttmp.x=xx;
                ttmp.y=yy;
                q.push(ttmp);
            }
        }
    }
    return ;
}

void DFS(int i, int j)
{
    int xx,yy;
    if(s[i][j]=='X')  //优先判断是不是'X',然后进行BFS
    {
        ccount++;
        BFS(i,j);
    }

    vis[i][j]=1;
    for(int k=1; k<=4; k++)
    {
        xx=i+dx[k];
        yy=j+dy[k];
        if(!vis[xx][yy] && (s[xx][yy]=='*' || s[xx][yy]=='X') )
            DFS(xx,yy);
    }

    return ;
}

void input()
{
    memset(s,0,sizeof(s));
    memset(vis,0,sizeof(vis));

    for(int i=1; i<=h; i++)
        gets(s[i]+1);
    
    for(int i=0; i<=h+1; i++) //标记左右两侧
        vis[i][0]=vis[i][w+1]=1;
    for(int i=0; i<=w+1; i++) //标记上下两行
        vis[0][i]=vis[h+1][i]=1;
/*
    for(int i=0; i<=h+1; i++)
    {
        for(int j=0; j<=w+1; j++)
            printf("%d",vis[i][j]);
        printf("\n");
    }
    for(int i=1; i<=h; i++)
        printf("%s\n",s[i]+1);
*/
    return ;
}
int main()
{
    int T=0,c,num[N*N];
    while(scanf("%d%d",&w,&h)!=EOF)
    {
        getchar(); T++;
        if(!w && !h)  break;
        input();

        c=0;
        for(int i=1; i<=h; i++)
            for(int j=1; j<=w; j++)
                if( (vis[i][j] && s[i][j]=='X' || s[i][j]=='*') )
                {
                    ccount=0;
                    DFS(i,j);  
                    if(ccount>0 && ccount<7)
                        num[c++]=ccount;
                }
        sort(num,num+c);
        printf("Throw %d\n",T);
        printf("%d",num[0]);
        for(int i=1; i<c; i++)
            printf(" %d",num[i]);
        printf("\n\n");

    }
    return 0;
}