[leetcode]2258. 逃离火灾(多源BFS+贡献法+二分答案)

题意

给定$n\times m$的地图
0 表示草地。
1 表示着火的格子
2 表示一座墙

火每分钟会按照四联通蔓延到草地上
人每分钟可以走一步 从左上角出发 到右下角
每分钟是人先走 火再蔓延 但是人不能走到某个格子上 同一分钟火就烧到这个点上来了

注意:走到终点时 同一分钟火烧上来的话没关系
这个情况 需要特殊处理

求人最多能在起点呆着不走多少分钟，然后还能安全到达终点

思路

这题我的思路来的特别快 很顺利地就做出来了
这题跟校赛的演唱会差不多
bfs计算出每个点着火的时间点

然后再二分答案+对人bfs

Code

下面是我写的第一版 能通过 但是时间复杂度很高

#define pii pair<int,int>
#define ar2 array<int,2>
#define ar3 array<int,3>
#define ar4 array<int,4>
#define endl '\n'
void cmax(int &a,int b){a=max(a,b);};
void cmin(int &a,int b){a=min(a,b);};
const int N=310,MOD=1e9+7,INF=0x3f3f3f3f;const long long LINF=LLONG_MAX;const double eps=1e-6;

int dx[]={-1,0,1,0},dy[]={0,1,0,-1};
int g[N][N],dis[N][N],n,m;

class Solution {
public:
    int maximumMinutes(vector<vector<int>>& grid) {
        n=grid.size(),m=grid[0].size();
        memset(dis,0x3f,sizeof dis);
        //dis数组表示每个点着火时间 永远不会着火就是INF
        
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++) g[i+1][j+1]=grid[i][j];
        
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(g[i][j]==1){
                    dis[i][j]=0;
                    bfs(i,j);//对每个火源bfs
                }
            }
        }

        
        int l=-1,r=1e9;
        if(check(r)) return r;
        //无论在起点呆多久都能到达终点就返回 1e9
        r=n*m;
        while(l+1!=r){
            int mid=l+r>>1;
            if(check(mid)) l=mid;
            else r=mid;
        }
        if(check(l)) return l;
        return -1;//永远无法到达终点就返回-1
        
    }
    
    void bfs(int sx,int sy){
        vector<vector<bool>>vis(N,vector<bool>(N));
        queue<ar3>q;
        q.push({sx,sy,0});
        vis[sx][sy]=1;

        while(q.size()){
            auto [x,y,d]=q.front();q.pop();
            
            for(int i=0;i<4;i++){
                int tx=x+dx[i],ty=y+dy[i];
                if(tx<1||tx>n||ty<1||ty>m||g[tx][ty]!=0||vis[tx][ty]) continue;
                vis[tx][ty]=1;
                if(dis[tx][ty]>d+1){
                    q.push({tx,ty,d+1});
                    dis[tx][ty]=d+1;
                }
            }
        }
    }

    bool check(int mid){
        vector<vector<bool>>vis(N,vector<bool>(N));
        queue<ar3>q;
        q.push({1,1,mid});
        vis[1][1]=1;

        while(q.size()){
            auto [x,y,steps]=q.front();q.pop();
            if(x==n&&y==m) return 1;
            
            for(int i=0;i<4;i++){
                int tx=x+dx[i],ty=y+dy[i];
                if(tx<1||tx>n||ty<1||ty>m||vis[tx][ty]||g[tx][ty]!=0) continue;
                if(dis[tx][ty]>steps+1||(tx==n&&ty==m&&dis[tx][ty]>=steps+1)){ 
                //注意特殊处理终点 到达终点时火可以同时到达
                    vis[tx][ty]=1;
                    q.push({tx,ty,steps+1});
                }
            }
        }

        return 0;
    }


    
};

然而这样时间复杂度太高了
每次bfs扩展火源 最坏复杂度为$O(nm)$
最坏有$nm$个火源 需要bfs $nm$次
二分时间复杂度$O(lognm)$
总复杂度最坏为$O(n^2{m}^2)$

事实上 不需要对每个火源单独bfs
可以把所有火源全都入队 然后去掉vis数组 因为每个dis只会在第一次被更新时是最小的 以后再到这个点只会更久

优化后

#define pii pair<int,int>
#define ar2 array<int,2>
#define ar3 array<int,3>
#define ar4 array<int,4>
#define endl '\n'
void cmax(int &a,int b){a=max(a,b);};
void cmin(int &a,int b){a=min(a,b);};
const int N=310,MOD=1e9+7,INF=0x3f3f3f3f;const long long LINF=LLONG_MAX;const double eps=1e-6;

int dx[]={-1,0,1,0},dy[]={0,1,0,-1};
int g[N][N],dis[N][N],n,m;

class Solution {
public:

    int maximumMinutes(vector<vector<int>>& grid) {
        n=grid.size(),m=grid[0].size();
        memset(dis,0x3f,sizeof dis);
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++) g[i+1][j+1]=grid[i][j];
        }

        queue<ar3>q;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(g[i][j]==1){
                    dis[i][j]=0;
                    q.push({i,j,0});//所有火源入队
                }
            }
        }
        bfs(q);
        
        int l=-1,r=1e9;
        if(check(r)) return r;
        r=n*m;
        while(l+1!=r){
            int mid=l+r>>1;
            if(check(mid)) l=mid;
            else r=mid;
        }
        if(check(l)) return l;
        return -1;
    }
    
    void bfs(queue<ar3>&q){
        while(q.size()){
            auto [x,y,d]=q.front();q.pop();
            
            for(int i=0;i<4;i++){
                int tx=x+dx[i],ty=y+dy[i];
                if(tx<1||tx>n||ty<1||ty>m||g[tx][ty]!=0||dis[tx][ty]!=INF) continue;
                //如果dis被更新过了 就continue
                
                // if(dis[tx][ty]>d+1){
                //不需要这句if， 第一次更新一定是最小的
                    q.push({tx,ty,d+1});
                    dis[tx][ty]=d+1;
                // }
            }
        }
    }

    bool check(int mid){
        vector<vector<bool>>vis(N,vector<bool>(N));
        queue<ar3>q;
        q.push({1,1,mid});
        vis[1][1]=1;

        while(q.size()){
            auto [x,y,steps]=q.front();q.pop();
            if(x==n&&y==m) return 1;
            
            for(int i=0;i<4;i++){
                int tx=x+dx[i],ty=y+dy[i];
                if(tx<1||tx>n||ty<1||ty>m||vis[tx][ty]||g[tx][ty]!=0) continue;
                if(dis[tx][ty]>steps+1||(tx==n&&ty==m&&dis[tx][ty]>=steps+1)){ 
                    vis[tx][ty]=1;
                    q.push({tx,ty,steps+1});
                }
            }
        }

        return 0;
    }
};

代码分析

• 其实就改了一个扩展火源的bfs
• 多源bfs 一开始就把所有火源入队 只需要一次bfs
• bfs最坏访问所有$nm$个点 所以这部分复杂度从$O(n^2{m}^2)$降至了$O(nm)$ 每个点其实只需要访问一次 因为第一次扩展到这个点时 一定是最小的 这是bfs的扩展方式决定的
• 二分答案复杂度一样$O(lognm)$
• 所以总复杂度为$O(nmlognm)$
• 快了非常多 从1200ms 到70ms