【算法】多源 BFS

1. 单源最短路问题 vs 多源最短路问题

• 当问题中只存在一个起点时，这时的最短路问题就是单源最短路问题。
• 当问题中存在多个起点而不是单一起点时，这时的最短路问题就是多源最短路问题。

2. 多源 BFS：多源最短路问题的边权都为 1 时，此时就可以用多源 BFS 来解决
3. 解决方式：把这些源点汇聚在一起，当成一个 “超级源点”。然后从这个 “超级源点” 开始，处理最短路问题。落实到代码上时：

• 初始化的时候，把所有的源点都加入到队列里面。
• 然后正常行 bfs 的逻辑即可。

也就是初始化的时候，比普通的 bfs 多加入几个起点。

1.矩阵距离

矩阵距离

解法：多源 BFS

曼哈顿距离本质：最短路

正难则反思想：

1. 如果针对某一个点，直接去找最近的 1，我们需要对所有的 0 都来一次 bfs，这个时间复杂度是接受不了的。
2. 但是我们如果反着来想，从 1 开始向外扩展，每遍历到一个 0 就更新一下最短距离。这样仅需一次 bfs，就可以把所有点距离 1 的最短距离更新出来。

由于 1 的数量很多，因此可以把所有的 1 看成一个超级源点，从这个超级源点开始一层一层的向外扩展。实现起来也很简单，就是在初始化阶段把所有 1 的坐标加入到队列中，然后正常 bfs 即可。

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

typedef pair<int, int> PII;

const int N = 1e3 + 10;

int n, m;
char a[N][N];
int dist[N][N];

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

void bfs()
{
    memset(dist, -1, sizeof(dist));
    
    queue<PII> q;
    //1.将所有的起点丢进队列中
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(a[i][j] == '1')
            {
                q.push({i, j});
                dist[i][j] = 0;
            }
        }
    }
    
    //2.BFS
    while(!q.empty())
    {
        auto t = q.front(); q.pop();
        int i = t.first, j = t.second;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 1 && x <= n && y >= 1 && y <= m && dist[x][y] == -1)
            {
                dist[x][y] = dist[i][j] + 1;
                q.push({x, y});
            }
        }
    }
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cin >> a[i][j];
        }
    }
    
    bfs();
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cout << dist[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}

2.刺杀大使

P1902 刺杀大使

解法：多源 BFS

直接找答案显然是不现实的，因为能走的路径实在是太多了，如果全都枚举出来时间上吃不消。但是题目要求的是最大值最小化，可以尝试用二分来优化枚举。

设最终结果是 x，会发现一个性质：

1. 当规定搜索过程中的最大值大于等于 x 时，我们一定可以从第一行走到最后一行。
2. 当规定搜索过程中的最大值小于 x 时，我们一定不能走到最后一行。

因此，我们可以二分最终结果，通过 bfs 或者 dfs 来判断是否能走到最后一行。

如果用 dfs，那就从第一行的每一列开始，全都搜索一遍。如果用 bfs，可以看成多源 bfs 问题，直接把所有的源点加入队列中，然后正常搜索即可。

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

typedef pair<int, int> PII;

const int N = 1e3 + 10;

int n, m;
int a[N][N];
bool st[N][N]; //在宽搜的过程中, 不走重复的路

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

//在伤害不超过mid的情况下, 是否能到达第n行
bool bfs(int mid)
{
    if(n == 1) return true;
    memset(st, 0, sizeof(st));
    
    queue<PII> q;
    //1.将所有的源点丢进队列中
    for(int j = 1; j <= m; j++)
    {
        q.push({1, j});
        st[1][j] = true;
    }
    
    while(!q.empty())
    {
        auto t = q.front(); q.pop();
        int i = t.first, j = t.second;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 1 && x <= n && y >= 1 && y <=m && a[x][y] <= mid && st[x][y] == false)
            {
                q.push({x, y});
                st[x][y] = true;
                
                if(x == n) return true;
            }
        }
    }
    return false;
}

int main()
{
    cin >> n >> m;
    int left = 0, right = 0;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cin >> a[i][j];
            right = max(right, a[i][j]);
        }
    }
    
    //二分答案
    while(left < right)
    {
        int mid = (left + right) / 2;
        if(bfs(mid)) right = mid;
        else left = mid + 1;
    }
    cout << left << endl;
    
    return 0;
}