CodeForces 987D Fair BFS_codeforces andrew skipped lessons on the subject '-优快云博客

本文介绍了一个涉及图论和最短路径算法的问题，即如何在不同的城镇间选择最优路径以运输货物，确保至少包含指定种类的商品，并使总花费最小。通过进行多次广度优先搜索（BFS），针对每种商品计算所有城镇到生产该商品城镇的距离。

Some company is going to hold a fair in Byteland. There are $n$ towns in Byteland and $m$ two-way roads between towns. Of course, you can reach any town from any other town using roads.

There are $k$ types of goods produced in Byteland and every town produces only one type. To hold a fair you have to bring at least $s$ different types of goods. It costs $d (u, v)$ coins to bring goods from town $u$ to town $v$ where $d (u, v)$ is the length of the shortest path from $u$ to $v$ . Length of a path is the number of roads in this path.

The organizers will cover all travel expenses but they can choose the towns to bring goods from. Now they want to calculate minimum expenses to hold a fair in each of $n$ towns.

Input

There are $4$ integers $n$ , $m$ , $k$ , $s$ in the first line of input ( $1 \leq n \leq 10^{5}$ , $0 \leq m \leq 10^{5}$ , $1 \leq s \leq k \leq m i n (n, 100)$ ) — the number of towns, the number of roads, the number of different types of goods, the number of different types of goods necessary to hold a fair.

In the next line there are $n$ integers $a_{1}, a_{2}, \dots, a_{n}$ ( $1 \leq a_{i} \leq k$ ), where $a_{i}$ is the type of goods produced in the $i$ -th town. It is guaranteed that all integers between $1$ and $k$ occur at least once among integers $a_{i}$ .

In the next $m$ lines roads are described. Each road is described by two integers $u$ $v$ ( $1 \leq u, v \leq n$ , $u \neq v$ ) — the towns connected by this road. It is guaranteed that there is no more than one road between every two towns. It is guaranteed that you can go from any town to any other town via roads.

Output

Print $n$ numbers, the $i$ -th of them is the minimum number of coins you need to spend on travel expenses to hold a fair in town $i$ . Separate numbers with spaces.

Examples
inputCopy
5 4 3
2 4 3 2
2
3
4
1
5
outputCopy
2 2 2 3 
inputCopy
6 3 2
2 3 3 2 2 1
2
3
4
5
6
7
outputCopy
1 1 2 2 1 1 

Note

Let's look at the first sample.

To hold a fair in town $1$ you can bring goods from towns $1$ ( $0$ coins), $2$ ( $1$ coin) and $4$ ( $1$ coin). Total numbers of coins is $2$ .

Town $2$ : Goods from towns $2$ ( $0$ ), $1$ ( $1$ ), $3$ ( $1$ ). Sum equals $2$ .

Town $3$ : Goods from towns $3$ ( $0$ ), $2$ ( $1$ ), $4$ ( $1$ ). Sum equals $2$ .

Town $4$ : Goods from towns $4$ ( $0$ ), $1$ ( $1$ ), $5$ ( $1$ ). Sum equals $2$ .

Town $5$ : Goods from towns $5$ ( $0$ ), $4$ ( $1$ ), $3$ ( $2$ ). Sum equals $3$ .

这道题对我这个大菜鸡还是很挑战智商的，竟然1A了，使我非常震惊。。。总之，做了k次bfs，每次让k类型的点全部入队，然后计算每一个点到这个类型的距离，之后再把这个距离加入这个点的vector里。做完bfs对每个点的bfs做个排序，取最小的s个数加起来就是结果。

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

int n,m,k,s,head[100005],dist[100005],t[100005];
vector<int> type[105];
vector<int> vec[100005];
bool vis[100005];

struct Edge{
    int to,next;
}edge[200010];
int e=0;
void addedge(int a,int b)
{
    edge[e].to=b;
    edge[e].next=head[a];
    head[a]=e++;
}

struct pos{
    int p;
    int dis;
};

void bfs(int i)
{
    queue<pos> q;
    for (int j=0; j<type[i].size(); j++)
    {
        pos u; u.p=type[i][j]; u.dis=0;
        q.push(u); vis[u.p]=true; dist[u.p]=0;
    }
    while (!q.empty())
    {
        pos u=q.front(); q.pop();
        //cout<<"u="<<u.p<<" t="<<u.dis<<endl;
        for (int j=head[u.p]; j!=-1; j=edge[j].next)
        {
            if (vis[edge[j].to]) continue;
            pos v; v.p=edge[j].to; v.dis=u.dis+1;
            dist[v.p]=v.dis; vis[v.p]=true;
            q.push(v);
        }
    }
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&k,&s);
    for (int i=1; i<=n; i++)
    {
        scanf("%d",&t[i]);
    }
    memset(head,-1,sizeof(head));
    for (int i=1; i<=m; i++)
    {
        int a,b; scanf("%d%d",&a,&b);
        addedge(a,b);
        addedge(b,a);
    }
    for (int i=1; i<=n; i++)
    {
        type[t[i]].push_back(i);
    }
    for (int i=1; i<=k; i++)
    {
        memset(vis,false,sizeof(vis));
        memset(dist,0x3f,sizeof(dist));
        bfs(i);
        for (int i=1; i<=n; i++)
        {
            vec[i].push_back(dist[i]);
        }
    }
    for (int i=1; i<=n; i++)
    {
        sort(vec[i].begin(),vec[i].end());
        long long sum=0;
        for (int j=0; j<s; j++)
        {
            sum+=vec[i][j];
        }
        cout<<sum<<' ';
    }
    return 0;
}