刷题记录:牛客NC16527[NOIP2013]货车运输 多次树链剖分+最大生成树

传送门:牛客

题目描述:

A 国有 n 座城市，编号从 1 到 n ，城市之间有 m 条双向道路。每一条道路对车辆都有重量限
制，简称限重。现在有 q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况
下，最多能运多重的货物。
输入:
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3
输出:
3
-1
3

一道树上路径求$min$的题目,可以使用树链树剖+线段树进行解决

首先我们会发现题目中给出的是一个图,并不是树,但是我们可以将这个图转化成一张图.我们会发现对于两个点<u,v>来说,我们每次走的肯定是<u,v>所有路径中限制最小的边(也就是可载最大的边),那么此时对于其他可载小的边来说,此时显然那些边是没有用的,因为我们肯定不会通过那些边来到达v.

所以贪心的来想,此时我们可以对原来的图进行一个最大生成树来讲图转化成一颗树.那么对于这棵树来说,此时我们就可以进行树链剖分来将树形结构转化为线性结构,然后使用线段树来维护区间最小值(注意此处是区间最小值而不是最大值,我们需要的是边的最小值最大!!)即可

我们需要将点权转化成边权进行存储,转化方法有很多,博主在这里使用的是将深度较大的点来存储原来的边权.

但是对于这道题来说,我们的原来的图并不一定是一个联通图,所以我们需要进行多次树链剖分将所有的森林都转化成线性结构

下面是具体的代码部分:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define int long long
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int fa[maxn],Size[maxn],max_son[maxn],dep[maxn];
struct Edge{
	int u,v,w;
	bool operator < (const Edge &rhs) const {
		return w>rhs.w;
	}
}edge1[maxn],edge2[maxn];
vector<int>edge[maxn];
void dfs1(int u,int pre_u) {
	Size[u]=1;
	for(int i=0;i<edge[u].size();i++) {
		int v=edge[u][i];
		if(v==pre_u) continue;
		dep[v]=dep[u]+1;
		dfs1(v,u);
		fa[v]=u;Size[u]+=Size[v];
		if(Size[v]>Size[max_son[u]]) {
			max_son[u]=v;
		}
	}
}
int top[maxn],rev[maxn],id[maxn],tot=0;
void dfs2(int u,int t) {
	top[u]=t;id[u]=++tot;rev[tot]=u;
	if(!max_son[u]) return ;
	dfs2(max_son[u],t);
	for(int i=0;i<edge[u].size();i++) {
		int v=edge[u][i];
		if(v==fa[u]||v==max_son[u]) continue;
		dfs2(v,v);
	}
}
struct Segment_tree {
	int l,r,mn;
}tree[maxn*4];int value[maxn];
void pushup(int rt) {
	tree[rt].mn=min(tree[ls].mn,tree[rs].mn);
}
void build(int l,int r,int rt) {
	tree[rt].l=l;tree[rt].r=r;tree[rt].mn=int_INF;
	if(l==r) {
		tree[rt].mn=value[rev[l]];
		return ;
	}
	int mid=(l+r)>>1;
	build(lson);build(rson);
	pushup(rt);
}
int ans_min=int_INF;
void query(int l,int r,int rt) {
	if(tree[rt].l==l&&tree[rt].r==r) {
		ans_min=min(ans_min,tree[rt].mn);
		return ;
	}
	int mid=(tree[rt].l+tree[rt].r)>>1;
	if(r<=mid) query(l,r,ls);
	else if(l>mid) query(l,r,rs);
	else query(l,mid,ls),query(mid+1,r,rs);
}
void ask(int u,int v) {
	while(top[u]!=top[v]) {
		if(dep[top[u]]<dep[top[v]]) swap(u,v);
		query(id[top[u]],id[u],1);
		u=fa[top[u]];
	}
	if(u==v) return ;
	if(dep[u]>dep[v]) swap(u,v);
	query(id[max_son[u]],id[v],1);
}
int FA[maxn];
int find(int x) {
	if(x==FA[x]) return x;
	else return FA[x]=find(FA[x]);
}
int n,m;
void kruskal() {
	sort(edge1+1,edge1+1+m);
	int cnt=0;
	for(int i=1;i<=m;i++) {
		int u=edge1[i].u,v=edge1[i].v,w=edge1[i].w;
		if(find(u)==find(v)) continue;
		edge[u].push_back(v);
		edge[v].push_back(u);
		edge2[++cnt]={u,v,edge1[i].w};
		FA[find(u)]=find(v);
		if(cnt==n-1) break;
	}
}
signed main() {
	n=read();m=read();int cnt=0;
	for(int i=1;i<=m;i++) {
		int x=read(),y=read(),z=read();
		edge1[++cnt].u=x;edge1[cnt].v=y;edge1[cnt].w=z;
	}
	for(int i=1;i<=n;i++) FA[i]=i;
	kruskal();
	for(int i=1;i<=n;i++) {
		if(!Size[i]){
			dfs1(i,0);
		} 
	}
	for(int i=1;i<=n;i++) {
		if(!top[i]) dfs2(i,i);
	}
	for(int i=1;i<=n-1;i++) {
		int u=edge2[i].u,v=edge2[i].v,w=edge2[i].w;
		if(dep[u]<dep[v]) swap(u,v);
		value[u]=edge2[i].w;
	}
	build(1,tot,1);
	int q=read();
	for(int i=1;i<=q;i++) {
		int u=read(),v=read();
		if(find(u)!=find(v)) {
			printf("-1\n");
			continue;
		}
		else {
			ans_min=int_INF;
			ask(u,v);
			printf("%lld\n",ans_min);
		}
	}
	return 0;
}