zoj - 2412 - Farm Irrigation

连块问题，输入矩阵后，逐点扫描，该点若没未标记过，计数器就+1，然后深度优先遍历，标记这一大块的通路，接着，继续扫点。

#include <iostream>
#include <string.h>

using namespace std;

const int maxn = 50 + 10;       //设置最大长度

struct Tmap     //定义结点数据类型，共有11种块，故开一个大小为12的数组，加1个四个方向都没有的结点
{
    int up;     //结点的上面有没通路，有的话为1，没有为0
    int down;       //结点的下面有没通路，有的话为1，没有为0
    int left;       //结点的左边有没通路，有的话为1，没有为0
    int right;      //结点的右边有没通路，有的话为1，没有为0
}map[12];

int M, N, st[maxn][maxn], vis[maxn][maxn];      //M、N为输入的行数和列数，st为转换后的整型数组，vis为状态数组

void dfs(int x, int y)      //深度优先遍历，将属于同一块的都标记掉
{
    if(vis[x][y] == 1)      //如果该点已经访问过，返回
        return;

    vis[x][y] = 1;      //否则，修改状态

    if(x > 1 && map[st[x-1][y]].down*map[st[x][y]].up == 1) dfs(x-1, y);        //判断可否向上走
    if(y < N && map[st[x][y+1]].left*map[st[x][y]].right == 1) dfs(x, y+1);     //判断可否向右走
    if(x < M && map[st[x+1][y]].up*map[st[x][y]].down == 1) dfs(x+1, y);        //判断可否向下走
    if(y > 1 && map[st[x][y-1]].right*map[st[x][y]].left == 1) dfs(x, y-1);     //判断可否向左走
}

int main()
{
    map[0].up = 1; map[0].right = 0; map[0].down = 0; map[0].left = 1;      //A
    map[1].up = 1; map[1].right = 1; map[1].down = 0; map[1].left = 0;      //B
    map[2].up = 0; map[2].right = 0; map[2].down = 1; map[2].left = 1;      //C
    map[3].up = 0; map[3].right = 1; map[3].down = 1; map[3].left = 0;      //D
    map[4].up = 1; map[4].right = 0; map[4].down = 1; map[4].left = 0;      //E
    map[5].up = 0; map[5].right = 1; map[5].down = 0; map[5].left = 1;      //F
    map[6].up = 1; map[6].right = 1; map[6].down = 0; map[6].left = 1;      //G
    map[7].up = 1; map[7].right = 0; map[7].down = 1; map[7].left = 1;      //H
    map[8].up = 0; map[8].right = 1; map[8].down = 1; map[8].left = 1;      //I
    map[9].up = 1; map[9].right = 1; map[9].down = 1; map[9].left = 0;      //J
    map[10].up = 1; map[10].right = 1; map[10].down = 1; map[10].left = 1;      //K

    int i, j;
    char s[maxn][maxn];     //输入的字符型数组
    while(cin>>M>>N)
    {
        if(M < 0 || N < 0) return 0;    //如果有一个数小于0，返回

        memset(vis, 0, sizeof(vis));        //初始化所有点为0，可以访问

        for(i = 1; i <= M; i++)
        {
            for(j = 1; j <= N; j++)
            {
                cin>>s[i][j];
                st[i][j] = s[i][j] - 'A';       //输入后即转化为整型，A、B~K分别对应0、1~10
            }
        }
        for(i = 0; i <= N+1; i++)       //外加一层边，置其所有走向为0（只需让其成为map[11]）
        {
            st[0][i] = 11;
            st[M+1][i] = 11;
        }
        for(i = 0; i <= M+1; i++)
        {
            st[i][0] = 11;
            st[i][N+1] = 11;
        }

        int cnt = 0;        //计数器
        for(i = 1; i <= M; i++)     //每个点扫一次
            for(j = 1; j <= N; j++)
            {
                if(vis[i][j] == 0)      //如果没有走过，就加1块，并把这一大块标记掉
                {
                    cnt++;
                    dfs(i, j);      //它的功能就是标记掉这一大块
                }
            }
        cout<<cnt<<endl;
    }

    return 0;
}