Description

\(n\) 个点，\(m\) 条边，\(k\) 个充电站，\(Q\) 次询问，每次询问给出两个点 \(p_1\) , \(p_2\) ，两个点一定在充电站上，问从 \(p_1\) 到 \(p_2\) 的电池容量最少需要多少

题目传送

前置知识

• 最短路算法
• 最小生成树算法
• 倍增求LCA / 树链剖分

Solution

考虑如何求出任意一个点到离它最近的充电站的距离？

暴力的做法是对每一个充电站跑一边单源最短路，但复杂度实在承受不了

有一个很巧妙的处理方法是，我们可以建一个超级源点，连向所有充电站，权值设为 \(0\)，然后在新图上跑一个最短路，就能求出所有点到离它最近的充电站得距离了

有什么用？别急，让我们接着往下看

设走到一个点 \(i\)，剩余电量为 \(x\)， 那么一定有 \(x > dis_i\) （不管是中途充电还是到达终点均成立，因为保证了终点也是充电站）

假设我们要求的电容量为 \(c\)，那么三者关系满足：

\[c \ge x \ge dis_i \]

因为走到 \(i\) 点至少消耗了 \(dis_i\) 的电（最少的情况是以对 \(i\) 来说它的起点刚好是最近的充电站来说的），那么上面的不等式可以改为：

\[c - dis_i \ge x \ge dis_i \]

设下一个点为 \(j\)，边权为 \(w_{i,j}\)，同理有：

\[c - dis_j \ge x - w_{i,j} \ge dis_j \]

结合上面两个式子，进行合并得到 \(dis_j \le x - w_{i,j}\)，即：

\[dis_j \le c - dis_i - w_{i,j} \]

交换一下位置：

\[c \ge dis_i + dis_j + w_{i,j} \]

这个不等式的含义为，从 \(i\) 点到 \(j\) 点所需最小的电池容量为 \(dis_i + dis_j + w_{i,j}\)，也就是说没条边的最小限制已经求出来了，用这个最小限制就可以更新图上所有的边

那么每次询问一个起点 \(a\) 到 \(b\) 的最小电池容量，就是找一条从 \(a\) 点到 \(b\) 点的路径，使得这个路径上的最大值最小

很像二分？ 但用不着那么麻烦

因为这条路径一定在最小生成树上，同时在这个最小生成树上每对点都有一个简单路径，最小生成树的构建过程也保证了这条简单路径上的最大值就是答案

那么用LCA+倍增法求出路径上的最大值即可（也可以用树链剖分来实现，前提是码力足够强）

具体实现来看代码

Code

/*
Work by: Suzt_ilymics
Knowledge: ??
Time: O(??)

思路极其鬼畜：
1、最短路
2、生成树
3、倍增+LCA
4、查询 
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
//#include<time.h>
#define LL long long
#define int long long
#define orz cout<<"lkp AK IOI!"<<endl

using namespace std;
const int MAXN = 4e5+5;
const int MAXM = 6e5+5;
const int INF = 1e9+7;
const int mod = 1e9+7;

struct edge{
    int from, to, w, nxt;
}e[MAXM << 2], E[MAXM], E2[MAXM << 1];
int head[MAXN], num_edge = 0;
int Head[MAXN], Num_edge = 0;

struct node{
    int bh, val;
    bool operator < (const node &b) const { return val > b.val; }
};

int n, m, k, Q, cnt;
int dis[MAXN], fa[MAXN], f[MAXN][22], dep[MAXN], maxm[MAXN][22];
bool vis[MAXN];
priority_queue<node> q;

int read(){
	int s = 0, f = 0;
	char ch = getchar();
	while(!isdigit(ch))  f |= (ch == '-'), ch = getchar();
	while(isdigit(ch)) s = (s << 1) + (s << 3) + ch - '0' , ch = getchar();
	return f ? -s : s;
}

bool cmp(edge x, edge y){ return x.w < y.w; }
void add_edge(int from, int to, int w){ e[++num_edge] = (edge){from, to, w, head[from]}, head[from] = num_edge; }
void Add_edge(int from, int to, int w){ E2[++Num_edge] = (edge){from, to, w, Head[from]}, Head[from] = Num_edge; }
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }

void dij(){//跑一边dij求出所有点到最近的充电站的距离
    memset(dis, 0x3f, sizeof dis);
    dis[0] = 0;
    q.push((node){0, 0});
    while(!q.empty()){
        node u = q.top(); q.pop();
        if(vis[u.bh]) continue;
        vis[u.bh] = true;
        for(int i = head[u.bh]; i; i = e[i].nxt){
            int v = e[i].to;
            if(dis[v] > dis[u.bh] + e[i].w){
                dis[v] = dis[u.bh] + e[i].w;
                if(!vis[v]) q.push((node){v, dis[v]});
            }
        }
    }
}

void kruskal(){//建出更新权值后的图的最小生成树
	for(int i = 1; i <= n; ++i) fa[i] = i;//重置父亲 
	for(int i = 1; i <= m; ++i){
//    	cout<<E[i].from<<" "<<E[i].to<<" "<<E[i].w<<"lkp"<<endl;
		int uf = find(E[i].from), vf = find(E[i].to);
		if(uf != vf){
//			orz;
//			if(rand() % 2) fa[uf] = vf;//随机连父亲，随机化优化复杂度 
//			else 
			fa[vf] = uf;
			Add_edge(E[i].from, E[i].to, E[i].w), Add_edge(E[i].to, E[i].from, E[i].w);//建出最小生成树来 
			cnt++;
			if(cnt == n - 1) return ;//如果建了n - 1条边，就结束 
		}
	}
}

void dfs(int u, int fa){//dfs预处理lca ，注意这里跑的是新图
	f[u][0] = fa;
	for(int i = Head[u]; i; i = E2[i].nxt){
		int v = E2[i].to;
		if(v == fa) continue;
		dep[v] = dep[u] + 1;
		maxm[v][0] = E2[i].w;
//		cout<<maxm[v][0]<<endl;
		dfs(v, u);
	}
}

void init(){//倍增法预处理lca，顺便维护一个最大值
	for(int i = 1; i <= 20; ++i){
		for(int j = 1; j <= n; ++j){
			f[j][i] = f[f[j][i - 1]][i - 1];
			maxm[j][i] = max(maxm[j][i - 1], maxm[f[j][i - 1]][i - 1]);
//			cout<<maxm[j][i]<<endl;
		}
	}
}

int get_max(int x, int y){//可以直接在求两点lca的过程中求出两点简单路径的最大值
	int ans = 0;
	if(dep[x] < dep[y]) swap(x, y);
	for(int i = 20; i >= 0; --i){
		if(dep[f[x][i]] < dep[y]) continue;
		ans = max(ans, maxm[x][i]);
		x = f[x][i];
	}
	if(x == y) return ans;
	for(int i = 20; i >= 0; --i){
		if(f[x][i] == f[y][i]) continue;
		ans = max(ans, max(maxm[x][i], maxm[y][i]));
//		cout<<ans<<endl;
		x = f[x][i];
		y = f[y][i];
	}
	ans = max(ans, max(maxm[x][0], maxm[y][0]));
	return ans;
}

signed main()
{
//	srand(time(0));
    n = read(), m = read(), k = read(), Q = read();
    for(int i = 1, u, v, w; i <= m; ++i){
        u = read(), v = read(), w = read();
        add_edge(u, v, w), add_edge(v, u, w);
        E[i].from = u, E[i].to = v, E[i].w = w;
    }
    for(int i = 1; i <= k; ++i){
        add_edge(0, i, 0), add_edge(i, 0, 0);    
    }
    dij();
//  for(int i = 1; i <= n; ++i) cout<<i<<" "<<dis[i]<<" lkp"<<endl;
    for(int i = 1; i <= m; ++i){//更新边的权值
    	E[i].w += dis[E[i].from] + dis[E[i].to];
	}
	sort(E + 1, E + m + 1, cmp);//按边权大小由小到大排序 
	kruskal();
	
//	memset(minn, 0x7f, sizeof minn);
	dep[1] = 1;
	dfs(1, -1);
	init();
	
	for(int i = 1, u, v; i <= Q; ++i){
		u = read(), v = read();
		cout<<get_max(u, v)<<endl;//直接输出所求结果即可
	}
	return 0;
}