引爆炸弹——DFS&&联通块

题目

链接

在一个$n imes m$方格地图上，某些方格上放置着炸弹。手动引爆一个炸弹以后，炸弹会把炸弹所在的行和列上的所有炸弹引爆，被引爆的炸弹又能引爆其他炸弹，这样连锁下去。

现在为了引爆地图上的所有炸弹，需要手动引爆其中一些炸弹，为了把危险程度降到最低，请算出最少手动引爆多少个炸弹可以把地图上的所有炸弹引爆。

解决方案

由于炸弹连锁，问题等价于求图中的联通块，只是此处的不只是相邻的炸弹联通，同行或同列也是广义的联通。

值得注意的是，寻找“相邻”炸弹时不能挨个查找（会超时），需要先预处理每个炸弹的“东”、“西”、“南”、“北”相邻炸弹的位置。

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1000 + 10;
const int maxm = 1000 + 10;
int n,m;
bool maze[maxn][maxm];
bool r[maxn], c[maxm];
char s[maxm];
int dn[maxn][maxm], ds[maxn][maxm], dw[maxn][maxm], de[maxn][maxm];

void init()
{
    //memset(dn, -1, sizeof(dn));
    //memset(ds, -1, sizeof(ds));
    //memset(dw, -1, sizeof(dw));
    //memset(de, -1, sizeof(de));
    for(int j = 0;j < m;j++)
    {
        int flagn = -1;
        for(int i = 0;i < n;i++)
        {
            dn[i][j] = flagn;
            if(maze[i][j] == 1)  flagn = i;
        }
    }

    for(int j = 0;j < m;j++)
    {
        int flags = -1;
        for(int i = n-1;i >= 0;i--)
        {
            ds[i][j] = flags;
            if(maze[i][j] == 1)  flags = i;
        }
    }

    for(int i = 0;i < n;i++)
    {
        int flagw = -1;
        for(int j = 0;j < m;j++)
        {
            dw[i][j] = flagw;
            if(maze[i][j] == 1)  flagw = j;
        }
    }

    for(int i = 0;i < n;i++)
    {
        int flage = -1;
        for(int j = m - 1;j >= 0;j--)
        {
            de[i][j] = flage;
            if(maze[i][j] == 1)  flage = j;
        }
    }
}

int cnt = 0;
void dfs(int i, int j)
{
    //printf("%d %d
", i, j);
    maze[i][j] = 0;
    r[i] = c[j] = true;

    if(dn[i][j] != -1 && maze[dn[i][j]][j] == 1)  dfs(dn[i][j], j);
    if(ds[i][j] != -1 && maze[ds[i][j]][j] == 1)  dfs(ds[i][j], j);
    if(dw[i][j] != -1 && maze[i][dw[i][j]] == 1)  dfs(i, dw[i][j]);
    if(de[i][j] != -1 && maze[i][de[i][j]] == 1)  dfs(i, de[i][j]);

}


int main()
{
    scanf("%d%d", &n,&m);
    for(int i = 0;i < n;i++)
    {
        scanf("%s", s);
        for(int j = 0;j < m;j++)  maze[i][j] = s[j] - '0';
    }

    init();

    int ans = 0;
    for(int i = 0;i <n;i++)
        for(int j = 0;j < m;j++)
        {
            if(maze[i][j] == 1 && (!r[i]) && (!c[j]))  //出现过的行和列肯定不可能再存在“未爆炸”的炸弹
            {
                dfs(i, j);
                ans++;
            }
        }
    printf("%d
", ans);

    return 0;
}