计蒜客题解——T1414：抠图

题目相关

题目链接

计蒜客，https://nanti.jisuanke.com/t/T1414。

我的 OJ，http://47.110.135.197/problem.php?id=4768。

题目描述

蒜头君以前做一个图像处理的项目时，遇到了一个问题，他需要摘取出图片中某个黑色线圏成的区域以内的图片，现在请你来帮助他完成第一步，把黑色线圏外的区域全部变为黑色。已知图中除了黑线上的点外，图像中没有纯黑色（即像素为 0 的点）。

输入格式

第一行输入测试数据的组数 N(0<N≤10)。

每组测试数据的第一行是两个个整数 W,H 分表表示图片的宽度和高度 (3≤W≤1440,3≤H≤960)。

随后的 H 行，每行有 W 个正整数，表示该点的像素值。(像素值都在 0 到 255 之间，0 表示黑色，255 表示白色）。

输出格式

以矩阵形式输出把黑色框之外的区域变黑之后的图像中各点的像素值。

输入样例

1
5 5
100 253 214 146 120
123 0 0 0 0
54 0 33 47 0
255 0 0 78 0
14 11 0 0 0

输出样例

0 0 0 0 0
0 0 0 0 0
0 0 33 47 0
0 0 0 78 0
0 0 0 0 0

题目分析

题意分析

就是在一个 H*W 的矩阵内将 0 围成的区域外面的非零变成零。

以前我们 BFS 都是找零围成的区域，换一个角度考虑，本题其实就是找零外面非零的数据。那么本题和洛谷涂颜色其实很像，就是反过来罢了。

因此，可以参考涂颜色这题的方案，在外围加上一层，只是本层不是零，而是非零。然后再从 (0,0) 开始进行 BFS 所有非零的区域。

更详细的题解报考可以参考我以前写过的涂颜色，https://blog.youkuaiyun.com/justidle/article/details/104764162。

因此本题的核心变为，在外围加上一层非零数据，将矩阵从 H*W 大小变为 (H+1)*(W+1) 的大小。

AC 参考代码

由于本题比较特殊，因此可以不需要可见性控制，我们通过将 data 设置为 0，表示访问控制。

使用 BFS

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

const int MAXW = 1444;
const int MAXH = 964;

typedef struct _MAZE {
    int w, h;
    int data[MAXH][MAXW];
} MAZE;

MAZE maze;

typedef struct _POS {
    int x,y;
} POS;

//x,y表示起点位置
void bfs(int x, int y) {
    queue<POS> q;
    //从0,0开始遍历
    POS cur={x,y};
    maze.data[x][y]=0;
    q.push(cur);

    POS next;
    const POS moves[] = {{-1,0},{0,-1},{1,0},{0,1}};

    while (false==q.empty()) {
        cur = q.front();
        q.pop();

        for (int i=0; i<4; i++) {
            next.x = cur.x+moves[i].x;
            next.y = cur.y+moves[i].y;

            if (next.x>=0 && next.x<=maze.h+1 &&
                next.y>=0 && next.y<=maze.w+1 &&
                maze.data[next.x][next.y]>0) {
                maze.data[next.x][next.y]=0;
                q.push(next);
            }
        }
    }
}

int main() {
    int n;
    cin >> n;
    
    for (int i=0; i<n; i++) {
        memset(maze.data, 1, sizeof(maze.data));

        cin>>maze.w>>maze.h;
        for (int j=1; j<=maze.h; j++) {
            for (int k=1; k<=maze.w; k++) {
                cin>>maze.data[j][k];
            }
        }

        bfs(0, 0);

        //输出
        for (int j=1; j<=maze.h; j++) {
            for (int k=1; k<=maze.w; k++) {
                cout << maze.data[j][k] << " ";
            }
            cout << endl;
        }
    }
    
    return 0;
}

使用 DFS

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

const int MAXW = 1444;
const int MAXH = 964;

typedef struct _MAZE {
    int w, h;
    int data[MAXH][MAXW];
} MAZE;

MAZE maze;

typedef struct _POS {
    int x,y;
} POS;

void dfs(int x, int y) {
    const POS moves[] = {{-1,0},{0,-1},{1,0},{0,1}};
    int xx, yy;
    for (int i=0; i<4; i++) {
        xx = x+moves[i].x;
        yy = y+moves[i].y;

        if (xx>=0 && xx<=maze.h+1 &&
            yy>=0 && yy<=maze.w+1 &&
            maze.data[xx][yy]>0) {
            maze.data[xx][yy]=0;
            dfs(xx, yy);
        }
    }
}

int main() {
    int n;
    cin >> n;
    
    for (int i=0; i<n; i++) {
        memset(maze.data, 1, sizeof(maze.data));

        cin>>maze.w>>maze.h;
        for (int j=1; j<=maze.h; j++) {
            for (int k=1; k<=maze.w; k++) {
                cin>>maze.data[j][k];
            }
        }

        maze.data[0][0]=0;
        dfs(0, 0);

        //输出
        for (int j=1; j<=maze.h; j++) {
            for (int k=1; k<=maze.w; k++) {
                cout << maze.data[j][k] << " ";
            }
            cout << endl;
        }
    }
    
    return 0;
}

BFS 和 DFS 区别

这类题目最好是使用 BFS。如果使用 DFS，当数据量比较大的时候，DFS 的递归可能导致爆栈。一般来说，当递归深度超过2500 层后，DFS 容易爆栈。

总结

连通性查找问题的结题思路是使用 BFS 或者查并集。而不是使用 DFS。