【ACM】PAT.A1091 Acute Stroke【搜索】

题目链接

题目分析

寻找一个立体图形的连通区域的总面积(有限制），上下左右前后 6个方向可走
M：1286 行数
N：128 列数
L: 60 层数
T: 区域的最小值

解题思路

类似于非连通图的BFS()标准遍历代码，从每一点向六个方向遍历即可。
注：
1、遍历时用3维数组模拟坐标，简化代码；
2、输入坐标时，最外层循环的下标i作为数组的z坐标；

---

AC程序（C++）

/**************************
//@Author: 3stone
//@ACM: PAT-A1091   
//@Time: 18/2/2
//@IDE: VS2017
***************************/
#include<cstdio>
#include<string.h>
#include<iostream>
#include<queue>
using namespace std;

int M, N, L, T;

typedef struct {
    int x, y, z;
}Node;
queue<Node> que; 

int sum = 0; // 记录总数
int area[1288][130][62];  //坐标0 1
bool flag[1288][130][62];  //是否未访问

int go[][3] = {  // 坐标变化数组，由坐标(x,y,z)扩展得到的新坐标均可扩展
    -1, 0, 0,    // (x+go[i][0], y+go[i][1], z+go[i][2])
    1, 0, 0,     // 扩展到 上下左右前后 6个方向
    0, -1, 0,
    0, 1, 0,
    0, 0, -1,
    0, 0, 1
};

void BFS(int &ans) {
    int x, y, z;
    Node node, newOne;
    while (!que.empty()) {
        node = que.front();
        que.pop();
        for (int i = 0; i < 6; i++) {//向6个方向扩展
            x = node.x + go[i][0];
            y = node.y + go[i][1];
            z = node.z + go[i][2];

            if (x >= 0 && y >= 0 && z >= 0 && z < L && x < M && y < N //保证在区域内
                && flag[x][y][z] && area[x][y][z] == 1) { //判断是否未访问 & = 1
                flag[x][y][z] = false;
                newOne.x = x;
                newOne.y = y;
                newOne.z = z;
                que.push(newOne);
                ans++;
            }
        }//for
    }//while

}//BFS

int main() {

    while (scanf("%d %d %d %d", &M, &N, &L, &T) != EOF) {
        memset(area, 0, sizeof(area));
        memset(flag, true, sizeof(flag));
        sum = 0;
        Node tempNode;
        //input
        for (int i = 0; i < L; i++) //层-z
            for (int j = 0; j < M; j++) //行-x
                for (int k = 0; k < N; k++) {  //列-y
                    scanf("%d", &area[j][k][i]); //注意坐标,i作为z坐标，放在最外层
                }

        //search
        for (int i = 0; i < L; i++)
            for (int j = 0; j < M; j++)
                for (int k = 0; k < N; k++) {
                    if (flag[j][k][i] && area[j][k][i] == 1) {  //此点未访问
                        flag[j][k][i] = false;
                        int ans = 1;
                        //入队列
                        tempNode.x = j;
                        tempNode.y = k;
                        tempNode.z = i;
                        while (!que.empty()) que.pop(); //清空队列
                        que.push(tempNode);
                        BFS(ans);
                        if (ans >= T) sum += ans;
                    }
                }
        printf("%d\n", sum);

    }//while
    system("pause");
    return 0;
}

---

2017版本：
感悟：做的过程，有一点让我好崩溃，判断候选点是否满足条件，如果把判断语句放在BFS()函数内部，则提交会显示所有测试点段错误，而当把判断语句与调用函数实现时，则正确了。好像放在内部，因为有三层循环，系统栈承受不了爆栈的样子【对比PAT.A1456，只调用一次BFS(),这种方式就可以了；】

先就这样搁着吧，进度不能等了，快复试了！

#include<cstdio>
#include<queue>
using namespace std;

int M, N, L, T;
int map[1290][130][65] = { 0 }; //记录点位
bool mark[1290][130][65] = { false }; //是否访问
int sum = 0; //1 的总数

struct point {
    int a, b, c;
};
int go[][3] = {//坐标转换数组【六个方向】
    1, 0, 0,
    -1, 0, 0,
    0, 1, 0,
    0, -1, 0,
    0, 0, 1,
    0, 0, -1
};
queue<point> que;

bool judge(int x, int y, int z) {//判断点是否满足
    if (x < 0 || x >= N || y < 0 || y >= M || z < 0 || z >= L)
    //不再区域内
        return false;
    if (true == mark[x][y][z] || 0 == map[x][y][z]) return false;
        //已访问过 or 不是1
        return true;
}

int BFS(int nx, int ny, int nz) {
    while (false == que.empty()) que.pop(); //清空

    point temp1; //起始点入队列
    temp1.a = nx;
    temp1.b = ny;
    temp1.c = nz;
    mark[nx][ny][nz] = true;
    que.push(temp1);
    int tempSum = 0;

    while (false == que.empty()) {
        point now = que.front();//出队列
        point temp;
        que.pop();
        tempSum++;
        //搜索6个方向
        for (int i = 0; i < 6; i++) {
            int x = now.a + go[i][0];
            int y = now.b + go[i][1];
            int z = now.c + go[i][2];
/*
就是这两句，放在这儿就显示段错误        
if (true == mark[x][y][z] || 0 == map[x][y][z]) continue;
if (x < 0 || x >= N || y < 0 || y >= M || z < 0 || z >= L)              
    continue;       
*/          
            if (judge(x, y, z)) {//这样实现就能通过 [崩溃脸]
                temp.a = x;
                temp.b = y;
                temp.c = z;
                mark[x][y][z] = true;
                que.push(temp); //入队列
            }
        }//for
    }//while
    return tempSum;
}

int main() {
    /*
    注意: L M N 三者的关系，楼层L 在循环最外层
    */
    scanf("%d%d%d%d", &N, &M, &L, &T);
    for (int k = 0; k < L; k++) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                scanf("%d", &map[i][j][k]);
                mark[i][j][k] = false;
            }
        }
    }
    sum = 0;
    for (int k = 0; k < L; k++) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (1 == map[i][j][k] &&false==mark[i][j][k]) {
                    //类似于非连通图的遍历
                    int temp = BFS(i, j, k);
                    if (temp >= T)
                        sum += temp;
                }
            }
        }
    }
    printf("%d\n", sum);

    return 0;
}