CF187C(堆优化BFS)

 题意：
给你一个n个点m条边的图，其中有k个节点是特殊的，起点s一定是特殊的，现在让你从s到t，每个特殊点可以加q点能量，经过一条边需要花费1点能量，求能从s到t时q最小为多少？（如果不能到达，输出-1）

思路:

首先能想到二分答案,然后我最开始想用floyd预处理+最小生成树,但是点数太多,于是用堆优化BFS,每次选择剩余次数最多的进行拓展,如果遇到志愿者就添加次数

代码:

#include <bits/stdc++.h>
#define int long long
#define IOS ios::sync_with_stdio(false), cin.tie(0) 
#define ll long long 
// #define double long double
#define ull unsigned long long 
#define PII pair<int, int> 
#define PDI pair<double, int> 
#define PDD pair<double, double> 
#define debug(a) cout << #a << " = " << a << endl 
#define point(n) cout << fixed << setprecision(n)
#define all(x) (x).begin(), (x).end() 
#define mem(x, y) memset((x), (y), sizeof(x)) 
#define lbt(x) (x & (-x)) 
#define SZ(x) ((x).size()) 
#define inf 0x3f3f3f3f 
#define INF 0x3f3f3f3f3f3f3f3f
namespace nqio{const unsigned R = 4e5, W = 4e5; char *a, *b, i[R], o[W], *c = o, *d = o + W, h[40], *p = h, y; bool s; struct q{void r(char &x){x = a == b && (b = (a = i) + fread(i, 1, R, stdin), a == b) ? -1 : *a++;} void f(){fwrite(o, 1, c - o, stdout); c = o;} ~q(){f();}void w(char x){*c = x;if (++c == d) f();} q &operator >>(char &x){do r(x);while (x <= 32); return *this;} q &operator >>(char *x){do r(*x); while (*x <= 32); while (*x > 32) r(*++x); *x = 0; return *this;} template<typename t> q&operator>>(t &x){for (r(y),s = 0; !isdigit(y); r(y)) s |= y == 45;if (s) for (x = 0; isdigit(y); r(y)) x = x * 10 - (y ^ 48); else for (x = 0; isdigit(y); r(y)) x = x * 10 + (y ^ 48); return *this;} q &operator <<(char x){w(x);return *this;}q &operator<< (char *x){while (*x) w(*x++); return *this;}q &operator <<(const char *x){while (*x) w(*x++); return *this;}template<typename t> q &operator<< (t x) {if (!x) w(48); else if (x < 0) for (w(45); x; x /= 10) *p++ = 48 | -(x % 10); else for (; x; x /= 10) *p++ = 48 | x % 10; while (p != h) w(*--p);return *this;}}qio; }using nqio::qio;
using namespace std;
const int N = 1e5 + 10;
int n, m, k, S, T, d[N];
vector<int> g[N];
bool ok[N];
struct BFS {
	int p, val;
	bool operator <(const BFS& i) const {
		return val < i.val;
	}
};
bool check(int x) {
	mem(d, -1);
	priority_queue<BFS> heap;
	heap.push({S, x});
	d[S] = x;
	//注意,这里的算法虽然跟dij一样,有松弛操作,但是这严格上来说,并不是dij算法,因为这里有添加容量的操作,而dij算法的容量都是固定的
	//因此,这里的每个点不一定只能被扩展一次,即作为松弛操作的中介点
	//除此之外,还需要注意的是,我们消耗容量和添加容量这两步操作一定得在入队前和出队后做,因为一个点可能被同时多个点松弛,也就是在队列中,
	//会有多个加过容量的点,此时当其中一个点拿出来对其他点松弛时,有可能松弛到队列中的点,此时就相当于队列中的点被加了两次容量,这样就混乱了
	while (heap.size()) {
		auto [p, val] = heap.top(); heap.pop();
		if (ok[p]) val = x;
		if (p == T) return true;
		if (val == 0) continue;
		d[p] = val;
		for (int x : g[p]) if (val - 1 > d[x]) d[x] = val - 1, heap.push({x, val - 1});
	}
	return ~d[T];
}
void solve() {
	qio >> n >> m >> k;
	for (int i = 1, x; i <= k; ++i) qio >> x, ok[x] = 1;
	for (int i = 1; i <= m; ++i) {
		int a, b;
		qio >> a >> b;
		g[a].emplace_back(b);
		g[b].emplace_back(a);
	}
	qio >> S >> T;
	int l = 0, r = 1e6;
	while (l < r) {
		int mid = l + r >> 1;
		if (check(mid)) r = mid;
		else l = mid + 1;
	}
	qio << (check(l) ? l : -1) << "\n";
}
signed main()  {
	// IOS;
	int T = 1;
	// qio >> T;
	while (T--) solve();
}