1002: 当不成勇者的Water只好去下棋了---课程作业---图的填色

1002: 当不成勇者的Water只好去下棋了

Time Limit: 1 Sec  Memory Limit: 128 MB

Description

由于魔王BOSS躲起来了，说好要当勇者的Water只好去下棋了，他很厉害，基本每局必输。

Water总是不知道为什么把自己的棋下得东一块西一块，而块与块之间总是被对手的棋隔开。概率统计挂了的Water一直没搞清楚到底自己被别人分成了多少块，又来找你帮忙。  
假定Water的棋为X，对手的棋为O。 
给出一个矩阵棋盘，上面布满了棋子，求Water的棋子究竟被对手分成了多少块？

（为了和谐，我们还是用0011代表OOXX）

Input

第一行为n, m。 (0 < n,m <= 100)
接下来 n 行 m 列为01矩阵。
1 为Water的棋。

Output

每组数据输出一行，表示块数。

Sample Input

2 2
01
10
2 3
101
011

Sample Output

2
2

这道题利用的原理是图的填色，从一个二维数组第一个元素开始进行遍历，如果发现一个元素a是有效的，那么久在他的周围找同样有效的元素b，如果找到了，那么就在元素b的周围继续寻找。很明显，这可以用递归来实现。当然你也可以用栈来模拟递归实现。

下面来看看伪代码：

4 6
010200
111030
110030
100033

/* Floodfill  */
bool validNode(newnode) {
        cond1 = inMatrix();//是否在图内部
        cond2 = isFreeNode();//是否是有效元素（这里指值为1）&&是否已经是某个块的成员
        return cond1 && cond2;
}

void floodfill(node) {
    if node是有效元素 {
        if node还不是某块的成员
            c[node.x][node.y] = color;
        
        //遍历上下左右四个元素
        for (direction dir) {
                newnode = extend(node, dir);
                if (validNode(newnode))
                        floodfill(newnode);
        }
    } 
}

char g[n][m];//储存元素的数组

int color = 0;//分块的标志

int c[n][m];//分块记录

init();//初始化

readGraph();//读取分块记录

//遍历全部元素，进行分块
for (i = 0...n)
  for (j = 0...m) {
  // c[i][j] == 0 && g[i][j] == '1'
        node = freeNode(); 
        color++;
        floodfill(node);
  }

然后递归的代码实现如下：

#include <iostream>
#include <stdio.h>
#include <set>

using namespace std;

struct Node{
    int x;
    int y;
    Node(int x_ = 0, int y_ = 0) {
        x = x_;
        y = y_;
    }
};

//上下左右四个节点
int borderUponX[4] = {0, 0, 1, -1};
int borderUponY[4] = {1, -1, 0, 0};
int n, m;
char g[101][101];
int color = 0;
int c[101][101];

bool validNode(Node newnode) {
    if (newnode.x < 0 || newnode.x > n || newnode.y < 0 || newnode.y > m)
        return false;
    if (g[newnode.x][newnode.y] != '1' || c[newnode.x][newnode.y] != -1)
        return false;
    return true;
}

void floodfill(Node node) {
    if(g[node.x][node.y] == '1') {
        if (c[node.x][node.y] == -1)
       c[node.x][node.y] = color;

       for (int i = 0; i != 4; i++) {
            int pathX = node.x + borderUponX[i];
            int pathY = node.y + borderUponY[i];
            Node t = Node(pathX, pathY);
            if (validNode(t)) {
                floodfill(t);
            }
        }
    }
}

void init() {
    for (int i = 0; i != n; i++) {
        scanf("%s", g[i]);
    }
    for (int i = 0; i != n; i++)
        for (int j = 0; j != m; j++)
            c[i][j] = -1;
}

void readGraph() {
    set<int> count;
    for (int i = 0; i != n; i++) {
        for (int j = 0;j != m; j++) {
            if (c[i][j] != -1 && g[i][j] != '0') {
                count.insert(c[i][j]);
            }
        }
    }
    printf("%d
", count.size());
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        init();

        for (int i = 0; i != n; i++) {
            for (int j = 0;j != m; j++) {
                color++;
                floodfill(Node(i, j));
            }
        }
        readGraph();
    }
    
    return 0;
}