矩阵中任意多个点到某一点最短距离

广度优先搜索一层一层找两点最短距离返回，遍历矩阵每个点到各要求输入点的距离存入最远距离，取每个点最小值取为到输入点的最短距离。

//输入 
5 5 
0 0 0 0 0
8 8 8 0 0
0 0 8 0 0
8 8 8 8 0
0 0 0 0 0 

4 
1 1 
1 5 
5 1 
5 5 

#include 
#include 
#include 

using namespace std;

vector direction{-1, 0, 1, 0, -1};

void dfs(queue>& points, vector> &grid, int m, int n
        , int i, int j) {
    if (i < 0 || j < 0 || i == m || j == n || grid[i][j] == 2 || grid[i][j] == 8) {
        return;
    }
    if (grid[i][j] == 0) {
        points.push({i, j});
        return;
    }
    grid[i][j] = 2;
    dfs(points, grid, m, n, i - 1, j);
    dfs(points, grid, m, n, i + 1, j);
    dfs(points, grid, m, n, i, j - 1);
    dfs(points, grid, m, n, i, j + 1);
}


int shortestDist(vector> grid,int x1,int y1,int x2,int y2) {

    grid[x2][y2] = 1;

    int m = grid.size(), n = grid[0].size();
    queue> points;
    points.push({x1, y1});
    grid[x1][y1] = 2;

// bfs寻找grid[x2][y2]，并把过程中经过的0赋值为2
    int x, y;
    int level = 0;
    while (!points.empty()){
        ++level;
        int n_points = points.size();
        while (n_points--) {
            auto [r, c] = points.front();
            points.pop();
            for (int k = 0; k < 4; ++k) {
                x = r + direction[k], y = c + direction[k+1];
                if (x >= 0 && y >= 0 && x < m && y < n) {
                    if (grid[x][y] == 2) {
                        continue;
                    }
                    if (grid[x][y] == 8) {          //障碍
                        continue;
                    }
                    if (grid[x][y] == 1) {          //找到另一端
                        return level;
                    }
                    points.push({x, y});
                    grid[x][y] = 2;
                }
            }
        }
    }
    return -1;          //不通
}

int judge(vector> data,vector> &input)
{
    int min = INT_MAX;
    for(int i=0;i max )
                min = max;

        }
    }
    return min;
}


int main()
{

    freopen("D:\desktop\Leecode_dbg\data.txt","r",stdin);
    int m,n;
    cin>>m>>n;
    vector> dist(m,vector(n));
    for(int i=0;i>dist[i][j];
        }
    }
    int k;
    cin>>k;
    vector> loc(k,vector(2));

    for(int i=0;i>temp;
            loc[i][j] = temp -1;
        }
    }

    cout<