P1967 货车运输

Posted 2020-11-15 little-cute-hjr

题目描述

AA国有nn座城市，编号从 11到nn，城市之间有 mm 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 qq 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入格式

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

接下来 mm行每行33个整数 x, y, zx,y,z，每两个整数之间用一个空格隔开，表示从 xx号城市到yy号城市有一条限重为 zz 的道路。注意： ** xx 不等于 yy，两座城市之间可能有多条道路 ** 。

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

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意： ** x 不等于 y ** 。

输出格式

共有 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

说明/提示

对于 30\%30%的数据，0 < n < 1,000,0 < m < 10,000,0 < q< 1,0000<n<1,000,0<m<10,000,0<q<1,000；

对于 60\%60%的数据，0 < n < 1,000,0 < m < 50,000,0 < q< 1,0000<n<1,000,0<m<50,000,0<q<1,000；

对于 100\%100%的数据，0 < n < 10,000,0 < m < 50,000,0 < q< 30,000,0 ≤ z ≤ 100,0000<n<10,000,0<m<50,000,0<q<30,000,0≤z≤100,000。

分析：

由于所给的边数不能确定，而且边的端点以及权值不确定；

为了保证答案最优，我们可以考虑删掉一定不会被选上的边

解决方案：构建一颗最大生成树

对于树上任意的两点(x,y),到他们的路径，任何一段组成部分的权值一定大于最大生成树的边的补集，正确性显然

然后考虑在构建的树上进行操作：

由于树上任意两点的路径唯一，可以考虑倍增LCA的做法：

联想倍增的过程，得出以下算法：

1.设f[i][j]表示从节点i向上跳2^j次所得到的节点，w[i][j]用来维护从节点i到2^j处节点的最小权重，dep[x]维护x节点的深度（用于倍增上跳）

2.考虑预处理f[i][j]，首先进行一遍dfs，求出所有的f[i][0]=fath(i),dep[x],w[i][0]=path(i,father),计算递推预处理的值

3.用倍增预处理出f,w数组

f[i][j]=f[f[i][j-1][j-1],w[i][j]=min(w[i][j-1],w[f[i][j-1][j-1]);

4.最后回答每个询问即可

询问节点（x,y）,回答：

ans=min(w[x][lca],w[y][lca])

先把x,y调到深度相同，如果已经是同一点了，就直接输出，如果不是同一个点，倍增往上跳

（2的幂从大往小枚举）

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define MAXN 10005
#define INF 999999999
using namespace std;
struct Edge1{
int x,y,dis;
}edge1[50005]; //题目所给的图
struct Edge2{
int to,next,w;
}edge2[100005]; //最大生成树的图
int cnt,n,m,head[MAXN],deep[MAXN],f[MAXN],fa[MAXN][21],w[MAXN][21];
//f数组表示并查集中的父节点，fa数组表示树上的父节点，w数组表示最大载重
bool vis[MAXN];

void addedge(int from, int to, int w)
{ //前向星存图
edge2[++cnt].next=head[from];
edge2[cnt].to=to;
edge2[cnt].w=w;
head[from]=cnt;
return ;
}

bool CMP(Edge1 x, Edge1 y)
{
return x.dis>y.dis; //将边权从大到小排序
}

int find(int x){ //并查集寻找父节点
if(f[x]!=x) f[x]=find(f[x]);
return f[x];
}

void kruskal()
{
sort(edge1+1, edge1+m+1, CMP);
for(int i=1; i<=n; i++)
f[i]=i; //并查集初始化
for(int i=1; i<=m; i++)
if(find(edge1[i].x)!=find(edge1[i].y)){
f[find(edge1[i].x)]=find(edge1[i].y);
addedge(edge1[i].x, edge1[i].y, edge1[i].dis);
addedge(edge1[i].y, edge1[i].x, edge1[i].dis); //无向图，双向加边
}
return ;
}

void dfs(int node)
{
vis[node]=true;
for(int i=head[node]; i; i=edge2[i].next){ //前向星遍历
int to=edge2[i].to;
if(vis[to]) continue;
deep[to]=deep[node]+1; //计算深度
fa[to][0]=node; //储存父节点
w[to][0]=edge2[i].w; //储存到父节点的权值
dfs(to);
}
return ;
}

int lca(int x, int y)
{
if(find(x)!=find(y)) return -1; //不连通，输出-1
int ans=INF;
if(deep[x]>deep[y]) swap(x,y); //保证y节点更深
//将y节点上提到于x节点相同深度
for(int i=20; i>=0; i--)
if(deep[fa[y][i]]>=deep[x]){
ans=min(ans, w[y][i]); //更新最大载重（最小边权）
y=fa[y][i]; //修改y位置
}
if(x==y) return ans; //如果位置已经相等，直接返回答案
//寻找公共祖先
for(int i=20; i>=0; i--)
if(fa[x][i]!=fa[y][i]){
ans=min(ans, min(w[x][i], w[y][i])); //更新最大载重（最小边权）
x=fa[x][i];
y=fa[y][i]; //修改x,y位置
}
ans=min(ans, min(w[x][0], w[y][0]));
//更新此时x,y到公共祖先最大载重，fa[x][0], fa[y][0]即为公共祖先
return ans;
}

int main()
{
int x,y,z,q;
scanf("%d%d",&n,&m);
for(int i=1; i<=m; i++){
scanf("%d%d%d",&x,&y,&z);
edge1[i].x=x;
edge1[i].y=y;
edge1[i].dis=z;
} //储存题目所给图
kruskal();
for(int i=1; i<=n; i++)
if(!vis[i]){ //dfs收集信息
deep[i]=1;
dfs(i);
fa[i][0]=i;
w[i][0]=INF;
}
//LCA初始化
for(int i=1; i<=20; i++)
for(int j=1; j<=n; j++){
fa[j][i]=fa[fa[j][i-1]][i-1];
w[j][i]=min(w[j][i-1], w[fa[j][i-1]][i-1]);
}
scanf("%d",&q);
for(int i=1; i<=q; i++){
scanf("%d%d",&x,&y);
printf("%d ",lca(x,y)); //回答询问
}
return 0;
}