2019南昌网络赛 B. Fire-Fighting Hero

最新推荐文章于 2021-03-09 21:14:06 发布

_Tiramisu

最新推荐文章于 2021-03-09 21:14:06 发布

阅读量351

点赞数

分类专栏：最短路文章标签：最短路

本文链接：https://blog.csdn.net/qq_40741550/article/details/100637757

版权

最短路专栏收录该内容

1 篇文章 0 订阅

订阅专栏

B. Fire-Fighting Hero

题目链接:https://nanti.jisuanke.com/t/41349

Problem Description

This is an era of team success, but also an era of heroes. Throughout the ages, there have been numerous examples of using the few to defeat the many. There are $V$ (Numbers $1$ to $V$ ) fire-fighting points in ACM city. These fire-fighting points have $E$ roads to communicate with each other. Among them, there is a fire-fighting hero in the $S$ fire-fighting point, and the fire-fighting team is distributed in $K$ fire-fighting points. If a fire-fighting point needs to be put out, the fire-fighting hero or the fire-fighting team must arrive as soon as possible, that is, to choose the shortest route to arrive.
Today, our fire-fighting heroes want to challenge the fire-fighting team. The challenge is to: The maximum value of the shortest path for a fire-fighting hero to go to others fire-fighting points is compared with the maximum value of the shortest path for a fire-fighting team to go to others fire-fighting points from any point in their fire-fighting points. Because firefighting heroes are different and run faster, the maximum value of the shortest path they get should be discounted first, that is, multiplied by a coefficient of $\frac{1}{C}$ , and then compared. The smaller one wins. Who is the real firefighter in this situation?
Who is the real firefighter in this situation?

Input

The first line contains a positive integer $(1\le T \le 10)$ , which indicates that there are $T$ cases of test data.
The format of each case of test data is as follows:

Line $1$ contains five positive integers $\le V \le 1000)$ , $\le E \le \frac{V*V}{2})$ , $\le S \le V)$ , $(1\le K \le V)$ and $(1\le C\le 10)$ , the meanings are shown above.
Line $2$ contains $K$ positive integers, which in turn denotes the location number of the fire-fighting point where the fire-fighting team is located.

In the next $E$ line, three positive integers $\le i, j \le V)$ and $\le L \le 10000)$ per line. Represents a path, $i, j$ as the endpoint (fire-fighting point), $L$ as the length of the path.

Output

Each case of test data outputs one line, which is a integer. That is, the maximum value of the shortest path of the winner (If the fire hero wins, the maximum value before the discount should be output). A draw is also a victory for fire-fighting hero.

Sample Input

1
4 7 3 2 2
1 4
1 2 7
1 3 2
1 4 6
2 1 1
2 4 1
3 2 1
3 4 3

Sample Output

2

题意

有 $T$ 组数据，每组数据有 $V$ 个消防点， $E$ 条无向边， $S$ 代表消防英雄所在的消防点，有 $K$ 支消防队和一个 $C$ 。
然后给你 $K$ 支消防队所在的消防点和 $E$ 条无向边。设消防英雄到各消防点最短路径的最大值为 $a n s 1$ ，消防队到各消防点最短路径的最大值为 $a n s 2$ ，这里可能会理解错（~~反正我理解错了~~ ），换句话说 $max\{min_i\}(1 \le i \le V)$ ，其中 $min_i$ 代表所有消防队到消防点 $i$ 的最短路径的最小值。如果 $\frac{ans1}{C} \le ans2$ 就输出 $a n s 1$ ，否则输出 $a n s 2$ 。
输入保证图联通。

思路

以 $s$ 为起点跑一次最短路找到消防英雄到各消防点最短路径的最大值 $a n s 1$ ，再通过虚拟一个起点来连接 $k$ 个消防队所在的消防点跑一次最短路找到所有消防队到各消防点最短路径的最大值 $a n s 2$ ，最后比较 $a n s 1$ 和 $a n s 2 * c$ 的大小即可。

代码

#include <bits/stdc++.h>
#define pi acos(-1.0)
#define ll long long
#define ull unsigned long long
#define esp 1e-9
#define inf 0x3f3f3f3f
#define inff 0x3f3f3f3f3f3f3f3f
#define Pair pair<ll, ll>
#define It list<node>::iterator
    
using namespace std;

const ll N = 1e3+5;

struct node{
	ll u, v, dis;
};

struct HeapNode{
	ll dis, u;
	bool operator < (const HeapNode &rhs) const{
		return dis > rhs.dis;
	}
};

struct Dijkstra{
	ll n, dis[N], pre[N], vis[N];
	vector<ll> G[N];
	vector<node> edge;
	void init(ll n){
		this->n = n; edge.clear();
		for (ll i = 0; i <= n; i++){
			G[i].clear();
		}
	}
	void add(ll u, ll v, ll dis){
		edge.push_back((node){u, v, dis});
		G[u].push_back(edge.size()-1);
	}
	void solve(ll s){
		priority_queue<HeapNode> que;
		memset(vis, 0, sizeof(vis));
		for (ll i = 0; i <= n; i++){
			dis[i] = inff;
		}
		dis[s] = 0;
		que.push((HeapNode){0, s});
		while (!que.empty()){
			HeapNode x = que.top(); que.pop();
			ll u = x.u;
			if (!vis[u]){
				vis[u] = true;
				for (ll i = 0; i < G[u].size(); i++){
					node &e = edge[G[u][i]];
					if (dis[e.v] > dis[u]+e.dis){
						dis[e.v] = dis[u]+e.dis;
						pre[e.v] = G[u][i];
						que.push((HeapNode){dis[e.v], e.v});
					}
				}
			}
		}
	}
};

ll arr[N], ans[N];
ll T, n, m, s, k, c, u, v, l, a, b;
Dijkstra dij;

int main(){
	ios::sync_with_stdio(false);
	cin>>T;
	while (T--){
		cin>>n>>m>>s>>k>>c;
		a = b = 0; dij.init(n);
		for (ll i = 1; i <= k; i++){
			cin>>arr[i];
		}
		while (m--){
			cin>>u>>v>>l;
			dij.add(u, v, l); dij.add(v, u, l);
		}
		dij.solve(s);
		for (ll i = 1; i <= n; i++){
			ans[i] = inff;
			a = max(a, dij.dis[i]);
		}
		for (ll i = 1; i <= k; i++){
			dij.add(0, arr[i], 0); dij.add(arr[i], 0, 0);
		}
		dij.solve(0);
		for (ll j = 1; j <= n; j++){
			b = max(b, dij.dis[j]);
		}
		if (a <= b*c){
			cout<<a<<endl;
		}
		else{
			cout<<b<<endl;
		}
	}
    return 0;
}