题目#

货车运输#

A 国有 $n$ 座城市，编号从 $1$ 到 $n$ ，城市之间有 $m$ 条双向道路。每一条道路对车辆都有重量限制，简称限重。

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

输入格式#

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

接下来 $m$ 行每行三个整数 $x, y, z$ ，每两个整数之间用一个空格隔开，表示从 $x$ 号城市到 $y$ 号城市有一条限重为 $z$ 的道路。注意： $x \neq y$ ，两座城市之间可能有多条道路。

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

接下来 $q$ 行，每行两个整数 $x,y$ ，之间用一个空格隔开，表示一辆货车需要从 $x$ 城市运输货物到 $y$ 城市，保证 $x \neq y$

对于 $100\%$ 的数据， $1 \le n < 10^4$ ， $1 \le m < 5\times 10^4$ ， $1 \le q< 3\times 10^4$ ， $0 \le z \le 10^5$ 。

题解#

由于要求路径上的最小值最大，所以 ~~二分（当然可以，但我不会QAQ）~~ 求出最大生成树来，然后对于每次询问的两点lca查询路径上的最小值即可

具体实现和lca差不多

问题#

1.建双向边

2.并查集fa[/*!!!*/x_fa] = y;

3.125行取min写成了anc

代码#

1
  #include<bits/stdc++.h>
2
  using namespace std;
3

4
  int read()
5
  {
6
    int f = 1, x = 0;
7
    char ch = getchar();
8
    while(ch < '0' || ch > '9')
9
    {
10
      if(ch == '-') f = -1;
11
      ch = getchar();
12
    }
13

14
    while(ch >= '0' && ch <= '9')
15
    {
16
      x = x * 10 + ch - '0';
17
      ch = getchar();
18
    }
19
    return f * x;
20
  }
21

22
  const int N = 1e4 + 10, M = 1e5 + 100;
23

24
  struct U
25
  {
26
    int x, y, z;
27
    bool operator < (const U o) const
28
    {
29
      return z > o.z;
30
    }
31
  }u[M >> 1]; int cnt = 1;
32

33
  int fa[N], n, m;
34

35
  int anc[N][20], path_min[N][20], depth[N];
36

37
  int getfa(int u)
38
  {
39
    if(fa[u] == u) return u;
40
    return fa[u] = getfa(fa[u]);
41
  }
42

43
  void merge(int x, int y)
44
  {
45
    int x_fa = getfa(x), y_fa = getfa(y);
46
    fa[/*!!!*/x_fa] = y;
47
  }
48

49
  int head[N], nxt[M], to[M], edge[M], tot = 1;
50

51
  void add(int x, int y, int z)
52
  {
53
    to[++tot] = y;
54
    edge[tot] = z;
55
    nxt[tot] = head[x];
56
    head[x] = tot;
57
  }
58

59
  void dfs(int u, int fa)
60
  {
61
    depth[u] = depth[fa] + 1;
62
    anc[u][0] = fa;
63
    for(int i = head[u]; i; i = nxt[i])
64
    {
65
      int v = to[i];
66
      if(v == fa) continue;
67
      path_min[v][0] = edge[i];
68
      dfs(v, u);
69
    }
70
  }
71

72
  void lca_init()
73
  {
74
    for(int j = 1;j < 20;j++)
75
    {
76
      for(int i = 1;i <= n;i++)
77
      {
78
        anc[i][j] = anc[anc[i][j - 1]][j - 1];
79
        path_min[i][j] = min(path_min[i][j - 1], path_min[anc[i][j - 1]][j - 1]);
80
      }
81
    }
82
  }
83

84
  int lca_query_anc(int x, int y)
85
  {
86
    if(depth[x] < depth[y])
87
      swap(x, y);
88
    for(int i = 19;i >= 0;i--)
89
    {
90
      if(depth[anc[x][i]] >= depth[y])
91
        x = anc[x][i];
92
    }
93

94
    if(x == y) return x;
95

96
    for(int i = 19;i >= 0;i--)
97
    {
98
      if(anc[x][i] != anc[y][i])
99
        x = anc[x][i], y = anc[y][i];
100
    }
101
    return anc[x][0];
102
  }
103

104
  int lca_query_min(int x, int y)
105
  {
106
    int ans = 0x3f3f3f3f;
107
    if(depth[x] < depth[y])
108
      swap(x, y);
109
    for(int i = 19;i >= 0;i--)
110
    {
111
      if(depth[anc[x][i]] >= depth[y])
112
      {
113
        ans = min(ans, path_min[x][i]);  x = anc[x][i];
114
      }
115
    }
116
    if(x == y) return ans;
117
    for(int i = 19;i >= 0;i--)
118
    {
119
      if(anc[x][i] != anc[y][i])
120
      {
121
        ans = min(ans, path_min[x][i]), ans = min(ans, path_min[y][i]);
122
        x = anc[x][i], y = anc[y][i];
123
      }
124
    }
125
    return min(ans, min(path_min[x][0], path_min[y][0]));
126
  }
127

128
  int main()
129
  {
130
    n = read(), m = read();
131
    for(int i = 1;i <= n;i++)
132
    {
133
      fa[i] = i;
134
    }
135

136
    int x, y, z;
137
    for(int i = 1;i <= m;i++)
138
    {
139
      x = read(), y = read(), z = read();
140
      u[cnt].x = x;
141
      u[cnt].y = y, u[cnt].z = z;
142
      ++cnt;
143
    }
144

145
    sort(u + 1, u + 1 + m);
146

147
    for(int i = 1;i <= m;i++)
148
    {
149
      int x_fa = getfa(u[i].x), y_fa = getfa(u[i].y);
150
      if(x_fa != y_fa)
151
      {
152
        merge(u[i].x, u[i].y);
153
        add(u[i].x, u[i].y, u[i].z);
154
        add(u[i].y, u[i].x, u[i].z);
155
      }
156
    }
157

158
    for(int i = 1;i <= n;i++)
159
    {
160
      if(fa[i] == i)
161
      {
162
        dfs(i, 0);
163
      }
164
    }
165
    lca_init();
166
    int q;
167
    q = read();
168

169
//    for(int i = 1;i <= n;i++)
170
//    {
171
//      cout << "qwq "<<path_min[i][2] << endl;
172
//    }
173

174
    while(q--)
175
    {
176
      x = read(), y = read();
177
      int x_fa = getfa(x), y_fa = getfa(y);
178
      if(x_fa != y_fa)
179
      {
180
        printf("-1\n");
181
        continue;
182
      }
183
      cout << lca_query_min(x, y) << endl;
184
  }
185

186
}