题解 旅行

传送门

以前见过的套路……但分的时间太少了

首先发现可以每次用 \(dis_i+c_i\) 最小的 \(i\) 更新其它点
随即发现每个点只有第一次被更新是有用的
于是考虑点分树优化建图
对每个点分树上的点扫出子树内的点并排序，单调指针即可
由于有个排序在复杂度是 \(O(n\log^2 n)\) 的
也许可以换成计数排序
不过不用 vector 就可以卡过了

点击查看代码

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define N 200100
#define fir first
#define sec second
#define pb push_back
#define ll long long
// #define int long long

char buf[1<<21], *p1=buf, *p2=buf;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf, 1, 1<<21, stdin)), p1==p2?EOF:*p1++)
inline int read() {
	int ans=0, f=1; char c=getchar();
	while (!isdigit(c)) {if (c=='-') f=-f; c=getchar();}
	while (isdigit(c)) {ans=(ans<<3)+(ans<<1)+(c^48); c=getchar();}
	return ans*f;
}

int n, m;
bool intr[N];
pair<int, int> g[N];
vector<pair<int, int>> to[N];
// map<pair<int, int>, int> mp;
int head[N], d[N], c[N], ecnt;
struct edge{int to, next;}e[N<<1];
inline void add(int s, int t) {e[++ecnt]={t, head[s]}; head[s]=ecnt;}

// namespace force{
// 	ll dis[N];
// 	bool vis[N], vis2[N];
// 	vector<int> to;
// 	priority_queue<pair<int, int>> q;
// 	void dfs(int u, int dis) {
// 		// cout<<"dfs: "<<u<<' '<<dis<<endl;
// 		vis[u]=1; to.pb(u);
// 		if (!dis) return ;
// 		for (int i=head[u],v; ~i; i=e[i].next) {
// 			v = e[i].to;
// 			if (!vis[v]) dfs(v, dis-1);
// 		}
// 	}
// 	void solve() {
// 		memset(dis, 0x3f, sizeof(dis));
// 		q.push({0, 1}); dis[1]=0;
// 		while (q.size()) {
// 			pair<int, int> u=q.top(); q.pop();
// 			if (vis2[u.sec]) continue;
// 			vis2[u.sec]=1;
// 			to.clear();
// 			for (int i=1; i<=n; ++i) vis[i]=0;
// 			dfs(u.sec, d[u.sec]);
// 			for (auto v:to) if (dis[u.sec]+c[u.sec]<dis[v]) {
// 				dis[v]=dis[u.sec]+c[u.sec];
// 				q.push({-dis[v], v});
// 			}
// 		}
// 		for (int i=2; i<=n; ++i) printf("%lld\n", dis[i]);
// 	}
// }

namespace task{
	ll ans[N];
	bool vis[N], del[N];
	int siz[N], msiz[N], pos[N], pos2[N], canc[N], clink[N], rot;
	pair<int, int> anc[N][100], link[N][60];
	vector<pair<int, int>> sta[N], sta2[N];
	priority_queue<pair<ll, int>> q;
	void build(int u) {
		vis[u]=1;
		for (auto& v:to[u])
			if (!vis[v.fir]) {
				add(u, v.fir), add(v.fir, u), build(v.fir);
				intr[v.sec]=1;
				// intr[mp[{min(u, v), max(u, v)}]]=1;
			}
	}
	void getrt(int u, int fa, int tot) {
		siz[u]=1; msiz[u]=0;
		for (int i=head[u],v; ~i; i=e[i].next) {
			v = e[i].to;
			if (v==fa||del[v]) continue;
			getrt(v, u, tot);
			siz[u]+=siz[v];
			msiz[u]=max(msiz[u], siz[v]);
		}
		msiz[u]=max(msiz[u], tot-siz[u]);
		if (msiz[u]<msiz[rot]) rot=u;
	}
	void getdis(int u, int fa, int c, int d) {
		anc[u][++canc[u]]={c, d}; sta[c].pb({d, u});
		for (int i=head[u],v; ~i; i=e[i].next) {
			v = e[i].to;
			if (v==fa||del[v]) continue;
			getdis(v, u, c, d+1);
		}
	}
	void solve(int u) {
		del[u]=1;
		getdis(u, 0, u, 0);
		for (int i=head[u],v; ~i; i=e[i].next) {
			v = e[i].to;
			if (del[v]) continue;
			rot=0;
			getrt(v, u, siz[v]);
			solve(rot);
		}
	}
	void bfs(int s) {
		memset(vis, 0, sizeof(vis));
		queue<pair<int, int>> q;
		q.push({s, 0});
		link[s][++clink[s]]={s, 0};
		while (q.size()) {
			pair<int, int> u=q.front(); q.pop();
			sta2[s].pb({u.sec, u.fir});
			for (auto& v:to[u.fir]) if (!vis[v.fir]) {
				link[v.fir][++clink[v.fir]]={s, u.sec+1};
				q.push({v.fir, u.sec+1}), vis[v.fir]=1;
			}
		}
	}
	void solve() {
		build(1);
		msiz[rot=0]=n;
		getrt(1, 0, n);
		solve(rot);
		for (int i=1; i<=n; ++i) sort(sta[i].begin(), sta[i].end());
		for (int i=1; i<=m; ++i) if (!intr[i]) {
			int u=g[i].fir;
			if (sta2[u].size()) continue;
			bfs(u);
			sort(sta2[u].begin(), sta2[u].end());
		}
		memset(vis, 0, sizeof(vis));
		memset(ans, 0x3f, sizeof(ans));
		q.push({-c[1], 1}); ans[1]=0;
		while (q.size()) {
			int u=q.top().sec; q.pop();
			// cout<<"u: "<<u<<' '<<ans[u]<<endl;
			if (vis[u]) continue;
			vis[u]=1;
			for (int i=1; i<=canc[u]; ++i) {
				pair<int, ll> it=anc[u][i];
				int dis=d[u]-it.sec, lca=it.fir, *p=&pos[lca];
				while (*p<sta[lca].size() && sta[lca][*p].fir<=dis) {
					int v=sta[lca][*p].sec;
					if (ans[u]+c[u]<ans[v]) {
						ans[v]=ans[u]+c[u];
						q.push({-ans[v]-c[v], v});
					}
					++*p;
				}
			}
			for (int i=1; i<=clink[u]; ++i) {
				pair<int, ll> it=link[u][i];
				int dis=d[u]-it.sec, lca=it.fir, *p=&pos2[lca];
				while (*p<sta2[lca].size() && sta2[lca][*p].fir<=dis) {
					int v=sta2[lca][*p].sec;
					if (ans[u]+c[u]<ans[v]) {
						ans[v]=ans[u]+c[u];
						q.push({-ans[v]-c[v], v});
					}
					++*p;
				}
			}
		}
		for (int i=2; i<=n; ++i) printf("%lld\n", ans[i]);
	}
}

signed main()
{
	freopen("travel.in", "r", stdin);
	freopen("travel.out", "w", stdout);

	n=read(); m=read();
	memset(head, -1, sizeof(head));
	for (int i=1,u,v; i<=m; ++i) {
		u=read(); v=read();
		// add(u, v); add(v, u);
		g[i]={u, v};
		to[u].pb({v, i}); to[v].pb({u, i});
		// mp[{min(u, v), max(u, v)}]=i;
	}
	for (int i=1; i<=n; ++i) d[i]=read(), c[i]=read();
	// force::solve();
	task::solve();

	return 0;
}