搜索：多源BFS：矩阵距离

多源BFS 转 单源BFS 原理：

首先，我们需要了解到这么一个知识。

求 一个点A，到多个固定的点B,C,D的距离的所有值中 最短距离的这个值。 如果用bfs暴力来求，实际上就是，按照单源BFS的方式，以B作为起点，用BFS走到A的距离,记为dist[1].

以C作为起点，用BFS走到A的距离，记为dist[2].

以D作为起点，用BFS走到A的距离，记为dist[3].

最后求出这些dist的最小值就是答案。

但是实际上，多源BFS可以转变为单源BFS，就是我们新添加一个点H，这个点到B,C,D的距离为0.  于是我们在通过的单源BFS的方式，求出H到A的最短距离即可。

首先H将B,C,D入队，然后不断的去求值。当到达A的时候，就是H到A的最短距离。而H到B,C,D的距离又为0。 所以自然就是B,C,D到A的最短距离值了。

而在写这个BFS的思路的时候，我们并不需要添加这个H点，首先将B,C,D这几个点入队即可。然后按照单源的求就可以了。

题目链接：https://www.acwing.com/problem/content/description/175/

题目：

给你一个大方格，每个小方格中存数字，找这些方格 所有离1最近的距离，最后输出。

输入格式

第一行两个整数 N,M。

接下来一个 N 行 M 列的 01 矩阵，数字之间没有空格。

输出格式

一个 N 行 M 列的矩阵 B，相邻两个整数之间用一个空格隔开。

数据范围

1≤N,M≤1000。

输入样例：

3 4
0001
0011
0110

输出样例：

3 2 1 0
2 1 0 0
1 0 0 1

分析： 

此题也是如此，求每个点，到值为1的点的所有点的距离的最小值。

暴力写就是每个1，走到当前这个点的距离，在求一个min.

但是转为单源就是直接将所有1的点入队，求到所有点最小距离即可。

代码实现：

# include <iostream>
# include <queue>
# include <cstring>
using namespace std;

const int N = 1010;

queue<pair<int,int> > q;

int n,m;

char ch[N][N];
int dist[N][N];

int dx[] = {-1,0,1,0};
int dy[] = {0,1,0,-1};

void bfs()
{
    memset(dist,-1,sizeof dist);
    for(int i = 1 ; i <= n ; i++)
    {
        for(int j = 1 ; j <= m ; j++)
        {
            if(ch[i][j] == '1')
            {
                q.push({i,j});
                dist[i][j] = 0;
            }
        }
    }
    
    while(q.size())
    {
        auto temp = q.front();
        q.pop();
        
        int x = temp.first;
        int y = temp.second;
        
        for(int i = 0 ; i < 4 ; i++)
        {
            int x1 = x + dx[i];
            int y1 = y + dy[i];
            if(x1 < 1 || x1 > n || y1 < 1 || y1 > m)
            {
                continue;
            }
            if(dist[x1][y1] != -1)
            {
                continue;
            }
            q.push({x1,y1});
            dist[x1][y1] = dist[x][y] + 1;
        }
    }
}

int main()
{
    scanf("%d %d",&n,&m);
    for(int i = 1 ; i <= n ; i++)
    {
        for(int j = 1 ; j <= m ; j++)
        {
            cin >> ch[i][j];
        }
    }
    
    bfs();
    
    for(int i = 1 ; i <= n ; i++)
    {
        for(int j = 1 ; j <= m ; j++)
        {
            printf("%d ",dist[i][j]);
        }
        printf("\n");
    }
    return 0;
}