B - Labyrinth Gym - 102798B

B - Labyrinth Gym - 102798B

题意：

n * m的地图，有k个障碍物，给你起点到终点，从起点到终点的最短距离
1<=n,m<=200000
nm<=200000
0<=k<=42
1<=q<=100000

题解：

如果没有障碍物，两点之间的最短距离就是曼哈顿距离
如果有障碍物，最短距离就是贴着障碍物走
直接暴力肯定不行 ，我们可以看到k的数量很小，每个障碍物上下左右有四个点，然后求这个四个点分别到其他点的距离，然后答案就是起点到障碍物(上下左右四个方向)的距离+障碍物到终点，取最小值
所有我们要开一个思维数组
dis[d][i][x][y]:第i个障碍物的第d个方向到点(x,y)的距离，我们用vector第三四维是动态开空间，避免超内存

代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>

using namespace std;

const int INF = 0x3f3f3f3f;
int dirx[4] = {0,0,-1,1};
int diry[4] = {1,-1,0,0};
vector<vector<int>>dis[4][44];
int n,m,k,q;

struct Point {
    int x,y;
}black[55];

map<pair<int,int>,int>mp;

int judge(int x,int y) {//判断点是否超出地图 
    if(x <= 0 || y <= 0 || x > n || y > m) return true;
    return false;
}

void bfs() {
    for(int i = 1;i <= k;i++) {
        int x = black[i].x,y = black[i].y;
        for(int d = 0;d < 4;d++) {
            int dx = x + dirx[d];
            int dy = y + diry[d];
            dis[d][i].resize(n + 1);//第三维开n+1的空间
            for(int ci = 1;ci <= n;ci++) {//初始化所有距离
                dis[d][i][ci].resize(m + 1);
                for(int cj = 1;cj <= m;cj++) {
                    dis[d][i][ci][cj] = INF;
                }
            }
            if(judge(dx,dy)) continue;
            if(mp.count({dx,dy})) continue;
            
            dis[d][i][dx][dy] = 0;
            queue<pair<int,int>>Q;
            Q.push({dx,dy});
            while(!Q.empty()) {//开始跑bfs  
                pair<int,int> now = Q.front();Q.pop();
                int x = now.first,y = now.second;
                for(int cd = 0;cd < 4;cd++) {
                    int dx = x + dirx[cd];
                    int dy = y + diry[cd];
                    if(judge(dx,dy)) continue;
                    if(dis[d][i][dx][dy] != INF) continue;
                    if(mp.count({dx,dy})) continue;
                    dis[d][i][dx][dy] = dis[d][i][x][y] + 1;
                    Q.push({dx,dy});
                }
            }
        }
    }
}

bool check(int x1,int y1,int x2,int y2) { //这个区域内是否有黑洞
    if(x1 > x2) swap(x1,x2);
    if(y1 > y2) swap(y1,y2);
    for(int i = 1;i <= k;i++) {
        if(black[i].x <= x2 && black[i].x >= x1 && black[i].y <= y2 && black[i].y >= y1) return true;
    }
    return false;
}


int main() {
    scanf("%d%d%d%d",&n,&m,&k,&q);
    for(int i = 1;i <= k;i++) {
        scanf("%d%d",&black[i].x,&black[i].y);
        mp[{black[i].x,black[i].y}] = 1;
    }
    
    bfs();

    for(int i = 1;i <= q;i++) {
        int x1,y1,x2,y2;scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        if(check(x1,y1,x2,y2)) {
            int ans = 0x3f3f3f3f;
            for(int j = 1;j <= k;j++) {
                for(int d = 0;d < 4;d++) {
                    int dx = black[j].x + dirx[d];
                    int dy = black[j].y + diry[d];
                    if(judge(dx,dy)) continue;
                    ans = min(ans,dis[d][j][x1][y1] + dis[d][j][x2][y2]);
                }
            }
            if(ans == INF) printf("-1\n");
            else printf("%d\n",ans);
            
        } else {//如果没有黑洞，直接曼哈顿距离 
            printf("%d\n",abs(x1 - x2) + abs(y1 - y2));
        }
    }
    return 0;
}