题目描述 Description
A 国有 n 座城市,编号从 1 到 n,城市之间有 m 条双向道路。每一条道路对车辆都有重量限制,简称限重。现在有 q 辆货车在运输货物,司机们想知道每辆车在不超过车辆限重的情况下,最多能运多重的货物。输入描述 Input Description
第一行有两个用一个空格隔开的整数 n,m,表示 A 国有 n 座城市和 m 条道路。
接下来 m 行每行 3 个整数 x、y、z,每两个整数之间用一个空格隔开,表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意:x 不等于 y,两座城市之间可能有多条道路。
接下来一行有一个整数 q,表示有 q 辆货车需要运货。
接下来 q 行,每行两个整数 x、y,之间用一个空格隔开,表示一辆货车需要从 x 城市运输货物到 y 城市,注意:x 不等于 y。输出描述 Output Description
输出共有 q 行,每行一个整数,表示对于每一辆货车,它的最大载重是多少。如果货车不能到达目的地,输出-1。样例输入 Sample Input
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3样例输出 Sample Output
3
-1
3数据范围及提示 Data Size & Hint
对于 30%的数据,0 < n < 1,000,0 < m < 10,000,0 < q < 1,000;
对于 60%的数据,0 < n < 1,000,0 < m < 50,000,0 < q < 1,000;
对于 100%的数据,0 < n < 10,000,0 < m < 50,000,0 < q < 30,000,0 ≤ z ≤ 100,000。
首先我们来分析一下算法的选择上:
题目要求求在最大限重下的是重量尽量大 所以我们应该在一棵最大生成树上处理两点
问题也就转化成n个点m条边的图中的两点间最短路的最小权值
这一步我们可以用结构体变量表示权值 然后用cmp改变排序顺序
SPFA可以拿30 也有人拿到60分 可能是优化过的
附上暴力LCA代码:
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXV=11000;
const int MAXE=51000;
int first[MAXV],nxt[MAXE<<1];
int fa[MAXV],anc[MAXV],dis[MAXV],deep[MAXV];
int n,m,q,tot;
struct edge
{
int from,to,cost;
}es[MAXE<<1],c[MAXE<<1];
void init()
{
memset(first,-1,sizeof(first));
memset(deep,0,sizeof(deep));
tot=0;
}
void build(int f,int t,int d)
{
es[++tot]=(edge){f,t,d};
nxt[tot]=first[f];
first[f]=tot;
}
bool cmp(edge a,edge b)
{
return a.cost>b.cost;
}
int find(int x)
{
return anc[x]==x?x:anc[x]=find(anc[x]);
}
void dfs(int s)
{
for(int i=first[s];i!=-1;i=nxt[i])
{
int v=es[i].to;
if(deep[v]==0)
{
dis[v]=es[i].cost;
deep[v]=deep[s]+1;
fa[v]=s;
dfs(v);
}
}
}
int lca(int x,int y)
{
int minn=0x7fffff;
if(deep[x]>deep[y]) swap(x,y);
while(deep[x]!=deep[y])
{
if(dis[y]<minn) minn=dis[y];
y=fa[y];
}
while(x!=y)
{
if(dis[x]<minn) minn=dis[x];
if(dis[y]<minn) minn=dis[y];
x=fa[x];
y=fa[y];
}
return minn;
}
int main()
{
scanf("%d%d",&n,&m);
init();
for(int i=1;i<=n;i++) anc[i]=i;
for(int i=1;i<=m;i++)
scanf("%d%d%d",&c[i].from,&c[i].to,&c[i].cost);
sort(c+1,c+m+1,cmp);
for(int i=1;i<=m;i++)
{
int x=find(c[i].from);
int y=find(c[i].to);
if(x!=y)
{
anc[x]=y;
build(c[i].from,c[i].to,c[i].cost);
build(c[i].to,c[i].from,c[i].cost);
}
}
for(int i=1;i<=n;i++)
if(deep[i]==0) dfs(i);
scanf("%d",&q);
for(int i=1;i<=q;i++)
{
int a,b;
scanf("%d%d",&a,&b);
if(find(a)!=find(b)) printf("-1\n");
else printf("%d\n",lca(a,b));
}
return 0;
}
倍增:
如果在一条链上而且两者相距较远 如果暴力一步一步向上走的话 效率会十分低下
这时候我么就应该采用倍增来处理向上跳的过程
首先将两个节点默认有一个深度更深,处理深度差,在不会过界的情况下令深度更大的点向上跳2^k步 定义f[i][j]表示节点i的第2^j个祖先的标号。
有f[i][0]就是节点i的父亲节点标号,那么f[i][j]=f[f[i][j-1]][j-1],即i节点的第2^j个祖先的标号等于i节点的第2^(j-1)个祖先的第2^(j-1)个祖先,因为2^j=2^(j-1)+2^(j-1)。
再用一个二维数组 表示两点间最小权值 记录答案
之后初始化并查集 建最大生成树 用dfs处理点之间的关系 求lca
如果两个点没有lca 也就是说不连通 那么就不能到达 输出-1
最后再找一下两点距离lca更小的那个路径 即为答案
代码:
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int SZ = 200010;
const int INF = 2147483647;
struct Edge{
int f, t, d;
}es[SZ], tr[SZ];
int first[SZ], nxt[SZ], tot = 0, fa[SZ];
int anc[SZ][20], depth[SZ], dis[SZ][20];
bool vis[SZ];
void build(int f, int t, int d)
{
tr[++tot] = (Edge){f, t, d};
nxt[tot] = first[f];
first[f] = tot;
}
bool cmp(Edge a, Edge b)
{
return a.d > b.d;
}
int find(int x)
{
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void dfs(int u)
{
vis[u] = 1;
for(int i = 1; i <= 16; i++)
{
anc[u][i] = anc[anc[u][i - 1]][i - 1];//u的第2^(i-1)个祖先的第2^(i-1)个祖先是他第2^i个祖先
dis[u][i] = min(dis[anc[u][i - 1]][i - 1], dis[u][i - 1]);//防止倍增的时候跳过lca
}
for(int i = first[u]; i; i = nxt[i])
{
int v = tr[i].t;
if(!vis[v])
{
depth[v] = depth[u] + 1;//v是u的子节点 深度+1
anc[v][0] = u;//v的第2^0个祖先是他的父节点u
dis[v][0] = tr[i].d;//两点距离为边权
dfs(v);//从子节点继续向下扩展
}
}
}
int lca(int x, int y)
{
if(depth[x] < depth[y]) //默认x深度更深
swap(x, y);
int t = depth[x] - depth[y];
for(int i = 0; i <= 16; i++)
if(t & (1 << i)) //x先与y同高
x = anc[x][i];
for(int i = 16; i >= 0; i--)
if(anc[x][i] != anc[y][i])//一起上升 && 不跳过头
{
x = anc[x][i];
y = anc[y][i];
}
if(x == y) return x;//找到lca
return anc[x][0];//如果 x != y 则需要在找一层
}
int ask(int x, int y)
{
int t = depth[x] - depth[y];
int ans = INF;
for(int i = 0; i <= 16; i++)
if(t & (1 << i))
{
ans = min(ans, dis[x][i]);//某个节点到lca的最小承重
x = anc[x][i];
}
return ans;
}
int main()
{
int n, m;
scanf("%d%d", &n, &m);
for(int i = 1; i <= m; i++)
scanf("%d%d%d", &es[i].f, &es[i].t, &es[i].d);
for(int i = 1; i <= n; i++)//初始化并查集
fa[i] = i;
sort(es + 1, es + 1 + m, cmp);//最大生成树
for(int i = 1; i <= m; i++)
{
int x = find(es[i].f), y = find(es[i].t);
if(x != y)
{
fa[x] = y;
build(es[i].f, es[i].t, es[i].d);
build(es[i].t, es[i].f, es[i].d);
}
}
for(int i = 1; i <= n; i++)
if(fa[i] == i)
depth[i] = 1, dfs(i);
int q;
scanf("%d", &q);
int u, v;
for(int i = 1; i <= q; i++)
{
scanf("%d%d", &u, &v);
if(find(u) != find(v)) puts("-1");
else
{
int t = lca(u, v);
int ans = min(ask(u, t), ask(v, t));
printf("%d\n", ans);
}
}
return 0;
}
蒟蒻学了一天了 看神犇们的题解大致明白了倍增 然而代码还是容易卡QAQ
Orz You All
但倍增还是很好用的一种优化方法 虽然可能不会卡暴力LCA
学习一下提升下思维 提高代码效率还是很不错的
另注:
图论题一定要注意 用新的数组重新进行记录原值 防止影响其他自定义函数