P1967 货车运输(最短路+lca)

52 篇文章 3 订阅
32 篇文章 1 订阅

P1967 货车运输
题目描述
A 国有 nn 座城市,编号从 11 到 nn,城市之间有 mm 条双向道路。每一条道路对车辆都有重量限制,简称限重。

现在有 qq 辆货车在运输货物, 司机们想知道每辆车在不超过车辆限重的情况下,最多能运多重的货物。

输入格式
第一行有两个用一个空格隔开的整数 n,mn,m,表示 AA 国有 nn 座城市和 mm 条道路。

接下来 mm 行每行三个整数 x, y, zx,y,z,每两个整数之间用一个空格隔开,表示从 xx 号城市到 yy 号城市有一条限重为 zz 的道路。
注意: x \neq yx  =y,两座城市之间可能有多条道路 。

接下来一行有一个整数 qq,表示有 qq 辆货车需要运货。

接下来 qq 行,每行两个整数 x,yx,y,之间用一个空格隔开,表示一辆货车需要从 xx 城市运输货物到 yy 城市

输出格式
共有 qq 行,每行一个整数,表示对于每一辆货车,它的最大载重是多少。
如果货车不能到达目的地,输出 -1−1。

输入输出样例
输入 #1复制

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

输出 #1复制

3
-1
3
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
const int N=500005;
const int inf=0x3f3f3f3f;
int n,m,num;
int vis[N],d[N],a[N],lg[N],dis[N][31],f[N][31],head[N];
struct node{
	int x,y,v;
}s[N];
struct edge{
	int to,next,w;
}s1[N];
bool cmp(node x,node y){
	return x.v>y.v;
}
int find(int x){
	return a[x]==x?x:(a[x]=find(a[x]));
}
void add(int u,int v,int w){
	s1[++num]=(edge){v,head[u],w};
	head[u]=num;
}
void kruskal(){
	sort(s,s+m,cmp);
	int i;
	for(i=1;i<=n;i++) a[i]=i;
	for(i=0;i<m;i++){
		int x=find(s[i].x),y=find(s[i].y);
		if(x!=y){
			a[x]=y;
			add(s[i].x,s[i].y,s[i].v);
			add(s[i].y,s[i].x,s[i].v);
		}
	}
}
void dfs(int x,int fa,int we){
	d[x]=d[fa]+1;
	f[x][0]=fa;
	vis[x]=1;
	dis[x][0]=we;
	int i;
	for(i=1;1<<i<=d[x];i++){
		f[x][i]=f[f[x][i-1]][i-1];
		dis[x][i]=min(dis[x][i-1],dis[f[x][i-1]][i-1]);
	}
	for(i=head[x];i;i=s1[i].next){
		if(fa!=s1[i].to) dfs(s1[i].to,x,s1[i].w);
	}
}
int lca(int x,int y){
	if(find(x)!=find(y)) return -1;
	int ans=inf;
	if(d[x]>d[y]) swap(x,y);
	for(int i=20;i>=0;i--)
	//	if(d[f[y][i]]>=d[x]){
		if(d[y]-(1<<i)>=d[x]){
			ans=min(ans,dis[y][i]);
			y=f[y][i];
		}
	if(x==y) return ans;
	for(int i=20;i>=0;i--){
		if(f[x][i]!=f[y][i]){
			ans=min(ans,min(dis[x][i],dis[y][i]));
			x=f[x][i];
			y=f[y][i];
		}
	}
	ans=min(ans,min(dis[x][0],dis[y][0]));
	return ans;
}
int main()
{
	int x,y,i,j,k;
	scanf("%d %d",&n,&m);
	for(i=0;i<m;i++){
		scanf("%d %d %d",&s[i].x,&s[i].y,&s[i].v);
	}
	kruskal();
	for(i=1;i<=n;i++){
		if(!vis[i]){
			dfs(i,0,0);
		}
	}
	
/*	for(i=1;i<=n;i++)	lg[i]=lg[i-1]+(1<<lg[i]==i);*/
	scanf("%d",&k);
	while(k--){
		scanf("%d %d",&x,&y);
		printf("%d\n",lca(x,y));
	}
	return 0;
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LCA+路径压缩的方式可以用于求解树上的桥,具体实现步骤如下: 1. 对于树上每个节点,记录其在树中的深度(或者高度)以及其父亲节点。 2. 对于每个节点,记录其在树上的最小深度(或最小高度)以及其所在子树中深度最小的节点。 3. 对于每条边(u, v),设u的深度小于v的深度(或者高度),则如果v的子树中没有深度小于u的节点,则(u, v)是桥。 具体的实现过程如下: 首先,我们需要对树进行预处理,求出每个节点的深度以及其父亲节点。可以使用深度优先搜索(DFS)或广度优先搜索(BFS)来实现。在这里我们使用DFS来实现: ```c++ vector<int> adj[MAX_N]; // 树的邻接表 int n; // 树的节点数 int dep[MAX_N], fa[MAX_N]; // dep[i]表示节点i的深度,fa[i]表示节点i的父亲节点 void dfs(int u, int f, int d) { dep[u] = d; fa[u] = f; for (int v : adj[u]) { if (v != f) { dfs(v, u, d + 1); } } } ``` 接下来,我们需要计算每个节点所在子树中深度最小的节点。我们可以使用LCA(最近公共祖先)的方法来实现。具体来说,我们可以使用倍增算法来预处理出每个节点的2^k级祖先,并且在查询LCA时使用路径压缩的方式优化时间复杂度。这里我们不展开讲解LCA和倍增算法的细节,如果你对此感兴趣,可以参考其他资料进行学习。 ```c++ const int MAX_LOG_N = 20; // log2(n)的上取整 int anc[MAX_N][MAX_LOG_N]; // anc[i][j]表示节点i的2^j级祖先 int mn[MAX_N]; // mn[i]表示节点i所在子树中深度最小的节点 void precompute() { // 预处理anc数组 for (int j = 1; j < MAX_LOG_N; j++) { for (int i = 1; i <= n; i++) { if (anc[i][j - 1] != -1) { anc[i][j] = anc[anc[i][j - 1]][j - 1]; } } } // 计算mn数组 for (int i = 1; i <= n; i++) { mn[i] = i; for (int j = 0; (1 << j) <= dep[i]; j++) { if ((dep[i] & (1 << j)) != 0) { mn[i] = min(mn[i], mn[anc[i][j]]); i = anc[i][j]; } } } } ``` 最后,我们可以使用LCA+路径压缩的方式来判断每条边是否为桥。具体来说,对于每条边(u, v),我们需要判断v的子树中是否存在深度小于u的节点。如果存在,则(u, v)不是桥,否则(u, v)是桥。 ```c++ bool is_bridge(int u, int v) { if (dep[u] > dep[v]) swap(u, v); if (mn[v] != u) return true; // 子树中存在深度小于u的节点 return false; // 子树中不存在深度小于u的节点 } ``` 完整代码如下:

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值