多源单汇问题

《经典问题一》：

若有

　　dist[t][j] 中 t 不是固定的，而j是固定的，我们只要将存储的边反一下，变成普通的单元汇的问题即可

 

《BFS解决的问题》

Problem G. Guard the castle
Input file: standard input
Output file: standard output
Time limit: 1 second
Memory limit: 256 megabytes
zzz 最近在玩一款"守卫城堡"塔防游戏。以下是游戏规则：沙盘上有n个城堡，敌方有m支小队分别潜藏
在不同的城堡之中，单位时间每支小队可以移动到相邻的城堡（当然小队也可以选择不移动）；敌方获
得胜利的条件是，至少k支队伍汇集在同一城堡中。
zzz 现在想知道，敌方获得胜利的最短时间，以便他继续DDL！
Input
第一行包含四个整数n, m, k, e(1 ≤ n ≤ 105
, 1 ≤ k ≤ m ≤ 10, n ≤ e ≤ 2 × 105
)，分别表示：城堡的数量，
敌方小队数量，k见题目描述，道路的数量。
第二行m个不同的整数，分别表示m支小队所在城堡的编号。
接下来e行，每行两个整数u, v(1 ≤ u, v ≤ n, u 6= v)，表示城堡u和v之间有一条道路（可能会有重边）。
Output
一行一个整数表示敌方获得胜利的最短时间，若无法胜利则输出−1。21 6 4 4 6
1 4 5 6
1 3
2 3
2 5
3 4
3 5
5 6
2
6 4 1 6
1 4 5 6
1 3
2 3
2 5
3 4
3 5
5 6
0
5 2 2 3
2 5
1 2
1 3
4 5
-1

权重为1，BFS 的时间复杂度又在O（n）的情况下，不会超时；
基本思路是：
在各个城堡中的队伍同时起跑（BFS）（BFS能在同一时间的情况下向四周发散，相当于一个人能在同一时间内走到四周）
看一下那个点被走了k次以及k次以上，深度就是时间也就是答案

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
const int N = 12, M = 1e5 + 10, INF = 0x3f3f3f3f;
int n, m, k, e;
int stapos[N], dep[N]; // stapos用来记录开始各个小队在的位置；//记录每一个小队到各个点的距离；
bool st[N];
vector<int> g[N];    //保存图
vector<int> cost[M]; //看一下点i被多少个队伍经过,且保存一下进过这个点用的时间；
void bfs(int x)
{
    memset(st, false, sizeof(st));
    memset(dep, 0, sizeof(dep));
    queue<int> q;
    q.push(x);
    st[x] = true;
    while (!q.empty())
    {
        int temp = q.front();
        q.pop();
        for (int node : g[temp])
        {
            if (!st[node])
            {
                st[node] = true;
                dep[node] = dep[temp] + 1;
                cost[node].push_back(dep[node]);
                q.push(node);
            }
        }
    }
}
int main()
{
    cin >> n >> m >> k >> e;
    for (int i = 1; i <= m; i++)
        cin >> stapos[i];
    int a, b;
    for (int i = 1; i <= e; i++)
    {
        scanf("%d%d", &a, &b);
        g[a].push_back(b), g[b].push_back(a);
    }
    for (int i = 1; i <= m; i++)
    {
        cost[stapos[i]].push_back(0);
        bfs(stapos[i]);
    }
    int ans = INF;
    for (int i = 1; i <= n; i++)
    {
        if (cost[i].size() >= k)
        {
            /* int temp=0,count=0;
            for (int j:cost[i])
            {
                temp=max(cost[i][j],temp);
                count++;
                if (count>=k) break;
            }
            ans=min(ans,temp); */
            //上面写的太复杂，优化：
            sort(cost[i].begin(), cost[i].end());
            ans=min(ans,cost[i][k-1]);//因为vector是从0开始存储的，所以k-1;
        }
    }
    if (ans == INF)
        printf("-1\n");
    else
        printf("%d\n", ans);
    return 0;
}