P1967 [NOIP 2013 提高组] 货车运输
题目背景
NOIP2013 提高组 D1T3
题目描述
A 国有 n n n 座城市，编号从 1 1 1 到 n n n，城市之间有 m m m 条双向道路。每一条道路对车辆都有重量限制，简称限重。
现在有 q q q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。
输入格式
第一行有两个用一个空格隔开的整数 $ n,m$，表示 A 国有 $ n$ 座城市和 m m m 条道路。
接下来
m
m
m 行每行三个整数
x
,
y
,
z
x, y, z
x,y,z，每两个整数之间用一个空格隔开，表示从 $x $ 号城市到 $ y $ 号城市有一条限重为
z
z
z 的道路。
注意：
x
≠
y
x \neq y
x=y，两座城市之间可能有多条道路 。
接下来一行有一个整数 q q q，表示有 q q q 辆货车需要运货。
接下来 q q q 行，每行两个整数 x , y x,y x,y，之间用一个空格隔开，表示一辆货车需要从 x x x 城市运输货物到 y y y 城市，保证 x ≠ y x \neq y x=y
输出格式
共有
q
q
q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。
如果货车不能到达目的地，输出
−
1
-1
−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\% 30% 的数据， 1 ≤ n < 1000 1 \le n < 1000 1≤n<1000， 1 ≤ m < 10 , 000 1 \le m < 10,000 1≤m<10,000， 1 ≤ q < 1000 1\le q< 1000 1≤q<1000；
对于 60 % 60\% 60% 的数据， 1 ≤ n < 1000 1 \le n < 1000 1≤n<1000， 1 ≤ m < 5 × 1 0 4 1 \le m < 5\times 10^4 1≤m<5×104， 1 ≤ q < 1000 1 \le q< 1000 1≤q<1000；
对于 100 % 100\% 100% 的数据， 1 ≤ n < 1 0 4 1 \le n < 10^4 1≤n<104， 1 ≤ m < 5 × 1 0 4 1 \le m < 5\times 10^4 1≤m<5×104，$1 \le q< 3\times 10^4 $， 0 ≤ z ≤ 1 0 5 0 \le z \le 10^5 0≤z≤105。
思路：
本题可以用Kruskal重构树来做，假如说有
n
n
n 个点
u
→
v
u → v
u→v 是其中一条边，边权是
w
w
w ，然后我们就新建立一个节点
x
x
x 为
n
+
1
n + 1
n+1 ，让这个点为两者的父节点，点权是
w
w
w。这样就是
{
u
1
,
v
1
,
x
}
\{u_1, v_1, x\}
{u1,v1,x}， 同理也可以得到另一个边的是
{
u
2
,
v
2
,
y
}
\{u_2, v_2, y\}
{u2,v2,y} 这两个代表源分别是
x
x
x 和
y
y
y ，然后我们建立一个新的点
z
z
z 为
n
+
3
n + 3
n+3.然后再把这两个连接起来就变成了
{
u
1
,
v
1
,
u
2
,
v
2
,
x
,
y
,
z
}
\{u_1, v_1, u_2, v_2, x, y, z\}
{u1,v1,u2,v2,x,y,z} 代表源就变成了
z
z
z
上图就是
K
r
u
s
k
a
l
Kruskal
Kruskal 重构树的构建，我们发现当我们重构树是通过
K
r
u
s
k
a
l
Kruskal
Kruskal 得到的最大生成树的时候，我们建立起来的父节点都是两点之间最大边权的最小值。而我们建立最小生成树（MST）的时候，我们的点权是两点之间最小边权的最大值。
于是我们就得到了一条规则：
构建最大生成树，建立起来的父节点都是两点之间最小边权的最大值
构建最小生成树，建立起来的父节点都是两点之间最大边权的最小值
K r u s k a l B u i l d T r e e KruskalBuildTree KruskalBuildTree 的构建代码
本题构建的是最大生成树 (不一定全部连通，可能是生成树森林)
inline void KruskalBuildTree() {
std::sort(adj.begin(), adj.end(), std::greater<Node>());
Rep(i, 1, 2 * n + 1) F[i] = i;
int tot = n;
rep(i, m) {
int u = adj[i].u, v = adj[i].v, w = adj[i].w;
int fu = Findest(u), fv = Findest(v);
if(fu == fv) continue;
tot++;
cost[tot] = w; // 得到新建父节点的点权
F[tot] = F[fu] = F[fv] = tot;
add(tot, fu);
add(tot, fv);
add(fu, tot);
add(fv, tot);
}
// 检测连通性，不一定全部连通，可能是生成树森林
Rep(i, 1, tot + 1) {
if(F[i] == i) {
DFS1(i, 0);
DFS2(i, i);
}
}
}
LCA部分，两种写法：
树链剖分：
// 取得fa, dep, sz, son
void DFS1(int u, int father) {
fa[u] = father, dep[u] = dep[father] + 1, sz[u] = 1;
for(int i = h[u]; ~i; i = e[i].ne) {
int v = e[i].v;
if(v == father) continue;
DFS1(v, u);
sz[u] += sz[v];
if(sz[son[u]] < sz[v]) son[u] = v;
}
}
// 取得top
void DFS2(int u, int t) {
top[u] = t;
if(!son[u]) return ;
DFS2(son[u], t);
for(int i = h[u]; ~i; i = e[i].ne) {
int v = e[i].v;
if(v == fa[u] || v == son[u]) continue;
DFS2(v, v);
}
}
inline int LCA(int u, int v) {
while(top[u] != top[v]) {
if(dep[top[u]] < dep[top[v]]) std::swap(u, v);
u = fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
倍增：
// 创建ST表
void DFS(int u, int father, int val) {
dep[u] = dep[father] + 1;
F[u][0] = father;
num[u][0] = val;
for(int i = 1; i <= log2(n); i++) {
F[u][i] = F[F[u][i - 1]][i - 1];
num[u][i] = std::min(num[u][i - 1], num[F[u][i - 1]][i - 1]);
}
for(const auto& [v, w] : adj[u]) if(v != father) DFS(v, u, w);
}
inline int LCA(int u, int v) {
int res = INF;
if(dep[u] < dep[v]) std::swap(u, v);
for(int i = log2(n); i >= 0; i--) {
if(dep[F[u][i]] >= dep[v]) {
res = std::min(res, num[u][i]);
u = F[u][i];
}
}
if(u == v) return res;
for(int i = log2(n); i >= 0; i--) {
if(F[u][i] != F[v][i]) {
res = std::min(res, std::min(num[u][i], num[v][i]));
u = F[u][i], v = F[v][i];
}
}
res = std::min(res, std::min(num[u][0], num[v][0]));
return res;
}
int Findest(int x) {
return x == fa[x] ? x : fa[x] = Findest(fa[x]);
}
注意：
1.建立新节点连接的时候连接的是根节点（集合的代表源），也就是
f
u
fu
fu 和
f
v
fv
fv
2.树链剖分的时候不要定义的时候初始化，不然会出现错误，初始化在
D
F
S
1
DFS1
DFS1 里面有的
3.建树的时候不要在建边的时候建，在并查集的时候建边
K
r
u
s
k
a
l
重构树
+
L
C
A
(
树链剖分
)
Kruskal重构树 + LCA(树链剖分)
Kruskal重构树+LCA(树链剖分)
AC code:
#include <iostream>
#include <climits>
#include <limits>
#include <vector>
#include <algorithm>
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> PII;
#define rep(i, n) for(int i = 0; i < n; i++)
#define Rep(i, len, n) for(int i = len; i < n; i++)
#define MAX_INT 0x7fffffff
#define MIN_INT 0x80000000
const int INF = std::numeric_limits<int>::max();
struct Node {
int u, v, w;
bool operator> (const Node& other) const{
return w > other.w;
}
};
struct edge {
int v, ne, w;
};
int n, m, q;
std::vector<Node> adj;
std::vector<edge> e;
std::vector<int> h, sz, fa, F, dep, top, son, cost;
inline void add(int a, int b) {
e.push_back({b, h[a]});
h[a] = e.size() - 1;
}
void DFS1(int u, int father) {
fa[u] = father, dep[u] = dep[father] + 1, sz[u] = 1;
for(int i = h[u]; ~i; i = e[i].ne) {
int v = e[i].v;
if(v == father) continue;
DFS1(v, u);
sz[u] += sz[v];
if(sz[son[u]] < sz[v]) son[u] = v;
}
}
void DFS2(int u, int t) {
top[u] = t;
if(!son[u]) return ;
DFS2(son[u], t);
for(int i = h[u]; ~i; i = e[i].ne) {
int v = e[i].v;
if(v == fa[u] || v == son[u]) continue;
DFS2(v, v);
}
}
inline int LCA(int u, int v) {
while(top[u] != top[v]) {
if(dep[top[u]] < dep[top[v]]) std::swap(u, v);
u = fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
int Findest(int x) {
return x == F[x] ? x : F[x] = Findest(F[x]);
}
inline void KruskalBuildTree() {
std::sort(adj.begin(), adj.end(), std::greater<Node>());
Rep(i, 1, 2 * n + 1) F[i] = i;
int tot = n;
rep(i, m) {
int u = adj[i].u, v = adj[i].v, w = adj[i].w;
int fu = Findest(u), fv = Findest(v);
if(fu == fv) continue;
tot++;
cost[tot] = w;
F[tot] = F[fu] = F[fv] = tot;
add(tot, fu);
add(tot, fv);
add(fu, tot);
add(fv, tot);
}
Rep(i, 1, tot + 1) {
if(F[i] == i) {
DFS1(i, 0);
DFS2(i, i);
}
}
}
int main(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr), std::cout.tie(nullptr);
std::cin >> n >> m;
sz.resize(2 * n + 1);
fa.resize(2 * n + 1);
h.resize(2 * n + 1, -1);
F.resize(2 * n + 1);
dep.resize(2 * n + 1, 0);
son.resize(2 * n + 1, 0);
top.resize(2 * n + 1);
cost.resize(2 * n + 1, -1);
rep(i, m) {
int a, b, c;
std::cin >> a >> b >> c;
adj.push_back({a, b, c});
}
KruskalBuildTree();
std::cin >> q;
while(q--) {
int x, y;
std::cin >> x >> y;
std::cout << cost[LCA(x, y)] << '\n';
}
return 0;
}
K
r
u
s
k
a
l
+
L
C
A
(
倍增
S
T
表
)
Kruskal+ LCA(倍增ST表)
Kruskal+LCA(倍增ST表)
AC code:
#include <iostream>
#include <climits>
#include <limits>
#include <vector>
#include <algorithm>
#include <cmath>
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> PII;
#define rep(i, n) for(int i = 0; i < n; i++)
#define Rep(i, len, n) for(int i = len; i < n; i++)
#define MAX_INT 0x7fffffff
#define MIN_INT 0x80000000
const int INF = std::numeric_limits<int>::max();
struct edge {
int u, v, w;
bool operator> (const edge& other) const{
return w > other.w;
}
};
int n, m, q, LOG;
std::vector<edge> e;
std::vector<int> dep, fa, sz;
std::vector<std::vector<int>> F, num;
std::vector<std::vector<PII>> adj;
void DFS(int u, int father, int val) {
dep[u] = dep[father] + 1;
F[u][0] = father;
num[u][0] = val;
for(int i = 1; i <= log2(n); i++) {
F[u][i] = F[F[u][i - 1]][i - 1];
num[u][i] = std::min(num[u][i - 1], num[F[u][i - 1]][i - 1]);
}
for(const auto& [v, w] : adj[u]) if(v != father) DFS(v, u, w);
}
inline int LCA(int u, int v) {
int res = INF;
if(dep[u] < dep[v]) std::swap(u, v);
for(int i = log2(n); i >= 0; i--) {
if(dep[F[u][i]] >= dep[v]) {
res = std::min(res, num[u][i]);
u = F[u][i];
}
}
if(u == v) return res;
for(int i = log2(n); i >= 0; i--) {
if(F[u][i] != F[v][i]) {
res = std::min(res, std::min(num[u][i], num[v][i]));
u = F[u][i], v = F[v][i];
}
}
res = std::min(res, std::min(num[u][0], num[v][0]));
return res;
}
int Findest(int x) {
return x == fa[x] ? x : fa[x] = Findest(fa[x]);
}
inline void Kruskal(int x, int y, int w) {
int fx = Findest(x), fy = Findest(y);
if(fx == fy) return ;
if(sz[fx] > sz[fy]) std::swap(fx, fy);
fa[fx] = fy;
sz[fy] += sz[fx];
adj[x].push_back({y, w});
adj[y].push_back({x, w});
}
int main(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr), std::cout.tie(nullptr);
std::cin >> n >> m;
LOG = log2(n);
F.resize(n + 1, std::vector<int>(LOG, 0));
num.resize(n + 1, std::vector<int>(LOG, 0));
adj.resize(n + 1);
dep.resize(n + 1, 0);
fa.resize(n + 1);
sz.resize(n + 1, 1);
Rep(i, 1, n + 1) fa[i] = i;
rep(i, m) {
int a, b, c;
std::cin >> a >> b >> c;
e.push_back({a, b, c});
}
std::sort(e.begin(), e.end(), std::greater<edge>());
rep(i, m) Kruskal(e[i].u, e[i].v, e[i].w);
for(int i = 1; i <= n; i++) if(fa[i] == i) DFS(i, 0, INF);
std::cin >> q;
while(q--) {
int x, y;
std::cin >> x >> y;
if(Findest(x) != Findest(y)) {
std::cout << -1 << std::endl;
} else {
std::cout << LCA(x, y) << std::endl;
}
}
return 0;
}
扫一扫
1335
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
