Welcome to the GitHub repository for Hafez Hafez's projects! This repository serves as a central hub for Hafez Hafez's code, projects, and contributions. Here, you can explore various repositories, contribute to ongoing projects, and stay updated on Hafez Hafez's latest developments.
About Hafez Hafez
Hafez Hafez is a software company known for its innovative solutions in software development. Hafez Hafez is dedicated to creating high-quality software that meets the needs of its users. The company is committed to open-source software and regularly contributes to the open-source community.
Projects
This repository contains a variety of projects, including web applications, mobile apps, and desktop software. Each project is organized into its own repository, making it easy to navigate and contribute to individual projects.
Getting Started
To get started with any of the projects in this repository, simply browse the repositories and clone the ones that interest you. Each repository comes with its own README file that provides detailed instructions on how to set up and run the project on your local machine.
Contributing
Hafez Hafez welcomes contributions from the community. If you're interested in contributing to any of the projects, please fork the repository, make your changes, and submit a pull request. For more information on the contribution process, please refer to the CONTRIBUTING.md file in each repository.
Contact
If you have any questions or need assistance with any of the projects, please don't hesitate to reach out to Hafez Hafez at hafez.hafez@example.com.
License
All projects in this repository are licensed under the MIT License. See the LICENSE file in each repository for more information.
#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[maxn][i] = max(ma[maxn][i - 1], ma[fa[maxn][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[maxn][i] = max(ma[maxn][i - 1], ma[fa[maxn][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[maxn][i] = max(ma[maxn][i - 1], ma[fa[maxn][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[maxn][i] = max(ma[maxn][i - 1], ma[fa[maxn][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[u][i] = max(ma[u][i - 1], ma[fa[u][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[maxn][i] = max(ma[maxn][i - 1], ma[fa[maxn][i - 1]][i - 1]);
}
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
#define maxn 200005
#define inf 1000000007
struct Edge {
int v;
int w;
}
struct Edge {
int u, v, w;
bool operator < (const Edge &a) const {
return w < a.w;
}
}e[maxn], tmp[maxn];
struct edge {
int v, w, next;
}edge[maxn];
int head[maxn], ecnt;
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void addedge(int u, int v, int w) {
edge[ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].next = head[u];
head[u] = ecnt++;
}
void Kruskal(int n, int m) {
sort(e + 1, e + 1 + m);
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
int fu = find(u), fv = find(v);
if (fu != fv) {
f[fu] = fv;
addedge(u, v, e[i].w);
addedge(v, u, e[i].w);
cnt++;
}
if (cnt == n - 1) break;
}
}
int fa[maxn][20], ma[maxn][20], deep[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
for (int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
ma[maxn][i] = max(ma[maxn][i - 1], ma[fa[maxn][i - 1]][i - 1]);
}
for (int i = head[maxn]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
deep[v] = deep[u] + 1;
ma[v][0] = edge[i].w;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int getma(int x, int f) {
int res = 0;
for (int i = 19; i >= 0; i--) {
if (deep[fa[x][i]] >= deep[f]) {
res = max(res, ma[x][i]);
x = fa[x][i];
}
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
}
int q;
scanf("%d", &q);
Kruskal(n, m);
dfs(1, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = LCA(x, y);
int ans = max(getma(x, lca), getma(y, lca));
printf("%d\n", ans);
}
return 0;
}
