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

题目

链接

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

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

解决方案

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

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

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

 const int maxn =  + ;
 const int maxm =  + ;
 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 = ;j < m;j++)
     {
         int flagn = -;
         for(int i = ;i < n;i++)
         {
             dn[i][j] = flagn;
             if(maze[i][j] == )  flagn = i;
         }
     }

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

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

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

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

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

 }

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

     init();

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

     return ;
 }