text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int sum = 0;
for (int t = 0; t <= 100; t++) {
for (int k = 0; k <= 100; k++) {
if (a >= t && b >= 2 * t + k && c >= 2 * k) {
sum = max(sum, 3 * t + 3 * k);
}
}
}
cout << sum << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int main() {
int te;
scanf("%d", &te);
while (te--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int c2 = 3 * min(b, c / 2);
int g2 = min(b, c / 2);
b -= g2;
int c1 = 3 * min(a, b / 2);
printf("%d\n", c1 + c2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fast_exp(long long base, long long exp) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
exp /= 2;
}
return res % 1000000007;
}
long long fib(long long n) {
if (n < 2) return n;
long long a = 0, b = 1, ans;
int i = 1;
while (i < n) {
ans = (a + b) % 1000000007;
a = b;
b = ans;
i++;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
long long ans = 0;
if (b < c / 2) {
ans += 3 * b;
cout << ans << "\n";
} else {
ans += 3 * (c / 2);
b -= c / 2;
int add = min(a, b / 2);
ans += 3 * add;
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c;
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> a >> b >> c;
int x = min(b, c / 2);
b -= x;
int y = min(a, b / 2);
cout << 3 * (x + y) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e6 + 5;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
inline long long qsm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
int n, m, k, rt;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int ans = 0, a, b, c;
scanf("%d%d%d", &a, &b, &c);
ans += min(c / 2, b);
b -= min(c / 2, b);
ans += min(b / 2, a);
printf("%d\n", ans * 3);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c, ans;
int main() {
scanf("%d", &t);
while (t--) {
ans = 0;
scanf("%d%d%d", &a, &b, &c);
c /= 2;
if (b >= c) {
ans += c * 3;
b -= c;
b /= 2;
if (a >= b)
ans += b * 3;
else
ans += a * 3;
} else
ans += b * 3;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, minimal, minimal2, ans, ans1;
int main() {
cin >> n;
while (n > 0) {
cin >> a >> b >> c;
n--;
int b1 = b, c1 = c;
minimal = min(a, b / 2);
b -= minimal * 2;
ans += minimal + (minimal * 2);
minimal2 = min(b, c / 2);
ans += minimal2 + (minimal2 * 2);
minimal = min(b1, c1 / 2);
ans1 += minimal + (minimal * 2);
b1 -= minimal;
minimal2 = min(a, b1 / 2);
ans1 += minimal2 + (minimal2 * 2);
(ans > ans1) ? cout << ans << endl : cout << ans1 << endl;
ans = 0;
ans1 = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, c;
cin >> t;
while (t--) {
cin >> a >> b >> c;
int ans = 0;
if (c / 2 <= b)
ans += c / 2 * 2 + c / 2, b -= c / 2;
else {
cout << b * 3 << endl;
continue;
}
if (b / 2 <= a)
cout << ans + b / 2 * 2 + b / 2 << endl;
else
cout << ans + a * 3 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, c;
cin >> t;
int ans[t];
for (int i = 0; i < t; i++) {
cin >> a >> b >> c;
ans[i] = ((min(c / 2, b)) * 3 + (min(a, (b - min(c / 2, b)) / 2)) * 3);
}
for (int z = 0; z < t; z++) {
cout << ans[z] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, c, sum, i, j, k;
cin >> t;
for (i = 0; i < t; i++) {
sum = 0;
cin >> a >> b >> c;
while (c >= 2 && b >= 1) {
sum += 3;
c -= 2;
b -= 1;
}
while (b >= 2 && a >= 1) {
sum += 3;
a -= 1;
b -= 2;
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
int count = 0;
int mn = min(b, c / 2);
count += (mn * 3);
b -= mn;
c -= (2 * mn);
mn = min(a, b / 2);
count += (mn * 3);
cout << count << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int maxn = 1000;
while (t--) {
int sum = 0, sum2 = 0;
int a, b, c;
cin >> a >> b >> c;
int e = a, f = b, g = c;
while (a >= 1 && b >= 2) {
sum += 3;
b -= 2;
a -= 1;
}
while (b >= 1 && c >= 2) {
sum += 3;
b -= 1;
c -= 2;
}
while (f >= 1 && g >= 2) {
sum2 += 3;
g -= 2;
f -= 1;
}
while (e >= 1 && f >= 2) {
sum2 += 3;
e -= 1;
f -= 2;
}
if (sum >= sum2)
cout << sum << endl;
else
cout << sum2 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int test, x, y, z;
cin >> test;
while (test--) {
int ans = 0;
cin >> x >> y >> z;
ans += min(y, z / 2);
y -= ans;
ans += min(x, y / 2);
cout << ans * 3 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
if (fopen("test.inp", "r"))
freopen("test.inp", "r", stdin), freopen("test.out", "w", stdout);
cin >> t;
while (t--) {
cin >> a >> b >> c;
int res = 0;
for (int i = 0; i <= 100; i++)
for (int j = 0; j <= 100; j++)
if (i <= a && i * 2 + j <= b && j * 2 <= c) {
res = max(res, i + i * 2 + j + j * 2);
}
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
while (b >= 1 && c >= 2) {
ans += 3;
b--;
c -= 2;
}
while (a >= 1 && b >= 2) {
ans += 3;
a--;
b -= 2;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int T, a, b, c, sum;
int main() {
scanf("%d", &T);
while (T--) {
sum = 0;
scanf("%d%d%d", &a, &b, &c);
int num = c / 2;
if (b >= num) {
sum += num * 2;
sum += num;
b -= num;
num = b / 2;
if (a >= num) {
sum += num * 2;
sum += num;
} else {
sum += a * 2;
sum += a;
}
} else {
sum += b * 2;
sum += b;
}
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int total = 0;
total += 3 * (min(b, c / 2));
b -= total / 3;
total += 3 * min(a, b / 2);
cout << total << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
void solve() {
long long a, b, c;
cin >> a >> b >> c;
long long x = min(2 * b, c);
long long ans = 0;
if (x == c) {
long long y = c / 2;
b = b - y;
ans += 3 * y;
} else {
ans = ans + 3 * b;
b = 0;
}
if (b > 0) {
long long z = min(2 * a, b);
if (z == b) {
long long p = b / 2;
ans = ans + 3 * p;
} else {
ans = ans + 3 * a;
a = 0;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int _i = 0; _i < t; ++_i) {
int a, b, c;
int ans = 0;
cin >> a >> b >> c;
for (int x = 0; x <= a; ++x) {
for (int y = 0; 2 * y <= c; ++y) {
if (2 * x + y <= b) ans = max(ans, 3 * (x + y));
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, t;
int main() {
cin >> t;
while (t--) {
cin >> a >> b >> c;
int maxim = 0;
for (int i = 0; i <= a; ++i) {
for (int j = 0; j <= b; ++j) {
int aa = a, bb = b, cc = c, contor = 0;
aa -= i;
bb -= 2 * i;
if (aa < 0 || bb < 0) continue;
contor = i * 3;
bb -= j;
cc -= 2 * j;
if (bb < 0 || cc < 0) continue;
contor += j * 3;
maxim = max(contor, maxim);
}
}
cout << maxim << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int x = 0; x < a + 1; x++) {
for (int y = 0; y < c / 2 + 1; y++) {
if (2 * x + y <= b) ans = max(3 * x + 3 * y, ans);
}
}
cout << ans << "\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int a, b, c;
cin >> a >> b >> c;
if (b == 0) {
cout << "0\n";
} else if (a == 0) {
if (b > c / 2) {
cout << ((c / 2) * 3) << "\n";
} else if (b <= c / 2) {
cout << (b * 3) << "\n";
}
} else if (c == 0) {
if (a > b / 2) {
cout << ((b / 2) * 3) << "\n";
} else if (a <= b / 2) {
cout << (a * 3) << "\n";
}
} else {
int ans = 0;
if (b > c / 2) {
ans += (c / 2) * 3;
b -= c / 2;
} else if (b <= c / 2) {
ans += (b * 3);
b = 0;
}
if (a > b / 2) {
ans += (((b / 2) * 3));
} else if (a <= b / 2) {
ans += (a * 3);
}
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a, b, c, i, j, s = 0;
cin >> a >> b >> c;
if (2 * b <= c) {
s = s + 3 * b;
} else {
s += 3 * (c / 2);
b = b - (c / 2);
if (2 * a <= b) {
s += 3 * a;
} else {
s += 3 * (b / 2);
}
}
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c, s = 0;
cin >> a >> b >> c;
if ((2 * b) <= c) {
s = 3 * b;
} else {
b = b - c / 2;
s = s + (3 * (c / 2));
if ((2 * a) <= b) {
s = s + 3 * a;
} else {
a = a - b / 2;
s = s + (3 * (b / 2));
}
}
cout << s << "\n";
}
signed main() {
long long t = 1;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int arr[101][101][101];
int fboii(int a, int b, int c) {
if (arr[a][b][c] != -1) {
return arr[a][b][c];
}
int ans1 = 0, ans2 = 0;
if (a >= 1 && b >= 2) {
ans1 = 3 + fboii(a - 1, b - 2, c);
}
if (b >= 1 && c >= 2) {
ans2 = 3 + fboii(a, b - 1, c - 2);
}
arr[a][b][c] = max(ans1, ans2);
return max(ans1, ans2);
}
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i < 101; i++) {
for (int j = 0; j < 101; j++) {
for (int k = 0; k < 101; k++) {
arr[i][j][k] = -1;
}
}
}
cout << fboii(a, b, c) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, c;
cin >> t;
while (t--) {
cin >> a >> b >> c;
int x = min(c / 2, b);
b -= x;
c -= 2 * x;
int y = min(b / 2, a);
cout << (x + y) * 3 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a, b, c, count;
cin >> t;
while (t--) {
count = 0;
cin >> a >> b >> c;
if (b == 0) {
cout << 0 << "\n";
continue;
}
if (a == 0) {
if (b >= (c / 2) && c > 0) {
count += ((c / 2) + (2 * (c / 2)));
c = c - (2 * (c / 2));
} else if (c > 0) {
count += (3 * b);
c = c - (2 * b);
}
cout << count << "\n";
continue;
}
if (c == 0) {
if (a >= (b / 2) && b > 0) {
count += ((b / 2) + (2 * (b / 2)));
b = b - (2 * (b / 2));
} else if (b > 0) {
count += (3 * a);
b = b - (2 * a);
}
cout << count << "\n";
continue;
}
long long aa = a, bb = b, cc = c;
if (a >= (b / 2)) {
count += ((b / 2) + (2 * (b / 2)));
b = b - (2 * (b / 2));
} else {
count += (3 * a);
b = b - (2 * a);
}
if (b >= (c / 2) && c > 0) {
count += ((c / 2) + (2 * (c / 2)));
c = c - (2 * (c / 2));
} else {
if (c > 0) {
count += (3 * b);
c = c - (2 * b);
}
}
long long count1 = count;
count = 0;
if (bb >= (cc / 2)) {
count += ((cc / 2) + (2 * (cc / 2)));
bb = bb - (cc / 2);
} else {
count += (3 * bb);
bb = bb - (cc / 2);
}
if (aa >= (bb / 2) && bb > 0) {
count += ((bb / 2) + (2 * (bb / 2)));
bb = bb - (2 * (bb / 2));
} else {
if (bb > 0) {
count += (3 * aa);
bb = bb - (2 * aa);
}
}
long long count2 = count;
cout << max(count1, count2) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, k, a, b, c, req, x;
cin >> t;
for (k = 0; k < t; k++) {
cin >> a >> b >> c;
req = 0;
x = min(b, c / 2);
if (b >= x) {
req += (x * 2) + x;
c -= (x * 2);
b -= x;
}
x = min(a, b / 2);
if (a >= x) {
req += (x * 2) + x;
b -= (x * 2);
a -= x;
}
cout << req << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, a, b, c, num1, num2;
cin >> q;
while (q--) {
cin >> a >> b >> c;
num1 = min(a, b / 2);
num2 = min(b, c / 2);
int sum = 0;
sum += num2;
sum += min(a, (b - num2) / 2);
cout << sum * 3 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int ans = min(b, c / 2);
c -= 2 * ans;
b -= ans;
ans += min(a, b / 2);
cout << ans * 3 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, t, res;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a >> b >> c;
res = 0;
while (b - 1 >= 0 && c - 2 >= 0) {
res += 3;
c -= 2;
b--;
}
while (b - 2 >= 0 && a - 1 >= 0) {
res += 3;
a--;
b -= 2;
}
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
cin >> n;
long long a, b, c;
for (long long i = 0; i < n; i++) {
cin >> a >> b >> c;
long long ans = 0;
ans += min(b, c / 2);
b -= ans;
ans += min(a, b / 2);
cout << ans * 3 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, c;
cin >> t;
while (t--) {
cin >> a >> b >> c;
int x = c / 2, sum = 0;
sum += 3 * min(x, b);
b -= min(x, b);
int y = b / 2;
sum += min(a, y) * 3;
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int m, ans = 0;
m = min(b, c / 2);
ans += m * 3;
b = b - m;
c -= 2 * m;
m = min(a, b / 2);
ans += m * 3;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
int main(void) {
int T;
T = read();
while (T--) {
int a, b, c, ans = 0;
a = read(), b = read(), c = read();
ans += min(b, c >> 1) * 3;
b -= min(b, c >> 1);
ans += min(b >> 1, a) * 3;
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int n = 0;
while (b > 0 && c > 1) {
int p = c / 2;
int q = b;
if (p > q) {
b = 0;
n += 3 * q;
break;
} else {
c = 0;
n += 3 * p;
b -= p;
}
}
while (a > 0 && b > 1) {
int p = b / 2;
int q = a;
if (p > q) {
a = 0;
n += 3 * q;
break;
} else {
b = 0;
n += 3 * p;
a -= p;
}
}
cout << n << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
long long int power(int x, int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = ((res % mod) * (x % mod)) % mod;
y = y >> 1;
x = ((x % mod) * (x % mod)) % mod;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int i = c / 2;
int stone = 0;
if (b - i > 0) {
stone += i * 2 + i;
b -= i;
} else {
stone += b * 2 + b;
b = 0;
}
int j = b / 2;
if (a - j > 0)
stone += j * 2 + j;
else
stone += a * 2 + a;
cout << stone << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int x, y;
long long val;
} e[3 * 100055];
bool cmp(Edge x1, Edge x2) { return x1.val < x2.val; }
int head[100055], to[6 * 100055], nex[6 * 100055];
long long w[6 * 100055];
int edge;
inline void addEdge(int x, int y, long long z) {
to[++edge] = y, w[edge] = z, nex[edge] = head[x], head[x] = edge;
to[++edge] = x, w[edge] = z, nex[edge] = head[y], head[y] = edge;
}
int n, m, k, q;
void init() {
for (int i = 1; i <= n; i++) head[i] = 0;
edge = 0;
}
bool vis[100055];
long long d[100055];
struct node {
int x;
long long val;
node(int x, long long val) : x(x), val(val) {}
friend bool operator<(node x1, node x2) { return x1.val > x2.val; }
};
priority_queue<node> que;
int pre[100055];
int findd(int x) {
if (pre[x] == x) return x;
return pre[x] = findd(pre[x]);
}
long long f[100055][18];
int g[100055][18];
int dep[100055];
int N;
void dfs(int u, int fa) {
for (int i = 1; i <= N; i++) {
g[u][i] = g[g[u][i - 1]][i - 1];
f[u][i] = max(f[u][i - 1], f[g[u][i - 1]][i - 1]);
}
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == fa) continue;
dep[v] = dep[u] + 1;
g[v][0] = u;
f[v][0] = w[i];
dfs(v, u);
}
}
inline long long lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
long long ans = 0;
for (int i = N; i >= 0; i--) {
if (dep[g[y][i]] >= dep[x]) {
ans = max(ans, f[y][i]);
y = g[y][i];
}
}
if (x == y) return ans;
for (int i = N; i >= 0; i--) {
if (g[x][i] != g[y][i]) {
ans = max(f[x][i], ans);
ans = max(f[y][i], ans);
x = g[x][i];
y = g[y][i];
}
}
if (x != y) ans = max(ans, f[x][0]), ans = max(ans, f[y][0]);
return ans;
}
int main() {
cin >> n >> m >> k >> q;
int x, y, z;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
addEdge(x, y, z);
e[i].x = x, e[i].y = y, e[i].val = z;
}
for (int i = k + 1; i <= n; i++) d[i] = 0x7f7f7f7f7f7f7f7f;
for (int i = 1; i <= k; i++) que.push(node(i, 0));
while (que.size()) {
int u = que.top().x;
que.pop();
if (vis[u]) continue;
vis[u] = true;
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (d[v] > d[u] + w[i]) {
d[v] = d[u] + w[i];
que.push(node(v, d[v]));
}
}
}
for (int i = 1; i <= m; i++) e[i].val += (d[e[i].x] + d[e[i].y]);
sort(e + 1, e + 1 + m, cmp);
init();
for (int i = 1; i <= n; i++) pre[i] = i;
for (int i = 1; i <= m; i++) {
x = e[i].x;
int xx = findd(x);
y = e[i].y;
int yy = findd(y);
if (xx != yy) {
pre[xx] = yy;
addEdge(x, y, e[i].val);
}
}
N = ceil(log2(n));
dep[1] = 1;
dfs(1, 0);
while (q--) {
scanf("%d%d", &x, &y);
printf("%lld\n", lca(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int ONE = 2000005;
const long long INF = 1ll << 60;
int get() {
int res = 1, Q = 1;
char c;
while ((c = getchar()) < 48 || c > 57)
if (c == '-') Q = -1;
if (Q) res = c - 48;
while ((c = getchar()) >= 48 && c <= 57) res = res * 10 + c - 48;
return res * Q;
}
int n, m, k, Q;
int nxt[ONE], first[ONE], go[ONE], tot;
long long w[ONE];
int x, y, num;
long long val;
struct power {
int x, y;
long long val;
friend bool operator<(const power &a, const power &b) {
return a.val < b.val;
}
} a[ONE];
void Add(int u, int v, long long e) {
nxt[++tot] = first[u], first[u] = tot, go[tot] = v, w[tot] = e;
nxt[++tot] = first[v], first[v] = tot, go[tot] = u, w[tot] = e;
}
long long dist[ONE];
bool vis[ONE];
priority_queue<pair<long long, int>> q;
void Dijkstra() {
for (int i = 1; i <= k; i++) q.emplace(0, i);
for (int i = k + 1; i <= n; i++) dist[i] = INF;
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int e = first[u]; e; e = nxt[e]) {
int v = go[e];
if (dist[v] > dist[u] + w[e])
dist[v] = dist[u] + w[e], q.emplace(-dist[v], v);
}
}
}
int siz[ONE], son[ONE], top[ONE], fat[ONE], Dep[ONE];
void Dfs1(int u, int fa) {
siz[u] = 1, fat[u] = fa, Dep[u] = Dep[fa] + 1;
for (int e = first[u]; e; e = nxt[e]) {
int v = go[e];
if (v == fa) continue;
Dfs1(v, u);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
void Dfs2(int u, int fa) {
if (int v = son[u]) top[v] = top[u], Dfs2(v, u);
for (int e = first[u]; e; e = nxt[e]) {
int v = go[e];
if (v == fa || v == son[u]) continue;
Dfs2(top[v] = v, u);
}
}
int LCA(int u, int v) {
while (top[u] != top[v]) {
int &x = Dep[top[u]] > Dep[top[v]] ? u : v;
x = fat[top[x]];
}
return Dep[u] < Dep[v] ? u : v;
}
int f[ONE];
int Find(int x) {
if (f[x] == x) return x;
return f[x] = Find(f[x]);
}
int now;
long long value[ONE];
void Kruskal() {
num = 0;
for (int u = 1; u <= n; u++)
for (int e = first[u]; e; e = nxt[e])
a[++num] = (power){u, go[e], w[e] + dist[u] + dist[go[e]]};
sort(a + 1, a + num + 1);
tot = 0;
for (int i = 1; i <= (n << 1) + 1; i++) f[i] = i, first[i] = 0;
now = n;
for (int i = 1; i <= num; i++) {
int fx = Find(a[i].x), fy = Find(a[i].y);
if (fx != fy) {
value[++now] = a[i].val;
f[fx] = f[fy] = now;
Add(now, fx, 0), Add(now, fy, 0);
}
}
}
int main() {
cin >> n >> m >> k >> Q;
for (int i = 1; i <= m; i++) {
scanf("%d %d %lld", &x, &y, &val);
Add(x, y, val);
}
Dijkstra();
Kruskal();
top[now] = now;
Dfs1(now, 0);
Dfs2(now, 0);
while (Q--) {
scanf("%d %d", &x, &y);
printf("%lld\n", value[LCA(x, y)]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct dataEdge {
long long u, v, w;
dataEdge(){};
dataEdge(long long u, long long v, long long w) : u(u), v(v), w(w){};
bool operator<(const dataEdge &a) const { return w < a.w; }
};
struct dataHeap {
long long u, type, val;
dataHeap(){};
dataHeap(long long u, long long type, long long val)
: u(u), type(type), val(val){};
bool operator>(const dataHeap &u) const { return val > u.val; }
};
const long long N = 3e5 + 4, oo = 1e17 + 4;
long long n, m, k, QQues;
vector<pair<long long, long long> > adj[N];
vector<dataEdge> Edge;
long long par[N];
vector<long long> lsNode;
long long getRoot(long long u) {
return (par[u] < 0) ? u : (par[u] = getRoot(par[u]));
}
bool Merge(long long u, long long v) {
u = getRoot(u);
v = getRoot(v);
if (u == v) return false;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
return true;
}
long long d[N][2], root[N][2];
priority_queue<dataHeap, vector<dataHeap>, greater<dataHeap> > pq;
void Dijkstra0() {
for (long long u = 1; u <= (long long)n; ++u)
d[u][0] = d[u][1] = oo, root[u][0] = root[u][1] = -1;
for (long long u = 1; u <= (long long)k; ++u) {
d[u][0] = 0;
root[u][0] = u;
pq.push(dataHeap(u, 0, d[u][0]));
}
while (pq.size()) {
long long u = pq.top().u, type = pq.top().type, val = pq.top().val;
pq.pop();
if (d[u][type] != val) continue;
for (pair<long long, long long> foo : adj[u]) {
long long v = foo.second, cost = foo.first;
if (d[v][0] > val + cost) {
d[v][0] = val + cost;
root[v][0] = root[u][type];
pq.push(dataHeap(v, 0, d[v][0]));
}
}
}
}
void Dijkstra1() {
for (long long u = 1; u <= (long long)n; ++u)
pq.push(dataHeap(u, 0, d[u][0]));
while (pq.size()) {
long long u = pq.top().u, type = pq.top().type, val = pq.top().val;
pq.pop();
if (d[u][type] != val) continue;
for (pair<long long, long long> foo : adj[u]) {
long long v = foo.second, cost = foo.first;
if (d[v][1] > val + cost &&
getRoot(root[v][0]) != getRoot(root[u][type])) {
d[v][1] = val + cost;
root[v][1] = root[u][type];
pq.push(dataHeap(v, 1, d[v][1]));
}
}
}
}
dataEdge Trace[N];
vector<dataEdge> Tree, CC;
long long Time, debug, best[N];
void sol() {
for (long long u = 1; u <= (long long)n; ++u) {
par[u] = -1;
if (u <= k) lsNode.push_back(u);
}
while (true) {
if ((long long)lsNode.size() == 1) return;
Dijkstra0();
Dijkstra1();
for (long long u = 1; u <= (long long)n; ++u)
best[u] = oo, Trace[u] = dataEdge(-1, -1, -1);
for (long long u = 1; u <= (long long)k; ++u) {
long long v = root[u][1], w = d[u][1], topo_u = getRoot(u),
topo_v = getRoot(v);
if (v == -1) continue;
if (best[topo_u] > d[u][1]) {
best[topo_u] = d[u][1];
Trace[topo_u] = dataEdge(u, v, w);
}
if (best[topo_v] > d[u][1]) {
best[topo_v] = d[u][1];
Trace[topo_v] = dataEdge(u, v, w);
}
}
CC.clear();
for (long long topo : lsNode) {
long long u = Trace[topo].u, v = Trace[topo].v, w = Trace[topo].w;
if (u != -1) CC.push_back(dataEdge(u, v, w));
}
sort(CC.begin(), CC.end());
for (dataEdge foo : CC) {
long long u = foo.u, v = foo.v;
if (Merge(u, v)) Tree.push_back(foo);
}
lsNode.clear();
for (long long u = 1; u <= (long long)k; ++u)
if (par[u] < 0) lsNode.push_back(u);
}
}
long long Low[N], High[N], ans[N];
vector<long long> needCheck[N];
pair<long long, long long> ques[N];
void Answer_Query() {
assert((long long)Tree.size() == k - 1);
sort(Tree.begin(), Tree.end());
for (long long i = 1; i <= (long long)QQues; ++i)
cin >> ques[i].first >> ques[i].second;
for (long long i = 1; i <= (long long)QQues; ++i)
Low[i] = 0, High[i] = k - 1, ans[i] = -1;
while (true) {
bool isEnd = true;
for (long long i = 1; i <= (long long)QQues; ++i)
if (Low[i] <= High[i]) {
long long mid = (Low[i] + High[i]) / 2;
needCheck[mid].push_back(i);
isEnd = false;
}
if (isEnd) break;
for (long long u = 1; u <= (long long)n; ++u) par[u] = -1;
for (long long i = 0; i < (long long)Tree.size(); ++i) {
long long u = Tree[i].u, v = Tree[i].v, w = Tree[i].w;
Merge(u, v);
for (long long id : needCheck[i]) {
long long u = ques[id].first, v = ques[id].second;
u = getRoot(u);
v = getRoot(v);
if (u == v) {
High[id] = i - 1;
ans[id] = w;
} else
Low[id] = i + 1;
}
needCheck[i].clear();
}
}
for (long long i = 1; i <= (long long)QQues; ++i) cout << ans[i] << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
cin >> n >> m >> k >> QQues;
long long u, v, w;
for (long long i = 1; i <= (long long)m; ++i) {
cin >> u >> v >> w;
adj[u].push_back(pair<long long, long long>(w, v));
adj[v].push_back(pair<long long, long long>(w, u));
Edge.push_back(dataEdge(u, v, w));
}
sol();
Answer_Query();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> sz;
UnionFind(int n = 0) {
if (n > 0) initialize(n);
}
void initialize(int n) {
par.resize(n);
sz.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (sz[x] > sz[y]) swap(x, y);
par[x] = y;
sz[y] += sz[x];
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return sz[find(x)]; }
};
struct UnionFind_P {
vector<int> par;
vector<int> rank;
vector<int64_t> time;
vector<vector<pair<int64_t, int>>> sz;
const int64_t INF = 1e18;
void initialize(int n) {
par.resize(n);
rank.resize(n);
time.resize(n);
sz.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
time[i] = INF;
sz[i].push_back({-1, 1});
}
}
int find(int x, int64_t t) {
if (time[x] > t) {
return x;
} else {
return find(par[x], t);
}
}
int size(int x, int64_t t) {
x = find(x, t);
return (*(lower_bound(sz[x].begin(), sz[x].end(), make_pair(t + 1, 0)) - 1))
.second;
}
void unite(int x, int y, int64_t t) {
x = find(x, t);
y = find(y, t);
if (x == y) return;
int new_sz = sz[x].back().second + sz[y].back().second;
if (sz[x].back().second > sz[y].back().second) swap(x, y);
par[x] = y;
time[x] = t;
sz[y].push_back({t, new_sz});
}
bool same(int x, int y, int64_t t) { return find(x, t) == find(y, t); }
};
int main() {
int N, M, K, Q;
cin >> N >> M >> K >> Q;
vector<pair<int64_t, int64_t>> edges[100000];
for (int i = 0; i < M; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
edges[a].emplace_back(b, c);
edges[b].emplace_back(a, c);
}
vector<pair<int64_t, int64_t>> dist(N);
bitset<100000> done;
pair<int64_t, int64_t> INFP = {1e18, 1e18};
priority_queue<vector<int64_t>, vector<vector<int64_t>>,
greater<vector<int64_t>>>
que;
for (int i = 0; i < K; i++) {
dist[i] = {0, i};
que.push({0, i, i});
}
for (int i = K; i < N; i++) dist[i] = INFP;
while (que.size()) {
auto p = que.top();
que.pop();
int64_t d = p[0], i = p[1], s = p[2];
done[i] = 1;
if (dist[i].first < d) continue;
for (auto& e : edges[i]) {
int64_t j = e.first, d2 = d + e.second;
if (dist[j].first > d2) {
dist[j] = {d2, s};
que.push({d2, j, s});
}
}
}
vector<vector<int64_t>> es;
for (int i = 0; i < N; i++)
for (auto& e : edges[i]) {
int j = e.first, c = e.second;
es.push_back(
{dist[i].first + dist[j].first + c, dist[i].second, dist[j].second});
}
sort(es.begin(), es.end());
UnionFind_P uf;
uf.initialize(N);
for (auto& e : es) uf.unite(e[1], e[2], e[0]);
for (int i = 0; i < Q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
int64_t ok = 1e18, ng = -1;
while (ok - ng > 1) {
int64_t mid = (ok + ng) / 2;
(uf.same(a, b, mid) ? ok : ng) = mid;
}
printf("%lld\n", ok);
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
using namespace std;
const int N = 200001;
const int LN = 20;
struct T {
int u, v;
int64_t c;
bool operator<(const T& a) const { return c > a.c; }
};
struct E {
int u;
int64_t c;
bool operator<(const E& a) const { return c < a.c; }
} d[N];
unordered_map<int, unordered_map<int, int64_t>> mp;
vector<E> gr[N], tr[N];
E st[N][LN];
int p[N], dep[N];
bool v[N];
void dfs(int node, int p, int64_t c, int depth) {
dep[node] = depth;
st[node][0].u = p;
st[node][0].c = c;
for (E it : tr[node])
if (it.u != p) dfs(it.u, node, it.c, depth + 1);
}
void initLca(int n) {
for (int j = 1; j < LN; j++) {
for (int i = 1; i <= n; i++) {
st[i][j].u = st[st[i][j - 1].u][j - 1].u;
st[i][j].c = max(st[i][j - 1].c, st[st[i][j - 1].u][j - 1].c);
}
}
}
int64_t lca(int u, int v) {
int64_t ans = 0;
if (dep[u] < dep[v]) swap(u, v);
for (int i = LN - 1; i >= 0; i--) {
if (dep[st[u][i].u] >= dep[v]) {
ans = max(ans, st[u][i].c);
u = st[u][i].u;
}
}
if (u == v) return ans;
for (int i = LN - 1; i >= 0; i--) {
if (st[u][i].u != st[v][i].u) {
ans = max(ans, max(st[u][i].c, st[v][i].c));
u = st[u][i].u;
v = st[v][i].u;
}
}
return max(ans, max(st[u][0].c, st[v][0].c));
}
int par(int node) { return (p[node] < 0 ? node : p[node] = par(p[node])); }
void merge(int u, int v, int64_t d) {
int pu = par(u);
int pv = par(v);
if (pu != pv) {
if (p[pu] < p[pv]) {
p[pu] += p[pv];
p[pv] = pu;
} else {
p[pv] += p[pu];
p[pu] = pv;
}
tr[u].push_back({v, d});
tr[v].push_back({u, d});
}
}
int main() {
ios_base::sync_with_stdio(false);
memset(p, -1, sizeof p);
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 0, u, v, c; i < m; i++) {
cin >> u >> v >> c;
gr[u].push_back({v, c});
gr[v].push_back({u, c});
}
priority_queue<T> Q;
for (int i = 1; i <= k; i++) Q.push({i, i, 0});
while (!Q.empty()) {
int node = Q.top().u;
int v = Q.top().v;
int64_t c = Q.top().c;
Q.pop();
if (::v[node]) {
int64_t& x = mp[d[node].u][v];
if (x)
x = min(x, c + d[node].c);
else
x = c + d[node].c;
continue;
}
::v[node] = true;
d[node] = {v, c};
for (E it : gr[node]) Q.push({it.u, v, it.c + c});
}
for (int i = 1; i <= k; i++)
for (auto it : mp[i]) Q.push({i, it.first, it.second});
while (!Q.empty()) {
merge(Q.top().u, Q.top().v, Q.top().c);
Q.pop();
}
dfs(1, 0, 0, 1);
initLca(k);
while (q--) {
int u, v;
cin >> u >> v;
cout << lca(u, v) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct UnionFind {
vector<int> nxt;
void init(int x) {
nxt.clear();
nxt.resize(x);
for (int i = 0; i < x; i++) {
nxt[i] = i;
}
}
int find(int x) {
if (nxt[x] == x) return x;
return nxt[x] = find(nxt[x]);
}
inline void unite(int x, int y) { nxt[find(y)] = find(x); }
};
long long N, M, K, Q;
vector<pair<long long, long long>> uvt[101010], cnt[101010], subcnt[101010];
long long dps[101010];
pair<long long, long long> pc[101010][30];
long long i, j, k, ans;
void crecntg() {
priority_queue<pair<long long, pair<long long, long long>>> pq;
vector<pair<long long, long long>> mk(N + 2, {0, 0});
long long ct = 0;
for (i = 0; i < K; i++) {
pq.push({0, {i + 1, i + 1}});
}
while (pq.size()) {
auto qa = pq.top();
pq.pop();
long long c = qa.first;
long long a = qa.second.first;
long long p = qa.second.second;
if (mk[a].second != 0) {
if (mk[a].second == p) continue;
subcnt[p].push_back({mk[a].second, mk[a].first - c});
subcnt[mk[a].second].push_back({p, mk[a].first - c});
continue;
}
mk[a] = {-c, p};
for (i = 0; i < uvt[a].size(); i++) {
auto b = uvt[a][i];
if (mk[b.first].second == p) continue;
pq.push({c - b.second, {b.first, p}});
}
}
}
void krus() {
priority_queue<pair<long long, pair<long long, long long>>> pq;
UnionFind uf;
uf.init(K + 1);
long long i, j;
for (i = 0; i < K; i++) {
for (j = 0; j < subcnt[i + 1].size(); j++) {
pq.push({-subcnt[i + 1][j].second, {i + 1, subcnt[i + 1][j].first}});
}
}
while (pq.size()) {
auto qa = pq.top();
pq.pop();
long long a = qa.second.first;
long long b = qa.second.second;
if (uf.find(a) == uf.find(b)) continue;
cnt[a].push_back({b, -qa.first});
cnt[b].push_back({a, -qa.first});
uf.unite(a, b);
}
}
void dfs(long long a, long long p, long long c, long long d) {
long long i = 0;
dps[a] = d;
pc[a][0] = {p, c};
for (i = 0; i < cnt[a].size(); i++) {
if (cnt[a][i].first != p) dfs(cnt[a][i].first, a, cnt[a][i].second, d + 1);
}
}
void setpp() {
long long i, j;
for (i = 0; i < 20; i++) {
for (j = 0; j < K; j++) {
pair<long long, long long> b = pc[j + 1][i];
pair<long long, long long> c = pc[b.first][i];
pc[j + 1][i + 1] = {c.first, max(c.second, b.second)};
}
}
}
void solve() {
long long a, b;
scanf("%lld%lld", &a, &b);
if (dps[a] > dps[b]) {
swap(a, b);
}
long long acp = 0, bcp = 0;
long long i;
for (i = 20; i >= 0; i--) {
if (dps[b] - (1 << i) >= dps[a]) {
bcp = max(pc[b][i].second, bcp);
b = pc[b][i].first;
}
}
if (a == b) {
printf("%lld\n", bcp);
return;
}
for (i = 20; i >= 0; i--) {
if (pc[a][i].first != pc[b][i].first) {
acp = max(pc[a][i].second, acp);
bcp = max(pc[b][i].second, bcp);
a = pc[a][i].first;
b = pc[b][i].first;
}
}
acp = max(pc[a][0].second, acp);
bcp = max(pc[b][0].second, bcp);
printf("%lld\n", max(acp, bcp));
}
int main() {
scanf("%lld%lld%lld%lld", &N, &M, &K, &Q);
for (i = 0; i < M; i++) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
uvt[u].push_back({v, w});
uvt[v].push_back({u, w});
}
crecntg();
krus();
dfs(1, 0, 0, 1);
setpp();
while (Q--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const long long inf = 1e18 + 9;
int n, m, k, q;
vector<pair<int, int> > g[maxn];
pair<long long, pair<int, int> > edges[maxn];
pair<int, int> query[maxn];
struct data {
int id;
long long val;
bool operator<(const data& other) const { return val > other.val; }
};
long long d[maxn];
int lab[maxn];
int low[maxn], high[maxn];
vector<int> vec[maxn];
void read_input() {
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
edges[i] = make_pair(w, pair<int, int>(u, v));
g[u].push_back(pair<int, int>(v, w));
g[v].push_back(pair<int, int>(u, w));
}
for (int i = 1; i <= q; ++i) {
int u, v;
cin >> u >> v;
query[i] = pair<int, int>(u, v);
}
}
void dijkstra() {
priority_queue<data> pq;
fill(d + 1, d + n + 1, inf);
for (int i = 1; i <= k; ++i) {
d[i] = 0;
pq.push({i, 0});
}
while (!pq.empty()) {
data tp = pq.top();
pq.pop();
if (tp.val != d[tp.id]) continue;
int u = tp.id;
for (auto& to : g[u]) {
int v = to.first, w = to.second;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
pq.push({v, d[v]});
}
}
}
}
int find_set(int u) { return lab[u] < 0 ? u : lab[u] = find_set(lab[u]); }
void union_sets(int u, int v) {
if (lab[u] < lab[v]) swap(u, v);
lab[v] += lab[u];
lab[u] = v;
}
void solve() {
dijkstra();
for (int i = 1; i <= m; ++i) {
int u = edges[i].second.first, v = edges[i].second.second;
edges[i].first += d[u] + d[v];
}
sort(edges + 1, edges + m + 1);
for (int i = 1; i <= q; ++i) {
low[i] = 1;
high[i] = m;
}
while (true) {
bool stop = true;
for (int i = 1; i <= q; ++i)
if (low[i] <= high[i]) {
stop = false;
int mid = (low[i] + high[i]) / 2;
vec[mid].push_back(i);
}
if (stop) break;
fill(lab + 1, lab + n + 1, -1);
for (int i = 1; i <= m; ++i) {
int u = edges[i].second.first, v = edges[i].second.second;
u = find_set(u);
v = find_set(v);
if (u != v) union_sets(u, v);
while ((int)vec[i].size()) {
int id = vec[i].back();
vec[i].pop_back();
if (find_set(query[id].first) == find_set(query[id].second))
high[id] = i - 1;
else
low[id] = i + 1;
}
}
}
for (int i = 1; i <= q; ++i) cout << edges[low[i]].first << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
read_input();
solve();
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 62);
const int inf = (1 << 30);
const int nmax = 3e5 + 50;
const long long mod = 1e9 + 7;
using namespace std;
int n, m, k, q, i, x, y, sz[nmax], p[nmax], ex[nmax], ey[nmax];
long long w, ew[nmax], d[nmax], rs[nmax];
vector<pair<int, int> > qr[nmax], tmp;
vector<pair<int, long long> > a[nmax];
vector<pair<long long, pair<int, int> > > vc;
set<pair<long long, int> > s;
vector<int> v[nmax];
map<int, bool> mp[nmax];
int fnd(int x) {
if (p[x] == x) return x;
return p[x] = fnd(p[x]);
}
void uni(int x, int y, long long w) {
x = fnd(x), y = fnd(y);
if (sz[x] < sz[y]) swap(x, y);
int u;
for (int i = 0; i < (int)v[y].size(); i++) {
u = v[y][i];
for (int j = 0; j < (int)qr[u].size(); j++) {
if (rs[qr[u][j].second]) continue;
if (mp[x][qr[u][j].first]) rs[qr[u][j].second] = w;
}
mp[x][u] = 1;
v[x].push_back(u);
}
v[y].clear();
mp[y].clear();
sz[x] += sz[y];
p[y] = x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
for (i = 1; i <= m; i++) {
cin >> ex[i] >> ey[i] >> ew[i];
a[ex[i]].push_back(make_pair(ey[i], ew[i]));
a[ey[i]].push_back(make_pair(ex[i], ew[i]));
}
for (i = k + 1; i <= n; i++) d[i] = llinf;
for (i = 1; i <= k; i++) s.insert(make_pair(d[i], i));
while (!s.empty()) {
x = s.begin()->second;
s.erase(s.begin());
for (i = 0; i < (int)a[x].size(); i++) {
y = a[x][i].first, w = a[x][i].second;
if (d[y] > d[x] + w) {
if (d[y] != llinf) s.erase(s.find(make_pair(d[y], y)));
d[y] = d[x] + w;
s.insert(make_pair(d[y], y));
}
}
}
for (i = 1; i <= m; i++) {
vc.push_back(
make_pair(d[ex[i]] + d[ey[i]] + ew[i], make_pair(ex[i], ey[i])));
}
sort(vc.begin(), vc.end());
for (i = 1; i <= q; i++) {
cin >> x >> y;
qr[x].push_back(make_pair(y, i));
qr[y].push_back(make_pair(x, i));
}
for (i = 1; i <= n; i++) {
sz[i] = 1;
p[i] = i;
v[i].push_back(i);
mp[i][i] = 1;
}
for (i = 0; i < m; i++) {
x = vc[i].second.first, y = vc[i].second.second, w = vc[i].first;
if (fnd(x) == fnd(y)) continue;
uni(x, y, w);
}
for (i = 1; i <= q; i++) cout << rs[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
struct disjoint_set {
std::vector<int> p;
disjoint_set(int n) : p(n, -1) {}
int root(int u) { return p[u] < 0 ? u : p[u] = root(p[u]); }
bool merge(int u, int v) {
if ((u = root(u)) == (v = root(v))) return false;
if (p[u] > p[v]) std::swap(u, v);
p[u] += p[v];
p[v] = u;
return true;
}
void reset() { std::fill(p.begin(), p.end(), -1); }
};
class FCheapRobot {
public:
void solve(std::istream& in, std::ostream& out) {
int n, m, k, q;
in >> n >> m >> k >> q;
using ll = long long;
std::vector<std::vector<std::pair<int, int>>> g(n);
std::vector<std::tuple<int, int, ll>> edges;
for (int i = 0; i < m; ++i) {
int u, v, w;
in >> u >> v >> w;
--u, --v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
edges.emplace_back(u, v, w);
}
using node = std::pair<ll, int>;
std::priority_queue<node, std::vector<node>, std::greater<node>> pq;
std::vector<ll> dist(n, std::numeric_limits<ll>::max());
for (int i = 0; i < k; ++i) pq.emplace(dist[i] = 0, i);
while (!pq.empty()) {
int u;
ll d;
std::tie(d, u) = pq.top();
pq.pop();
if (dist[u] < d) continue;
for (auto e : g[u])
if (dist[e.first] > d + e.second)
pq.emplace(dist[e.first] = d + e.second, e.first);
}
for (auto& e : edges) {
int u, v;
ll w;
std::tie(u, v, w) = e;
w += dist[u] + dist[v];
e = std::make_tuple(u, v, w);
}
std::sort(edges.begin(), edges.end(),
[](const std::tuple<int, int, ll>& a,
const std::tuple<int, int, ll>& b) {
return std::get<2>(a) < std::get<2>(b);
});
std::vector<int> u(q), v(q), ord;
for (int i = 0; i < q; ++i) in >> u[i] >> v[i], --u[i], --v[i];
std::vector<int> lo(q), hi(q, m - 1), mid(q);
disjoint_set ds(n);
while (true) {
ord.clear();
for (int i = 0; i < q; ++i) {
if (lo[i] == hi[i]) continue;
mid[i] = (lo[i] + hi[i]) / 2;
ord.emplace_back(i);
}
if (ord.empty()) break;
std::sort(ord.begin(), ord.end(),
[&mid](int x, int y) { return mid[x] < mid[y]; });
ds.reset();
for (int i = 0, j = 0; i < (int)ord.size(); ++i) {
ll w = std::get<2>(edges[mid[ord[i]]]);
for (; j < m && std::get<2>(edges[j]) <= w; ++j)
ds.merge(std::get<0>(edges[j]), std::get<1>(edges[j]));
if (ds.root(u[ord[i]]) == ds.root(v[ord[i]]))
hi[ord[i]] = mid[ord[i]];
else
lo[ord[i]] = mid[ord[i]] + 1;
}
}
for (int i = 0; i < q; ++i) out << std::get<2>(edges[lo[i]]) << '\n';
}
};
int main() {
std::ios_base::sync_with_stdio(0);
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(0);
FCheapRobot solver;
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10, mod = 1e9 + 7;
vector<pair<int, int> > g[N];
long long dis[N];
int par[N], sz[N];
set<pair<long long, int> > s;
void dijekstra() {
while (s.size()) {
auto x = *s.begin();
s.erase(s.begin());
long long d = x.first;
int v = x.second;
for (auto xx : g[v]) {
int u = xx.first, w = xx.second;
if (dis[u] > d + w) {
par[u] = par[v];
s.erase({dis[u], u});
dis[u] = d + w;
s.insert({dis[u], u});
}
}
}
}
int pr(int x) {
if (par[x] == x) return x;
return par[x] = pr(par[x]);
}
long long l[N], r[N], mid[N];
int a[N], b[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) dis[i] = 1ll * mod * mod;
for (int i = 0; i < k; i++) {
s.insert({0, i});
dis[i] = 0;
par[i] = i;
}
dijekstra();
vector<pair<long long, pair<int, int> > > e;
for (int i = 0; i < n; i++)
for (auto x : g[i]) {
int v = x.first, w = x.second;
if (par[i] < par[v]) e.push_back({w + dis[i] + dis[v], {par[i], par[v]}});
}
sort(e.begin(), e.end());
for (int i = 0; i < q; i++) {
scanf("%d%d", &a[i], &b[i]);
a[i]--;
b[i]--;
l[i] = 0, r[i] = 1ll * n * mod;
}
bool go = true;
while (go) {
go = false;
vector<pair<long long, int> > vec;
for (int i = 0; i < q; i++) {
if (r[i] - l[i] > 1) {
mid[i] = (l[i] + r[i]) / 2;
vec.push_back({mid[i], i});
go = true;
}
}
sort(vec.begin(), vec.end());
for (int i = 0; i < k; i++) par[i] = i, sz[i] = 1;
int cur = 0;
for (auto x : vec) {
while (cur < e.size() && e[cur].first <= x.first) {
int u = e[cur].second.first, v = e[cur].second.second;
u = pr(u);
v = pr(v);
if (sz[u] > sz[v]) swap(u, v);
par[u] = v;
sz[v] += sz[u];
cur++;
}
int id = x.second;
if (pr(a[id]) == pr(b[id]))
r[id] = mid[id];
else
l[id] = mid[id];
}
}
for (int i = 0; i < q; i++) printf("%lld\n", r[i]);
return 0;
}
|
#include <bits/stdc++.h>
struct Edge {
Edge(int u, int v, long long w) : start(u), end(v), weight(w) {}
int start, end;
long long weight;
bool operator<(const Edge &other) const { return (other.weight < weight); }
};
const int MAXN = 2e5;
const int LOGN = 18;
std::vector<Edge> graph[MAXN];
std::priority_queue<Edge> dijkstra;
int closestSpecial[MAXN];
long long distToClosest[MAXN];
std::vector<Edge> paths;
int component[MAXN];
std::vector<Edge> specTree[MAXN];
int depth[MAXN];
int ancester[MAXN][LOGN];
long long weightToAnc[MAXN][LOGN];
void computeinfluence() {
while (!dijkstra.empty()) {
int special = dijkstra.top().start;
int node = dijkstra.top().end;
long long dist = dijkstra.top().weight;
dijkstra.pop();
if (closestSpecial[node] != -1) continue;
closestSpecial[node] = special;
distToClosest[node] = dist;
for (Edge &edge : graph[node])
dijkstra.emplace(special, edge.end, dist + edge.weight);
}
}
int find(int node) {
if (node != component[node]) component[node] = find(component[node]);
return component[node];
}
void merge(Edge &edge) {
if (find(edge.start) != find(edge.end)) {
component[find(edge.end)] = find(edge.start);
specTree[edge.start].emplace_back(edge.start, edge.end, edge.weight);
specTree[edge.end].emplace_back(edge.end, edge.start, edge.weight);
}
}
void root(int node) {
for (Edge &edge : specTree[node])
if (edge.end != ancester[node][0]) {
ancester[edge.end][0] = node;
weightToAnc[edge.end][0] = edge.weight;
depth[edge.end] = depth[node] + 1;
root(edge.end);
}
}
int getanc(int node, int exp) {
if (ancester[node][exp] == -1)
ancester[node][exp] = getanc(getanc(node, exp - 1), exp - 1);
return ancester[node][exp];
}
long long getweighttoanc(int node, int exp) {
if (weightToAnc[node][exp] == 0)
weightToAnc[node][exp] =
std::max(getweighttoanc(node, exp - 1),
getweighttoanc(getanc(node, exp - 1), exp - 1));
return weightToAnc[node][exp];
}
int lift(int node, int dist) {
if (dist == 0) return node;
int exp = 31 - __builtin_clz(dist);
return lift(getanc(node, exp), dist - (1 << exp));
}
long long liftw(int node, int dist) {
if (dist == 0) return 0;
int exp = 31 - __builtin_clz(dist);
return std::max(liftw(getanc(node, exp), dist - (1 << exp)),
getweighttoanc(node, exp));
}
int lca(int u, int v) {
if (depth[u] < depth[v]) std::swap(u, v);
u = lift(u, depth[u] - depth[v]);
if (u == v) return u;
for (int iExp = 31 - __builtin_clz(depth[u]); iExp > -1; iExp--)
if (getanc(u, iExp) != getanc(v, iExp)) {
u = getanc(u, iExp);
v = getanc(v, iExp);
}
return getanc(u, 0);
}
int main() {
std::ios::sync_with_stdio(false);
std::cout.tie(nullptr);
std::cin.tie(nullptr);
int nodes, edges, special, queries;
std::cin >> nodes >> edges >> special >> queries;
for (int iEdge = 0; iEdge < edges; iEdge++) {
int u, v, w;
std::cin >> u >> v >> w;
u--;
v--;
graph[u].emplace_back(u, v, w);
graph[v].emplace_back(v, u, w);
}
for (int iSpec = 0; iSpec < special; iSpec++)
dijkstra.emplace(iSpec, iSpec, 0);
for (int iNode = 0; iNode < nodes; iNode++) closestSpecial[iNode] = -1;
computeinfluence();
for (int iNode = 0; iNode < nodes; iNode++) {
component[iNode] = iNode;
for (Edge &edge : graph[iNode])
if (closestSpecial[iNode] != closestSpecial[edge.end])
paths.emplace_back(
closestSpecial[iNode], closestSpecial[edge.end],
distToClosest[iNode] + edge.weight + distToClosest[edge.end]);
}
std::sort(paths.rbegin(), paths.rend());
for (Edge &path : paths) merge(path);
std::fill_n((int *)ancester, special * LOGN, -1);
root(0);
for (int iQuery = 0; iQuery < queries; iQuery++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
int w = lca(u, v);
std::cout << std::max(liftw(u, depth[u] - depth[w]),
liftw(v, depth[v] - depth[w]))
<< ' ';
}
std::cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto i = begin(v); i != end(v); i++) is >> *i;
return is;
}
int n, m, k, q;
vector<pair<int, int>> edg[101000];
vector<long long> best_dists(101000, 10000000000000000LL);
set<int> markers[101000];
int dsu[101000];
int drank[101000];
vector<long long> ans(301000, 10000000000000000LL);
struct Edg {
int u, v;
long long w;
};
int dsu_find(int a) {
if (dsu[a] == a) return a;
return dsu[a] = dsu_find(dsu[a]);
}
void dsu_union(int a, int b, long long curr_ans) {
a = dsu_find(a);
b = dsu_find(b);
if (a == b) return;
if (drank[a] >= drank[b]) {
dsu[b] = a;
drank[a] += drank[b];
} else {
dsu[a] = b;
swap(a, b);
drank[a] += drank[b];
}
if (markers[a].size() < markers[b].size()) swap(markers[a], markers[b]);
for (int x : markers[b]) {
if (markers[a].find(x) != markers[a].end()) {
ans[x] = curr_ans;
} else {
markers[a].insert(x);
}
}
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin >> n >> m >> k >> q;
vector<Edg> edges;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
edg[u].push_back({v, w});
edg[v].push_back({u, w});
edges.push_back(Edg{u, v, w});
}
set<pair<long long, int>> ss;
for (int i = 0; i < k; i++) {
ss.insert({0, i});
best_dists[i] = 0;
}
while (ss.size() > 0) {
auto curr = *ss.begin();
ss.erase(curr);
for (auto x : edg[curr.second]) {
long long new_dist = curr.first + x.second;
if (new_dist < best_dists[x.first]) {
ss.erase({best_dists[x.first], x.first});
best_dists[x.first] = new_dist;
ss.insert({best_dists[x.first], x.first});
}
}
}
for (int i = 0; i < m; i++) {
edges[i].w += best_dists[edges[i].u] + best_dists[edges[i].v];
}
sort(edges.begin(), edges.end(), [&](Edg& x, Edg& y) { return x.w < y.w; });
vector<pair<int, int>> qs(q);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--, b--;
qs[i] = {a, b};
markers[a].insert(i);
markers[b].insert(i);
}
for (int i = 0; i < n; i++) {
dsu[i] = i;
drank[i] = 1;
}
for (int i = 0; i < m; i++) {
dsu_union(edges[i].u, edges[i].v, edges[i].w);
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool mmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
void yesno(bool c) { cout << (c ? "YES" : "NO") << '\n'; }
void yes() { yesno(true); }
void no() { yesno(false); }
void imp() { cout << "-1" << '\n'; }
const int inf = 0x3f3f3f3f;
const long long infl = 0x3f3f3f3f3f3f3f3f;
vector<int> va, vb;
vector<int> aval, bval, wval;
struct base_graph {
int n, ecnt = 0;
bool is_wei;
vector<int> from, to;
vector<long long> w;
base_graph(int n, bool is_wei = false) : n(n), is_wei(is_wei) {}
virtual int add(int a, int b, int ww = 0) = 0;
int base_add(int a, int b, int ww = 0) {
from.push_back(a);
to.push_back(b);
if (is_wei) w.push_back(ww);
return ecnt++;
}
void readin(int m, bool add_rev = false, int offset = 1) {
reserve(add_rev ? 2 * m : m);
for (int i = 0; i < m; i++) {
int a, b, ww = 0;
cin >> a >> b;
a -= offset;
b -= offset;
if (is_wei) cin >> ww;
add(a, b, ww);
if (add_rev) add(b, a, ww);
}
}
void readin_tree(bool add_rev, int offset = 1) {
int m = n - 1;
reserve(add_rev ? 2 * m : m);
for (int i = 2; i <= m; i++) {
int p;
cin >> p;
int a = i - offset;
add(a, p);
if (add_rev) add(p, a);
}
}
protected:
void reserve(int m) {
from.reserve(m);
to.reserve(m);
if (is_wei) w.reserve(m);
}
};
struct dir_graph : public base_graph {
bool has_rev;
vector<vector<pair<int, int>>> out, in;
dir_graph(int n, bool has_rev = false, bool is_wei = false)
: base_graph(n, is_wei), has_rev(has_rev), out(n), in(n) {}
int add(int a, int b, int ww = 0) {
int e = base_add(a, b, ww);
out[a].push_back({e, b});
in[b].push_back({e, a});
return e;
}
void readin(int m, int offset = 1) { base_graph::readin(m, has_rev, offset); }
void readin_tree(int offset = 1) { base_graph::readin_tree(has_rev, offset); }
};
struct undir_graph : public base_graph {
vector<vector<pair<int, int>>> edg;
undir_graph(int n, bool is_wei = false) : base_graph(n, is_wei), edg(n) {}
int add(int a, int b, int ww = 0) {
if (b > a) swap(a, b);
int e = base_add(a, b, ww);
edg[a].push_back({e, b});
edg[b].push_back({e, a});
return e;
}
void readin(int m, int offset = 1) { base_graph::readin(m, false, offset); }
void readin_tree(int offset = 1) { base_graph::readin_tree(false, offset); }
};
struct dijkstra_vec {
vector<long long> dist, par;
dir_graph& g;
dijkstra_vec(dir_graph& g) : dist(g.n, infl), par(g.n), g(g) {}
void solve(const vector<int>& s) {
using P = pair<long long, int>;
priority_queue<P, vector<P>, greater<P>> q;
auto upd = [&](int u, int p, long long d) {
if (mmin(dist[u], d)) {
par[u] = p;
q.push({d, u});
}
};
for (int ss : s) upd(ss, -1, 0);
while (!q.empty()) {
int u;
long long d;
tie(d, u) = q.top();
q.pop();
if (d > dist[u]) continue;
for (auto [e, v] : g.out[u]) {
long long newd = d + g.w[e];
upd(v, u, newd);
}
}
}
};
struct dsu {
int _n;
std::vector<int> parent_or_size;
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y) return x;
if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0) return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
};
int qval;
bool br = false;
struct query_dsu : dsu {
unordered_map<int, unordered_map<int, vector<int>>> betw;
undir_graph& g;
query_dsu(int n, undir_graph& g) : dsu(n), g(g) {
for (int e = 0; e < g.ecnt; e++) {
int u = g.from[e], v = g.to[e];
betw[u][v].push_back(e);
betw[v][u].push_back(e);
}
}
vector<int>& getbetw(int a, int b) {
int x = leader(a), y = leader(b);
return betw[x][y];
}
int merge(int a, int b) {
int x = leader(a), y = leader(b);
if (x == y) return -1;
if (br) {
cout << a << " " << b << " " << x << " " << y << '\n';
exit(0);
}
if (dsu::merge(a, b) != x) swap(x, y);
betw[x][y].clear();
betw[y][x].clear();
for (auto [e, v] : g.edg[y]) {
v = leader(v);
if (v == x) continue;
g.edg[x].push_back({e, v});
betw[x][v].push_back(e);
betw[v][x].push_back(e);
}
g.edg[y].clear();
return x;
}
};
void solve() {
int n, m, k, q;
cin >> n >> m >> k >> q;
qval = q;
dir_graph g(n, true, true);
g.readin(m);
dijkstra_vec dij(g);
vector<int> s;
for (int i = 0; i < (k); i++) s.push_back(i);
dij.solve(s);
for (int e = 0; e < (g.ecnt); e++) {
g.w[e] += dij.dist[g.from[e]] + dij.dist[g.to[e]];
}
undir_graph qg(n);
qg.readin(q);
query_dsu d(n, qg);
vector<pair<long long, long long>> ws;
for (int e = 0; e < (g.ecnt); e++) {
if (e % 2) ws.push_back(make_pair(g.w[e], e));
}
sort((ws).begin(), (ws).end());
vector<long long> ans(q);
int cnt = 0;
for (pair<long long, long long> we : ws) {
cnt++;
int u = g.from[we.second], v = g.to[we.second];
for (int qq : d.getbetw(u, v)) ans[qq] = we.first;
d.merge(u, v);
}
for (int qq = 0; qq < (q); qq++) {
cout << ans[qq] << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tc = 1;
while (tc--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 300100;
const long long inf = (1ll << 60);
int p[N];
int sz[N];
int k;
bool out[N];
vector<pair<int, int> > a[N];
int get(int a) {
if (a == p[a]) {
return a;
}
return p[a] = get(p[a]);
}
bool uni(int l, int r) {
l = get(l), r = get(r);
if (l == r) {
return false;
}
if (l >= k && r < k) {
swap(l, r);
} else {
if (sz[l] < sz[r]) {
swap(l, r);
}
}
p[r] = l;
sz[l] += sz[r];
return true;
}
pair<long long, int> d[N];
set<pair<long long, int> > s;
vector<pair<long long, int> > b[N];
int tw[20][N];
long long maxx[20][N];
int h[N];
void dfs(int v, pair<long long, int> pr, int h1) {
;
h[v] = h1;
maxx[0][v] = pr.first;
tw[0][v] = pr.second;
for (int i = int(0); i < int(((int)(b[v]).size())); ++i) {
int to = b[v][i].second;
if (to == pr.second) {
continue;
}
dfs(to, make_pair(b[v][i].first, v), h1 + 1);
}
}
int up(int v, int h) {
for (int i = int(0); i < int(20); ++i) {
if (h & (1 << i)) {
v = tw[i][v];
}
}
return v;
}
int get_lca(int u, int v) {
if (h[u] > h[v]) {
swap(u, v);
}
v = up(v, h[v] - h[u]);
if (u == v) {
return u;
}
for (int i = int(20) - 1; i >= int(0); --i) {
if (tw[i][v] != tw[i][u]) {
v = tw[i][v];
u = tw[i][u];
}
}
return tw[0][v];
}
long long get_max_up(int v, int h) {
long long result = 0ll;
for (int i = int(0); i < int(20); ++i) {
if (h & (1 << i)) {
umx(result, maxx[i][v]);
v = tw[i][v];
}
}
return result;
}
long long get_maxx(int u, int v) {
int lca = get_lca(u, v);
;
;
return max(get_max_up(u, h[u] - h[lca]), get_max_up(v, h[v] - h[lca]));
}
void precalc() {
for (int i = int(1); i < int(20); ++i) {
for (int j = int(0); j < int(k); ++j) {
int mid = tw[i - 1][j];
tw[i][j] = tw[i - 1][mid];
maxx[i][j] = max(maxx[i - 1][j], maxx[i - 1][mid]);
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
int n, m, q;
cin >> n >> m >> k >> q;
for (int i = int(0); i < int(m); ++i) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
a[u].push_back(make_pair(v, c));
a[v].push_back(make_pair(u, c));
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
sz[i] = 1;
if (i < k) {
d[i] = make_pair(0ll, i);
} else {
d[i] = make_pair(inf, inf);
}
s.insert(make_pair(d[i].first, i));
}
memset(out, 0, sizeof(out));
while (!s.empty()) {
pair<long long, int> k = *s.begin();
s.erase(k);
int v = k.second;
out[v] = true;
for (int i = int(0); i < int(((int)(a[v]).size())); ++i) {
int to = a[v][i].first;
long long cost = a[v][i].second;
if (d[to].first > d[v].first + cost) {
s.erase(make_pair(d[to].first, to));
d[to].first = d[v].first + cost;
d[to].second = d[v].second;
s.insert(make_pair(d[to].first, to));
}
}
}
vector<pair<long long, pair<int, int> > > e;
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(((int)(a[i]).size())); ++j) {
int to = a[i][j].first;
long long cost = a[i][j].second;
e.push_back(make_pair(d[i].first + d[to].first + cost,
make_pair(d[to].second, d[i].second)));
}
}
sort((e).begin(), (e).end());
for (int i = int(0); i < int(((int)(e).size())); ++i) {
int u = e[i].second.first, v = e[i].second.second;
if (uni(u, v)) {
;
b[u].push_back(make_pair(e[i].first, v));
b[v].push_back(make_pair(e[i].first, u));
}
}
dfs(0, make_pair(0ll, 0), 0);
precalc();
for (int i = int(0); i < int(q); ++i) {
int st, fn;
cin >> st >> fn;
--st, --fn;
cout << get_maxx(st, fn) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10, mod = 1e9 + 7;
long long inf = 0x3f3f3f3f3f3f3f3f;
int n, m, k, Q, fa[N], hd[N], ne, mxd[N];
long long d[N], val[N];
struct E {
int v, c, nxt;
} e[N << 1];
struct E2 {
int u, v;
long long c;
bool operator<(const E2& b) const { return c < b.c; }
} e2[N];
void link(int u, int v, int c) { e[ne] = {v, c, hd[u]}, hd[u] = ne++; }
struct D {
int u;
long long g;
bool operator<(const D& b) const { return g > b.g; }
};
void Dij() {
priority_queue<D> q;
memset(d, inf, sizeof d);
for (int i = 1; i <= k; ++i) q.push({i, d[i] = 0});
while (q.size()) {
int u = q.top().u;
long long g = q.top().g;
q.pop();
if (d[u] != g) continue;
for (int i = hd[u]; ~i; i = e[i].nxt) {
int v = e[i].v, c = e[i].c;
if (d[v] > d[u] + c) d[v] = d[u] + c, q.push({v, d[v]});
}
}
}
int fd(int x) { return fa[x] ? fd(fa[x]) : x; }
void mg(int x, int y, long long c) {
int fx = fd(x), fy = fd(y);
if (fx == fy) return;
if (mxd[fx] > mxd[fy]) swap(fx, fy);
fa[fx] = fy, val[fx] = c, mxd[fy] = max(mxd[fy], mxd[fx] + 1);
}
void Kruskal() {
sort(e2, e2 + m);
for (int i = 1; i <= n; ++i) mxd[i] = 1, fa[i] = 0;
for (int i = 0; i < m; ++i) {
int u = e2[i].u, v = e2[i].v;
long long c = e2[i].c;
mg(u, v, c);
}
}
long long qry(int u, int v) {
long long ret = 0;
for (; u != v; u = fa[u]) {
if (mxd[u] > mxd[v]) swap(u, v);
ret = max(ret, val[u]);
}
return ret;
}
int main() {
memset(hd, -1, sizeof hd), ne = 0;
scanf("%d%d%d%d", &n, &m, &k, &Q);
for (int i = 0; i < m; ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
link(u, v, c);
link(v, u, c);
e2[i] = {u, v, c};
}
Dij();
for (int i = 0; i < m; ++i) e2[i].c += d[e2[i].u] + d[e2[i].v];
Kruskal();
while (Q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%lld\n", qry(u, v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const long long B = 1e15;
long long dis[300009];
vector<pair<int, int> > adj[300009];
pair<pair<int, int>, int> arr[300009];
long long ans[300009];
int ata[300009];
set<int> s[300009];
int tap(int x) {
if (ata[x] == x) return x;
return ata[x] = tap(ata[x]);
}
void merge(int x, int y, long long w) {
if ((x = tap(x)) == (y = tap(y))) return;
if (s[x].size() < s[y].size()) swap(x, y);
for (__typeof((s[y]).begin()) it = (s[y]).begin(); it != (s[y]).end(); it++) {
if (s[x].count(*it))
ans[*it] = w;
else
s[x].insert(*it);
}
s[y].clear();
ata[y] = x;
}
int main() {
int n, m, k, qr;
scanf("%d%d%d%d", &n, &m, &k, &qr);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
arr[i] = make_pair(make_pair(u, v), w);
}
for (int i = 1; i <= qr; i++) {
int u, v;
scanf("%d%d", &u, &v);
s[u].insert(i);
s[v].insert(i);
}
queue<int> q;
for (int i = 1; i <= k; i++) q.push(i);
for (int i = k + 1; i <= n; i++) dis[i] = B;
while (!q.empty()) {
int nd = q.front();
q.pop();
for (__typeof((adj[nd]).begin()) it = (adj[nd]).begin();
it != (adj[nd]).end(); it++)
if (umin(dis[it->first], dis[nd] + it->second)) q.push(it->first);
}
vector<pair<long long, pair<int, int> > > edge;
for (int i = 1; i <= m; i++) {
int u = arr[i].first.first, v = arr[i].first.second, w = arr[i].second;
edge.push_back(make_pair(w + dis[u] + dis[v], make_pair(u, v)));
}
sort(edge.begin(), edge.end());
for (int i = 1; i <= n; i++) ata[i] = i;
for (__typeof((edge).begin()) it = (edge).begin(); it != (edge).end(); it++)
merge(it->second.first, it->second.second, it->first);
for (int i = 1; i <= qr; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto i = begin(v); i != end(v); i++) is >> *i;
return is;
}
int n, m, k, q;
vector<pair<int, int>> edg[101000];
vector<long long> best_dists(101000, 10000000000000000LL);
set<int> markers[101000];
int dsu[101000];
int drank[101000];
vector<long long> ans(301000, 10000000000000000LL);
struct Edg {
int u, v;
long long w;
};
int dsu_find(int a) {
if (dsu[a] == a) return a;
return dsu_find(dsu[a]);
}
void dsu_union(int a, int b, long long curr_ans) {
a = dsu_find(a);
b = dsu_find(b);
if (a == b) return;
if (drank[a] >= drank[b]) {
dsu[b] = a;
drank[a] += drank[b];
} else {
dsu[a] = b;
swap(a, b);
drank[a] += drank[b];
}
if (markers[a].size() < markers[b].size()) swap(markers[a], markers[b]);
for (int x : markers[b]) {
if (markers[a].find(x) != markers[a].end()) {
ans[x] = curr_ans;
} else {
markers[a].insert(x);
}
}
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin >> n >> m >> k >> q;
vector<Edg> edges;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
edg[u].push_back({v, w});
edg[v].push_back({u, w});
edges.push_back(Edg{u, v, w});
}
set<pair<long long, int>> ss;
for (int i = 0; i < k; i++) {
ss.insert({0, i});
best_dists[i] = 0;
}
while (ss.size() > 0) {
auto curr = *ss.begin();
ss.erase(curr);
for (auto x : edg[curr.second]) {
long long new_dist = curr.first + x.second;
if (new_dist < best_dists[x.first]) {
ss.erase({best_dists[x.first], x.first});
best_dists[x.first] = new_dist;
ss.insert({best_dists[x.first], x.first});
}
}
}
for (int i = 0; i < m; i++) {
edges[i].w += best_dists[edges[i].u] + best_dists[edges[i].v];
}
sort(edges.begin(), edges.end(), [&](Edg& x, Edg& y) { return x.w < y.w; });
vector<pair<int, int>> qs(q);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--, b--;
qs[i] = {a, b};
markers[a].insert(i);
markers[b].insert(i);
}
for (int i = 0; i < n; i++) {
dsu[i] = i;
drank[i] = 1;
}
for (int i = 0; i < m; i++) {
dsu_union(edges[i].u, edges[i].v, edges[i].w);
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, M = 10 * N;
const long long INF = 1e18;
long long n, m, k, q;
long long h[N], ht[N], e[M], ne[M], w[M], idx;
long long fa[N];
long long fat[N][25], depth[N], d[N][25];
long long dist[N];
bool st[N];
vector<pair<long long, pair<long long, long long>>> edge;
void add(long long h[], long long a, long long b, long long c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
long long find(long long x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void dijkstra() {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
heap;
for (long long i = 1; i <= n; i++) {
dist[i] = INF;
fa[i] = i;
}
for (long long i = 1; i <= k; i++) {
dist[i] = 0;
heap.push({0, i});
}
while (heap.size()) {
long long t = heap.top().second;
heap.pop();
if (st[t]) continue;
st[t] = true;
for (long long i = h[t]; ~i; i = ne[i]) {
long long p = e[i];
if (dist[p] > dist[t] + w[i]) {
dist[p] = dist[t] + w[i];
fa[p] = find(t);
heap.push({dist[p], p});
}
}
}
}
void build() {
for (long long i = 1; i <= n; i++) {
for (long long j = h[i]; ~j; j = ne[j]) {
long long p = e[j];
long long a = find(i);
long long b = find(p);
if (a == b) continue;
edge.push_back({dist[i] + dist[p] + w[j], {a, b}});
}
}
sort(edge.begin(), edge.end());
for (auto x : edge) {
long long a = x.second.first;
long long b = x.second.second;
if (find(a) == find(b)) continue;
add(ht, a, b, x.first);
add(ht, b, a, x.first);
fa[find(a)] = find(b);
}
}
void bfs(long long h[]) {
queue<long long> q;
q.push(1);
memset(depth, 0x3f, sizeof depth);
depth[0] = 0;
depth[1] = 1;
while (q.size()) {
auto t = q.front();
q.pop();
for (long long i = h[t]; ~i; i = ne[i]) {
long long p = e[i];
if (depth[p] > depth[t] + 1) {
depth[p] = depth[t] + 1;
q.push(p);
fat[p][0] = t;
d[p][0] = w[i];
for (long long j = 1; j <= 20; j++) {
fat[p][j] = fat[fat[p][j - 1]][j - 1];
d[p][j] = max(d[p][j - 1], d[fat[p][j - 1]][j - 1]);
}
}
}
}
}
long long lca(long long a, long long b) {
long long res = 0;
if (depth[a] < depth[b]) swap(a, b);
for (long long i = 20; i >= 0; i--)
if (depth[fat[a][i]] >= depth[b]) {
res = max(res, d[a][i]);
a = fat[a][i];
}
if (a == b) return res;
for (long long i = 20; i >= 0; i--)
if (fat[a][i] != fat[b][i]) {
res = max(res, d[a][i]);
res = max(res, d[b][i]);
a = fat[a][i];
b = fat[b][i];
}
res = max(res, d[a][0]);
res = max(res, d[b][0]);
return res;
}
signed main() {
ios ::sync_with_stdio(false);
cin.tie(0);
memset(h, -1, sizeof h);
memset(ht, -1, sizeof ht);
cin >> n >> m >> k >> q;
while (m--) {
long long a, b, c;
cin >> a >> b >> c;
add(h, a, b, c);
add(h, b, a, c);
}
dijkstra();
build();
bfs(ht);
while (q--) {
long long a, b;
cin >> a >> b;
cout << lca(a, b) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5;
int par[MX + 1], sz[MX + 1];
long long ans[3 * MX], dist[MX + 1];
vector<int> token[MX + 1];
vector<pair<int, long long>> adj[MX + 1];
pair<int, int> query[3 * MX];
tuple<long long, int, int> edge[3 * MX];
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
void unite(int a, int b, long long c) {
a = find(a);
b = find(b);
if (a != b) {
if (sz[a] > sz[b]) {
swap(a, b);
}
par[a] = b;
sz[b] += sz[a];
for (auto i : token[a]) {
if (query[i].first == query[i].second) continue;
if (query[i].first != a) {
swap(query[i].first, query[i].second);
}
query[i].first = b;
if (query[i].second == b) {
ans[i] = c;
} else {
token[b].push_back(i);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 0; i < m; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
edge[i] = make_tuple(w, u, v);
adj[u].emplace_back(v, w);
adj[v].emplace_back(u, w);
}
memset(dist, 0x3F3F3F3F, sizeof dist);
priority_queue<pair<long long, int>> dijkstra;
for (int i = 1; i <= k; ++i) {
dist[i] = 0;
dijkstra.emplace(0, i);
}
while (!dijkstra.empty()) {
int u;
long long d;
tie(d, u) = dijkstra.top();
dijkstra.pop();
if (-d > dist[u]) continue;
for (auto e : adj[u]) {
if (-d + e.second < dist[e.first]) {
dist[e.first] = -d + e.second;
dijkstra.emplace(-dist[e.first], e.first);
}
}
}
for (int i = 0; i < m; ++i) {
int u, v;
tie(ignore, u, v) = edge[i];
get<0>(edge[i]) += dist[u] + dist[v];
}
sort(edge, edge + m);
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
query[i] = {a, b};
token[a].push_back(i);
token[b].push_back(i);
}
iota(par + 1, par + 1 + n, 1);
fill(sz + 1, sz + 1 + n, 1);
for (int i = 0; i < m; ++i) {
int u, v;
long long w;
tie(w, u, v) = edge[i];
unite(u, v, w);
}
for (int i = 0; i < q; ++i) {
cout << ans[i] << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 1e5 + 10;
int n, m, k, q, cnt;
long long dis[2 * N];
struct edges {
int from, to, next;
long long wi;
bool operator<(const edges &node) const { return wi < node.wi; }
} edge[6 * N];
int head[6 * N];
vector<int> tr[N << 1];
long long tr_wi[N << 1];
int tr_num = 0;
void addedge(int u, int v, long long w) {
edge[cnt].from = u;
edge[cnt].wi = w;
edge[cnt].next = head[u];
edge[cnt].to = v;
head[u] = cnt++;
}
void dj() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
que;
for (int i = 1; i <= n; i++) {
if (i <= k) {
que.push(make_pair(0, i));
} else
dis[i] = 1e18;
}
while (!que.empty()) {
auto s = que.top();
que.pop();
long long fi = s.first;
int se = s.second;
if (dis[se] < fi) continue;
for (int i = head[se]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] > fi + edge[i].wi) {
dis[v] = fi + edge[i].wi;
que.push(make_pair(dis[edge[i].to], edge[i].to));
}
}
}
}
int pr[3 * N];
int height[3 * N];
set<int> s[3 * N];
long long ans[3 * N];
vector<pair<int, int> > ip[N];
void init() {
for (int i = 0; i <= n; i++) pr[i] = i, height[i] = 1, s[i].insert(i);
}
int find_pr(int u) { return pr[u] == u ? u : pr[u] = find_pr(pr[u]); }
bool same(int u, int v) { return find_pr(u) == find_pr(v); }
void insert(int u, int v, long long w) {
u = find_pr(u), v = find_pr(v);
if (u == v) return;
if (height[u] < height[v]) swap(u, v);
pr[v] = u;
height[u] += height[v];
for (auto k : s[v])
for (auto p : ip[k]) {
if (s[u].count(p.second)) ans[p.first] = w;
}
for (auto k : s[v]) s[u].insert(k);
}
int main() {
memset(head, -1, sizeof(head));
n = read(), m = read(), k = read(), q = read();
int u, v;
long long w;
for (int i = 1; i <= m; i++) {
u = read(), v = read(), w = read();
addedge(u, v, w);
addedge(v, u, w);
}
dj();
for (int i = 0; i < cnt; i++) {
edge[i].wi += dis[edge[i].from] + dis[edge[i].to];
}
sort(edge, edge + cnt);
int ip_cnt = 0;
init();
while (q--) {
u = read(), v = read();
ip[u].push_back(make_pair(ip_cnt, v));
ip[v].push_back(make_pair(ip_cnt, u));
ip_cnt++;
}
for (int i = 0; i < cnt; i++) {
u = edge[i].from;
v = edge[i].to;
insert(u, v, edge[i].wi);
}
for (int i = 0; i < ip_cnt; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265359;
const long long MOD = (long long)998244353ll;
const long long MAXN = (long long)3e5 + 10;
const long long INF = (long long)2242545357980376863;
const long double EPS = (long double)1e-8;
long long source[MAXN], d0[MAXN], dis[MAXN], done[MAXN], par[MAXN];
vector<long long> C[MAXN];
vector<pair<long long, long long> > G[MAXN];
vector<pair<long long, pair<long long, long long> > > E;
set<pair<long long, long long> > dj;
void change_key(long long node, long long last, long long now) {
dj.erase({last, node});
dis[node] = now;
dj.insert({now, node});
return;
}
long long A[MAXN], B[MAXN], ans[MAXN];
long long W;
long long get_par(long long u) {
if (par[u] == u) return u;
return par[u] = get_par(par[u]);
}
bool merge(long long u, long long v) {
long long U = u, V = v;
u = get_par(u);
v = get_par(v);
if (u == v) return false;
if (C[u].size() < C[v].size()) swap(u, v);
par[v] = u;
for (auto x : C[v]) {
C[u].push_back(x);
if (get_par(A[x]) == get_par(B[x])) ans[x] = min(ans[x], W);
}
C[v].clear();
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(ans, 31, sizeof ans);
for (int i = 0; i < MAXN; i++) par[i] = i;
memset(dis, 31, sizeof dis);
memset(d0, 31, sizeof d0);
long long n, m, k, q;
scanf("%lld%lld%lld%lld", &n, &m, &k, &q);
long long u, v, w;
for (int i = 0; i < m; i++) {
scanf("%lld%lld%lld", &u, &v, &w);
G[u].push_back({v, w});
G[v].push_back({u, w});
}
long long p, f;
for (int i = 1; i <= k; i++) {
p = i;
source[p] = p;
dj.insert({0, p});
dis[p] = 0;
}
long long fr, d, adj;
while (dj.size()) {
d = (*dj.begin()).first;
fr = (*dj.begin()).second;
dj.erase(dj.begin());
for (auto edge : G[fr]) {
adj = edge.first;
w = edge.second;
if (done[adj] == 1) {
E.push_back({dis[adj] + dis[fr] + w, {source[fr], source[adj]}});
}
if (dis[adj] > d + w) {
change_key(adj, dis[adj], d + w);
source[adj] = source[fr];
}
}
done[fr] = 1;
}
for (int i = 0; i < q; i++) {
scanf("%lld%lld", A + i, B + i);
C[A[i]].push_back(i);
C[B[i]].push_back(i);
}
sort(E.begin(), E.end());
for (auto edge : E) {
W = edge.first;
if (merge(edge.second.first, edge.second.second)) {
}
}
for (int i = 0; i < q; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K, Q;
vector<pair<int, int>> E[101010];
vector<pair<int, signed long long>> E2[101010];
int from[101010];
signed long long dist[101010];
int P[21][200005], D[200005];
signed long long ma[21][200005];
template <int um>
class UF {
public:
vector<int> par, rank;
UF() {
rank = vector<int>(um, 0);
for (int i = 0; i < um; i++) par.push_back(i);
}
int operator[](int x) {
return (par[x] == x) ? (x) : (par[x] = operator[](par[x]));
}
int operator()(int x, int y) {
if ((x = operator[](x)) == (y = operator[](y))) return x;
if (rank[x] > rank[y]) return par[x] = y;
rank[x] += rank[x] == rank[y];
return par[y] = x;
}
};
UF<500000> uf;
void dfs(int cur) {
for (auto& e : E2[cur])
if (e.first != P[0][cur]) {
D[e.first] = D[cur] + 1;
P[0][e.first] = cur;
ma[0][e.first] = e.second;
dfs(e.first);
}
}
int lca(int a, int b) {
int ret = 0, i, aa = a, bb = b;
if (D[aa] > D[bb]) swap(aa, bb);
for (i = 19; i >= 0; i--)
if (D[bb] - D[aa] >= 1 << i) bb = P[i][bb];
for (i = 19; i >= 0; i--)
if (P[i][aa] != P[i][bb]) aa = P[i][aa], bb = P[i][bb];
return (aa == bb) ? aa : P[0][aa];
}
void solve() {
int i, j, k, l, r, x, y;
string s;
scanf("%d%d%d%d", &N, &M, &K, &Q);
for (i = 0; i < (M); i++) {
scanf("%d%d%d", &x, &y, &r);
E[x - 1].push_back({y - 1, r});
E[y - 1].push_back({x - 1, r});
}
priority_queue<pair<signed long long, int>> PQ;
for (i = 0; i < (N); i++) {
if (i < K)
from[i] = i, PQ.push({0, i});
else
dist[i] = 1LL << 60;
}
while (PQ.size()) {
signed long long co = -PQ.top().first;
int cur = PQ.top().second;
PQ.pop();
if (dist[cur] != co) continue;
for (auto& e : E[cur])
if (dist[e.first] > co + e.second) {
dist[e.first] = co + e.second;
from[e.first] = from[cur];
PQ.push({-dist[e.first], e.first});
}
}
vector<vector<signed long long>> Es;
for (i = 0; i < (N); i++)
for (auto& e : E[i])
if (from[e.first] > from[i]) {
Es.push_back(
{dist[i] + dist[e.first] + e.second, from[i], from[e.first]});
}
sort((Es.begin()), (Es.end()));
for (auto& e : Es) {
if (uf[e[1]] != uf[e[2]]) {
uf(e[1], e[2]);
E2[e[1]].push_back({e[2], e[0]});
E2[e[2]].push_back({e[1], e[0]});
}
}
dfs(0);
for (i = 0; i < (19); i++)
for (x = 0; x < (K); x++) {
P[i + 1][x] = P[i][P[i][x]];
ma[i + 1][x] = max(ma[i][x], ma[i][P[i][x]]);
}
while (Q--) {
scanf("%d%d", &x, &y);
x--;
y--;
int lc = lca(x, y);
signed long long ret = 0;
for (i = 18; i >= 0; i--) {
if (D[x] - D[lc] >= 1 << i) ret = max(ret, ma[i][x]), x = P[i][x];
if (D[y] - D[lc] >= 1 << i) ret = max(ret, ma[i][y]), y = P[i][y];
}
cout << ret << endl;
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PLI = pair<LL, int>;
const LL INF = 1e18;
class DSU {
vector<int> par;
int find(int u) {
if (u == par[u]) return u;
return par[u] = find(par[u]);
}
public:
DSU(int n) : par(n) { iota(par.begin(), par.end(), 0); }
bool merge(int u, int v) {
u = find(u), v = find(v);
if (u == v) return false;
par[v] = u;
return true;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, q;
cin >> n >> m >> k >> q;
vector<vector<PLI>> adj(n);
vector<tuple<LL, int, int>> edges;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
edges.emplace_back(w, u, v);
adj[u].emplace_back(w, v);
adj[v].emplace_back(w, u);
}
vector<LL> dis(n, INF);
vector<bool> done(n, false);
vector<int> par(n, -1);
priority_queue<PLI> heap;
for (int u = 0; u < k; u++) {
dis[u] = 0;
par[u] = u;
heap.emplace(0, u);
}
while (!heap.empty()) {
int u = heap.top().second;
heap.pop();
if (done[u]) continue;
done[u] = true;
for (auto [w, v] : adj[u]) {
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
par[v] = par[u];
heap.emplace(-dis[v], v);
}
}
}
vector<tuple<LL, int, int>> sub_edges;
for (auto [w, u, v] : edges) {
if (par[u] != par[v]) {
sub_edges.emplace_back(dis[u] + dis[v] + w, par[u], par[v]);
}
}
sort(sub_edges.begin(), sub_edges.end());
vector<vector<PLI>> tree(k);
DSU dsu(k);
for (auto [w, u, v] : sub_edges) {
if (dsu.merge(u, v)) {
tree[u].emplace_back(w, v);
tree[v].emplace_back(w, u);
}
}
const int LOG = 20;
vector<vector<int>> anc(k, vector<int>(20, -1));
vector<vector<LL>> best(k, vector<LL>(20, 0));
vector<int> dep(k, 0);
function<void(int, int, LL)> dfs = [&](int u, int p, LL pw) {
dep[u] = dep[p] + 1;
anc[u][0] = p;
best[u][0] = pw;
for (int i = 1; i < LOG; i++) {
int v = anc[u][i - 1];
anc[u][i] = anc[v][i - 1];
best[u][i] = max(best[u][i - 1], best[v][i - 1]);
}
for (auto [w, v] : tree[u]) {
if (v != p) {
dfs(v, u, w);
}
}
};
dfs(0, 0, 0);
auto compute = [&](int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
int diff = dep[v] - dep[u];
LL res = 0;
for (int i = 0; i < LOG; i++) {
if (diff & (1 << i)) {
res = max(res, best[v][i]);
v = anc[v][i];
}
}
if (u == v) return res;
for (int i = LOG - 1; i >= 0; i--) {
int pu = anc[u][i], pv = anc[v][i];
if (pu != pv) {
res = max(res, best[u][i]);
res = max(res, best[v][i]);
u = pu, v = pv;
}
}
res = max(res, best[u][0]);
res = max(res, best[v][0]);
return res;
};
while (q--) {
int a, b;
cin >> a >> b;
cout << compute(a - 1, b - 1) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool mmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
void yesno(bool c) { cout << (c ? "YES" : "NO") << '\n'; }
void yes() { yesno(true); }
void no() { yesno(false); }
void imp() { cout << "-1" << '\n'; }
const int inf = 0x3f3f3f3f;
const long long infl = 0x3f3f3f3f3f3f3f3f;
vector<int> va, vb;
vector<int> aval, bval, wval;
struct base_graph {
int n, ecnt = 0;
bool is_wei;
vector<int> from, to;
vector<long long> w;
base_graph(int n, bool is_wei = false) : n(n), is_wei(is_wei) {}
virtual int add(int a, int b, int ww = 0) = 0;
int base_add(int a, int b, int ww = 0) {
from.push_back(a);
to.push_back(b);
if (is_wei) w.push_back(ww);
return ecnt++;
}
void readin(int m, bool add_rev = false, int offset = 1) {
reserve(add_rev ? 2 * m : m);
for (int i = 0; i < m; i++) {
int a, b, ww = 0;
cin >> a >> b;
a -= offset;
b -= offset;
if (is_wei) cin >> ww;
add(a, b, ww);
if (add_rev) add(b, a, ww);
}
}
void readin_tree(bool add_rev, int offset = 1) {
int m = n - 1;
reserve(add_rev ? 2 * m : m);
for (int i = 2; i <= m; i++) {
int p;
cin >> p;
int a = i - offset;
add(a, p);
if (add_rev) add(p, a);
}
}
protected:
void reserve(int m) {
from.reserve(m);
to.reserve(m);
if (is_wei) w.reserve(m);
}
};
struct dir_graph : public base_graph {
bool has_rev;
vector<vector<pair<int, int>>> out, in;
dir_graph(int n, bool has_rev = false, bool is_wei = false)
: base_graph(n, is_wei), has_rev(has_rev), out(n), in(n) {}
int add(int a, int b, int ww = 0) {
int e = base_add(a, b, ww);
out[a].push_back({e, b});
in[b].push_back({e, a});
return e;
}
void readin(int m, int offset = 1) { base_graph::readin(m, has_rev, offset); }
void readin_tree(int offset = 1) { base_graph::readin_tree(has_rev, offset); }
};
struct undir_graph : public base_graph {
vector<vector<pair<int, int>>> edg;
undir_graph(int n, bool is_wei = false) : base_graph(n, is_wei), edg(n) {}
int add(int a, int b, int ww = 0) {
if (b > a) swap(a, b);
int e = base_add(a, b, ww);
edg[a].push_back({e, b});
edg[b].push_back({e, a});
return e;
}
void readin(int m, int offset = 1) { base_graph::readin(m, false, offset); }
void readin_tree(int offset = 1) { base_graph::readin_tree(false, offset); }
};
struct dijkstra_vec {
vector<long long> dist, par;
dir_graph& g;
dijkstra_vec(dir_graph& g) : dist(g.n, infl), par(g.n), g(g) {}
void solve(const vector<int>& s) {
using P = pair<long long, int>;
priority_queue<P, vector<P>, greater<P>> q;
auto upd = [&](int u, int p, long long d) {
if (mmin(dist[u], d)) {
par[u] = p;
q.push({d, u});
}
};
for (int ss : s) upd(ss, -1, 0);
while (!q.empty()) {
int u;
long long d;
tie(d, u) = q.top();
q.pop();
if (d > dist[u]) continue;
for (auto [e, v] : g.out[u]) {
long long newd = d + g.w[e];
upd(v, u, newd);
}
}
}
};
struct dsu {
int _n;
std::vector<int> parent_or_size;
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y) return x;
if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0) return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
};
struct query_dsu : dsu {
unordered_map<int, unordered_map<int, vector<int>>> betw;
undir_graph& g;
query_dsu(int n, undir_graph& g) : dsu(n), g(g) {
for (int e = 0; e < g.ecnt; e++) {
int u = g.from[e], v = g.to[e];
betw[u][v].push_back(e);
betw[v][u].push_back(e);
}
}
vector<int>& getbetw(int a, int b) {
int x = leader(a), y = leader(b);
return betw[x][y];
}
int merge(int a, int b) {
int x = leader(a), y = leader(b);
if (x == y) return x;
if (dsu::merge(a, b) != x) swap(x, y);
betw[x][y].clear();
betw[y][x].clear();
for (auto [e, v] : g.edg[y]) {
v = leader(v);
if (v == x) continue;
g.edg[x].push_back({e, v});
betw[x][v].push_back(e);
betw[v][x].push_back(e);
}
g.edg[y].clear();
return x;
}
};
void solve() {
int n, m, k, q;
cin >> n >> m >> k >> q;
dir_graph g(n, true, true);
g.readin(m);
dijkstra_vec dij(g);
vector<int> s;
for (int i = 0; i < (k); i++) s.push_back(i);
dij.solve(s);
for (int e = 0; e < (g.ecnt); e++) {
g.w[e] += dij.dist[g.from[e]] + dij.dist[g.to[e]];
}
undir_graph qg(n);
qg.readin(q);
query_dsu d(n, qg);
vector<pair<long long, long long>> ws;
for (int e = 0; e < (g.ecnt); e++) {
if (e % 2) ws.push_back(make_pair(g.w[e], e));
}
sort((ws).begin(), (ws).end());
vector<long long> ans(q);
for (pair<long long, long long> we : ws) {
int u = g.from[we.second], v = g.to[we.second];
for (int qq : d.getbetw(u, v)) ans[qq] = we.first;
d.merge(u, v);
}
for (int qq = 0; qq < (q); qq++) {
cout << ans[qq] << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tc = 1;
while (tc--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(time(0));
const int maxn = 100010;
const int maxm = 300010;
const long long INF = 1e18;
struct E1 {
int to, next, w;
} edge[maxm << 1];
int head[maxn], tol;
inline void Addedge(int u, int v, int w) {
edge[tol].to = v;
edge[tol].w = w;
edge[tol].next = head[u];
head[u] = tol++;
}
long long dis[maxn];
bool vis[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
void dijkstra(int k, int n) {
fill(dis + k + 1, dis + n + 1, INF);
for (int i = 1; i <= k; ++i) Q.push(make_pair(dis[i] = 0, i));
while (!Q.empty()) {
int u = Q.top().second;
Q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (!vis[v] && dis[v] > dis[u] + edge[i].w) {
Q.push(make_pair(dis[v] = dis[u] + edge[i].w, v));
}
}
}
return;
}
struct E2 {
int u, v;
long long w;
bool operator<(const E2& P) const { return w < P.w; }
} E[maxm];
long long ans[maxm];
vector<pair<int, int> > vec[maxn];
int fa[maxn];
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void unite(int x, int y, long long w) {
int fx = find(x), fy = find(y);
if (fx == fy) return;
if (vec[fx].size() > vec[fy].size()) swap(fx, fy);
for (pair<int, int>& elem : vec[fx]) {
if (ans[elem.second]) continue;
if (find(elem.first) == fy)
ans[elem.second] = w;
else
vec[fy].push_back(elem);
}
fa[fx] = fy;
return;
}
int main() {
memset(head, -1, sizeof(head));
int n, m, k, q, u, v, w;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &u, &v, &w);
Addedge(u, v, w);
Addedge(v, u, w);
E[i] = E2{u, v, w};
}
dijkstra(k, n);
for (int i = 0; i < m; ++i) E[i].w += dis[E[i].u] + dis[E[i].v];
sort(E, E + m);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 0; i < q; ++i) {
scanf("%d%d", &u, &v);
vec[u].emplace_back(make_pair(v, i));
vec[v].emplace_back(make_pair(u, i));
}
for (int i = 0; i < m; ++i) unite(E[i].u, E[i].v, E[i].w);
for (int i = 0; i < q; ++i) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[600006], B[600006], D[600006], F[100001], G[100001], a[100001], b[600006],
c[600006], d[600006], e[100001], i, j, k, m, n, o[600006], q, s, t;
long long C[600006], E[100001], f[100001], p[600006];
bool g[100001];
inline bool cmp(int u, int v) { return C[u] < C[v]; }
inline int find(int u) {
while (F[u]) u = F[u];
return u;
}
inline void merge(int u, int v, long long w) {
if ((u = find(u)) == (v = find(v))) return;
if (G[u] < G[v]) swap(u, v);
G[F[v] = u] += G[v], E[v] = w;
}
inline long long query(int u, int v) {
long long w = 0;
while (u != v)
G[u] < G[v] ? w = max(w, E[u]), u = F[u] : (w = max(w, E[v]), v = F[v]);
return w;
}
inline void put(int v, long long w) {
int u = ++s;
while (1 < u && w < p[u >> 1]) o[u] = o[u >> 1], p[u] = p[u >> 1], u >>= 1;
o[u] = v, p[u] = w;
}
inline int get() {
int u = 1, v = 2, w = o[1];
for (o[1] = o[s], p[1] = p[s--]; v <= s;
swap(o[u], o[v]), swap(p[u], p[v]), u = v, v = u << 1) {
if (v < s && p[v | 1] < p[v]) v++;
if (p[u] <= p[v]) return w;
}
return w;
}
inline void del() {
while (s && g[o[1]]) get();
}
int u, v, w;
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (i = 1; i <= k; G[i++] = 1) put(e[i] = i, f[i] = 0ll);
for (; i <= n; G[i++] = 1) f[i] = 0x7fffffffffffffff;
for (i = 1; i <= m; i++)
scanf("%d%d%d", &u, &v, &w),
b[i << 1] = a[u], c[a[u] = i << 1] = v, b[i << 1 | 1] = a[v],
c[a[v] = i << 1 | 1] = u, d[i << 1] = d[i << 1 | 1] = w;
while (del(), s) {
for (i = a[u = get()], g[u] = 1; i; i = b[i])
if (f[u] + d[i] < f[c[i]])
e[c[i]] = e[u], put(c[i], f[c[i]] = f[u] + d[i]);
else if (g[c[i]] && e[u] != e[c[i]])
A[++t] = e[u], B[t] = e[c[i]], C[D[t] = t] = f[u] + f[c[i]] + d[i];
}
for (sort(D + 1, D + t + 1, cmp), i = 1; i <= t; i++)
merge(A[D[i]], B[D[i]], C[D[i]]);
for (i = 1; i <= q; i++) scanf("%d%d", &u, &v), printf("%lld\n", query(u, v));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const long long oo = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000000007;
struct disjoint_set {
vector<int> ds;
disjoint_set(int n) { ds = vector<int>(n, -1); }
int root(int a) { return ds[a] < 0 ? a : ds[a] = root(ds[a]); }
bool join(int a, int b) {
a = root(a), b = root(b);
if (a == b) return false;
if (a > b) swap(a, b);
ds[a] = b;
return true;
}
};
void myassert(bool target) {
while (!target)
;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k, q;
cin >> n >> m >> k >> q;
vector<vector<pair<int, long long>>> adj(n);
for (int i = 0; i < m; ++i) {
int u, v;
long long c;
cin >> u >> v >> c;
--u;
--v;
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
vector<pair<long long, int>> dist(n, {oo, -1});
priority_queue<pair<long long, int>> pq;
for (int i = 0; i < k; ++i) {
dist[i] = {0, i};
pq.push({0, i});
}
while (!pq.empty()) {
auto cur = pq.top();
pq.pop();
long long d = -cur.first;
int u = cur.second;
if (dist[u].first < d) continue;
for (auto e : adj[u]) {
long long c = e.second;
int v = e.first;
if (dist[v].first > d + c) {
dist[v] = {d + c, dist[u].second};
pq.push({-dist[v].first, v});
}
}
}
vector<pair<long long, pair<int, int>>> edges;
for (int i = 0; i < n; ++i) {
for (auto e : adj[i]) {
int u = dist[i].second;
int v = dist[e.first].second;
if (u <= v) continue;
edges.push_back({dist[i].first + dist[e.first].first + e.second, {u, v}});
auto x = edges.back();
}
}
sort(edges.begin(), edges.end());
disjoint_set ds(k);
vector<vector<pair<int, long long>>> tree(k);
for (auto e : edges) {
if (ds.join(e.second.first, e.second.second)) {
tree[e.second.first].push_back({e.second.second, e.first});
tree[e.second.second].push_back({e.second.first, e.first});
}
}
vector<int> h(k);
vector<vector<pair<int, long long>>> parent(k);
function<void(int, int, long long)> dfs = [&](int s, int p, long long cost) {
if (p != -1) {
parent[s].push_back({p, cost});
int i = 0;
while (true) {
int p = parent[s][i].first;
if (parent[p].size() > i) {
auto x = parent[p][i];
auto c = parent[s][i].second;
parent[s].push_back({x.first, max(x.second, c)});
} else {
break;
}
++i;
}
}
for (auto e : tree[s]) {
if (e.first == p) continue;
h[e.first] = h[s] + 1;
dfs(e.first, s, e.second);
}
};
dfs(0, -1, 0);
auto lca = [&](int a, int b) {
if (h[a] > h[b]) swap(a, b);
long long answer = 0;
for (int i = 0; h[b] > h[a]; ++i) {
if ((h[b] - h[a]) >> i & 1) {
answer = max(answer, parent[b][i].second);
b = parent[b][i].first;
}
}
if (a == b) return answer;
int it = parent[a].size() - 1;
for (int i = it; i >= 0; --i) {
if (parent[a].size() <= i) continue;
if (parent[b].size() <= i) continue;
int pa = parent[a][i].first;
int pb = parent[b][i].first;
if (pa != pb) {
answer = max(answer, parent[a][i].second);
answer = max(answer, parent[b][i].second);
a = pa;
b = pb;
}
}
answer = max(answer, parent[a][0].second);
answer = max(answer, parent[b][0].second);
return answer;
};
while (q-- > 0) {
int u, v;
cin >> u >> v;
u--;
v--;
cout << lca(u, v) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[100010];
vector<int> e[100010], ec[100010];
int u[300010], v[300010], w[300010], qu[300010], qv[300010], qk[300010],
be[100010];
long long ans[300010];
int par[100010];
int find(int x) { return par[x] == x ? x : (par[x] = find(par[x])); }
const int C = 340;
vector<int> qd[C];
int main() {
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
--u[i];
--v[i];
e[u[i]].push_back(v[i]);
ec[u[i]].push_back(w[i]);
e[v[i]].push_back(u[i]);
ec[v[i]].push_back(w[i]);
}
for (int i = 0; i < q; i++) {
scanf("%d%d", &qu[i], &qv[i]);
--qu[i], --qv[i];
}
for (int i = 0; i < n; i++) {
d[i] = 1ll << 60;
}
priority_queue<pair<long long, int> > qq;
for (int i = 0; i < k; i++) {
d[i] = 0;
be[i] = i;
par[i] = i;
qq.push(make_pair(0, i));
}
vector<pair<long long, pair<int, int> > > fvv;
while (qq.size()) {
long long co = -qq.top().first;
int tv = qq.top().second;
qq.pop();
if (d[tv] != co) continue;
for (int i = 0; i < e[tv].size(); i++) {
int to = e[tv][i];
if (d[to] > co + ec[tv][i]) {
d[to] = co + ec[tv][i];
be[to] = be[tv];
qq.push(make_pair(-co - ec[tv][i], to));
}
}
}
for (int i = 0; i < m; i++) {
if (be[u[i]] != be[v[i]]) {
fvv.push_back(pair<long long, pair<int, int> >(
d[u[i]] + d[v[i]] + w[i], make_pair(be[u[i]], be[v[i]])));
}
}
sort(fvv.begin(), fvv.end());
vector<long long> f;
vector<vector<pair<int, int> > > fv;
for (int i = 0; i < fvv.size(); i++) {
if (!f.size() || f.back() != fvv[i].first) {
if (fv.size() && !fv.back().size()) {
f.pop_back();
fv.pop_back();
}
f.push_back(fvv[i].first);
fv.push_back(vector<pair<int, int> >());
}
int su = find(fvv[i].second.first), sv = find(fvv[i].second.second);
if (su == sv) continue;
fv.back().push_back(fvv[i].second);
par[su] = sv;
}
for (int i = 0; i < k; i++) {
par[i] = i;
}
int la = 0;
for (int i = 0; i <= f.size(); i++) {
if (i && i % C == 0) {
for (int j = 0; j < q; j++) {
if (qk[j]) continue;
if (find(qu[j]) == find(qv[j])) {
qd[i / C - 1].push_back(j);
qk[j] = 1;
}
}
la = i / C;
}
if (i == f.size()) continue;
for (int j = 0; j < fv[i].size(); j++) {
int tu = fv[i][j].first, tv = fv[i][j].second;
tu = find(tu);
tv = find(tv);
par[tu] = tv;
}
}
for (int i = 0; i < q; i++) {
if (!qk[i]) qd[la].push_back(i);
}
for (int i = 0; i < k; i++) {
par[i] = i;
}
for (int i = 0; i < f.size(); i++) {
for (int j = 0; j < fv[i].size(); j++) {
int tu = fv[i][j].first, tv = fv[i][j].second;
tu = find(tu);
tv = find(tv);
par[tu] = tv;
}
for (int j = 0; j < qd[i / C].size(); j++) {
int z = qd[i / C][j];
if (ans[z]) continue;
if (find(qu[z]) == find(qv[z])) {
ans[z] = f[i];
}
}
}
for (int i = 0; i < q; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
char ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
struct edge {
int to, nxt, from;
long long dis;
} g[1010101];
int head[1010101], tot, n, m, K, Q;
inline void made(int from, int to, long long dis) {
g[++tot].to = to;
g[tot].nxt = head[from];
head[from] = tot;
g[tot].dis = dis;
g[tot].from = from;
}
int F[1010101], sz[1010101];
long long dis[1010101];
int find(int u) {
if (F[u] != u) F[u] = find(F[u]);
return F[u];
}
struct que {
int x, y;
int id;
} q[1010101];
long long ans[1010101];
vector<que> G[1010101];
inline bool cmp(edge a, edge b) { return a.dis < b.dis; }
long long NOW;
bool vis[1010101];
int main() {
n = read(), m = read(), K = read(), Q = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
long long z = read();
made(x, y, z);
made(y, x, z);
}
for (int i = 1; i <= n; i++) {
F[i] = i;
sz[i] = 1;
}
priority_queue<pair<long long, int> > dl;
memset(dis, 0x3f, sizeof dis);
while (!dl.empty()) dl.pop();
for (int i = 1; i <= K; i++) dis[i] = 0, dl.push(make_pair(0, i));
while (!dl.empty()) {
int u = dl.top().second;
dl.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i; i = g[i].nxt) {
int v = g[i].to;
if (dis[v] > dis[u] + g[i].dis) {
dis[v] = dis[u] + g[i].dis;
if (!vis[v]) {
dl.push(make_pair(-dis[v], v));
}
}
}
}
for (int i = 1; i <= tot; i++) {
g[i].dis = g[i].dis + dis[g[i].from] + dis[g[i].to];
}
sort(g + 1, g + 1 + tot, cmp);
for (int i = 1; i <= Q; i++) {
q[i].id = i;
q[i].x = read(), q[i].y = read();
G[q[i].x].push_back(q[i]);
G[q[i].y].push_back(q[i]);
}
for (int i = 1; i <= tot; i++) {
int u = g[i].from, v = g[i].to;
NOW = g[i].dis;
int fu = find(u), fv = find(v);
if (fu != fv) {
if (sz[fu] < sz[fv]) {
swap(fu, fv);
swap(u, v);
}
sz[fu] += sz[fv];
F[fv] = fu;
for (auto now : G[fv]) {
if (find(now.x) == find(now.y)) {
if (!ans[now.id]) {
ans[now.id] = NOW;
}
} else {
G[fu].push_back(now);
}
}
}
}
for (int i = 1; i <= Q; i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 6e5 + 5;
long long n, m, k, T, w, x, y, t, tot, head[MAXN], ver[MAXN], edge[MAXN],
Next[MAXN];
long long f[MAXN][21], maxx[MAXN][21];
pair<long long, long long> dis[MAXN];
long long d[MAXN];
bool v[MAXN];
void addedge(long long x, long long y, long long z) {
ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
}
struct node {
long long x, y, z;
} a[MAXN], b[MAXN];
priority_queue<pair<long long, long long> > q;
vector<pair<long long, long long> > g[MAXN];
void dij() {
memset(v, 0, sizeof(v));
for (long long i = 1; i <= n; i++) {
if (i <= k)
dis[i].first = 0, dis[i].second = i, q.push(make_pair(0, i));
else
dis[i].first = 1ll << 62, dis[i].second = 0;
}
while (q.size()) {
long long x = q.top().second;
q.pop();
if (v[x]) continue;
v[x] = 1;
for (long long i = head[x]; i; i = Next[i]) {
long long y = ver[i], z = edge[i];
if (dis[y].first > dis[x].first + z) {
dis[y].first = dis[x].first + z;
dis[y].second = dis[x].second;
q.push(make_pair(-dis[y].first, y));
}
}
}
}
bool cmp(node a, node b) { return a.z < b.z; }
long long pre[MAXN];
long long Find(long long x) { return x == pre[x] ? x : pre[x] = Find(pre[x]); }
long long lca(long long x, long long y) {
if (d[x] > d[y]) swap(x, y);
long long ans = 0;
for (long long i = t; i >= 0; i--) {
if (d[f[y][i]] >= d[x]) ans = max(ans, maxx[y][i]), y = f[y][i];
}
if (x == y) return ans;
for (long long i = t; i >= 0; i--) {
if (f[x][i] != f[y][i])
ans = max(ans, max(maxx[x][i], maxx[y][i])), x = f[x][i], y = f[y][i];
}
ans = max(ans, maxx[x][0]);
ans = max(ans, maxx[y][0]);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
while (cin >> n >> m >> k >> T) {
t = (long long)(log(n) / log(2)) + 1;
for (long long i = 1; i <= k; i++) g[i].clear(), pre[i] = i;
memset(head, 0, sizeof(head));
tot = 0;
long long pos = 0;
for (long long i = 1; i <= m; i++) {
cin >> x >> y >> w;
addedge(x, y, w);
addedge(y, x, w);
a[++pos].x = x, a[pos].y = y, a[pos].z = w;
a[++pos].x = y, a[pos].y = x, a[pos].z = w;
}
dij();
pos = 0;
for (long long i = 1; i <= 2 * m; i++) {
if (dis[a[i].x].second != dis[a[i].y].second) {
b[++pos].x = dis[a[i].x].second;
b[pos].y = dis[a[i].y].second;
b[pos].z = a[i].z + dis[a[i].x].first + dis[a[i].y].first;
}
}
sort(b + 1, b + pos + 1, cmp);
for (long long i = 1; i <= pos; i++) {
long long xx = Find(b[i].x);
long long yy = Find(b[i].y);
if (xx == yy) continue;
pre[xx] = yy;
g[b[i].x].push_back(make_pair(b[i].y, b[i].z));
g[b[i].y].push_back(make_pair(b[i].x, b[i].z));
}
queue<long long> Q;
memset(d, 0, sizeof(d));
Q.push(1);
d[1] = 1;
while (Q.size()) {
long long x = Q.front();
Q.pop();
long long len = g[x].size();
for (long long i = 0; i <= len - 1; i++) {
long long y = g[x][i].first;
if (d[y]) continue;
d[y] = d[x] + 1;
f[y][0] = x;
maxx[y][0] = g[x][i].second;
for (long long j = 1; j <= t; j++) {
f[y][j] = f[f[y][j - 1]][j - 1];
maxx[y][j] = max(maxx[y][j - 1], maxx[f[y][j - 1]][j - 1]);
}
Q.push(y);
}
}
while (T--) {
cin >> x >> y;
cout << lca(x, y) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dijk();
void build();
void dfs(int u);
long long getv(int u, int v);
bool add(int u, int v, long long w);
int n, m, k, dpth[100002], r[100002];
pair<int, long long> pr[17][100002];
long long d[100002];
vector<pair<int, long long> > ad[100002];
pair<long long, pair<int, int> > edge[100002 * 6];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, q;
cin >> n >> m >> k >> q;
for (i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
ad[u].push_back({v, w});
ad[v].push_back({u, w});
}
dijk();
build();
dfs(1);
for (i = 1; i <= q; ++i) {
int u, v;
cin >> u >> v;
cout << getv(u, v) << '\n';
}
return 0;
}
long long getv(int u, int v) {
if (dpth[u] < dpth[v]) swap(u, v);
int cv = dpth[u] - dpth[v], i;
long long rev = 0;
for (i = 0; i < 17; ++i)
if ((cv >> i) & 1) {
rev = max(rev, pr[i][u].second);
u = pr[i][u].first;
}
for (i = 16; i >= 0; --i)
if (pr[i][u].first != pr[i][v].first) {
rev = max(rev, max(pr[i][u].second, pr[i][v].second));
u = pr[i][u].first;
v = pr[i][v].first;
}
if (u == v) return rev;
return max(rev, max(pr[0][u].second, pr[0][v].second));
}
void dfs(int u) {
int i;
for (auto v : ad[u]) {
if (v.first == pr[0][u].first) continue;
pr[0][v.first] = {u, v.second};
dpth[v.first] = dpth[u] + 1;
for (i = 1; i < 17; ++i) {
pr[i][v.first].first = pr[i - 1][pr[i - 1][v.first].first].first;
pr[i][v.first].second = max(pr[i - 1][v.first].second,
pr[i - 1][pr[i - 1][v.first].first].second);
}
dfs(v.first);
}
}
int getr(int x) { return r[x] ? r[x] = getr(r[x]) : x; }
bool add(int u, int v, long long w) {
int ru = getr(u), rv = getr(v);
if (ru == rv) return 0;
r[ru] = rv;
ad[u].push_back({v, w});
ad[v].push_back({u, w});
return 1;
}
void build() {
int i;
m = 0;
for (i = 1; i <= n; ++i) {
for (auto j : ad[i])
edge[++m] = {d[i] + d[j.first] + j.second, {i, j.first}};
ad[i].clear();
}
sort(edge + 1, edge + m + 1);
for (i = 1; i <= m; ++i)
add(edge[i].second.first, edge[i].second.second, edge[i].first);
}
void dijk() {
int i, u;
long long cv;
priority_queue<pair<long long, int> > pq;
for (i = 1; i <= k; ++i) {
pq.push({0, i});
d[i] = 0;
}
for (; i <= n; ++i) d[i] = 1e18;
while (pq.size()) {
u = pq.top().second;
cv = -pq.top().first;
pq.pop();
if (cv > d[u]) continue;
for (auto v : ad[u])
if (d[v.first] > cv + v.second) {
d[v.first] = cv + v.second;
pq.push({-d[v.first], v.first});
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, Q, d[100005], tr[100005], oo, f[100005][20], gt[100005][20],
h[100005], u, v, w, ru, rv, lab[100005];
bool kt[100005];
pair<long long, pair<int, int> > ed[300005];
vector<pair<long long, int> > a[100005], ke[100005];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
void ditcha() {
for (int i = 1; i <= n; ++i)
if (i <= k) {
q.push({0, i});
tr[i] = i;
} else
d[i] = oo;
memset(kt, 0, sizeof(kt));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (kt[u]) continue;
kt[u] = true;
for (int i = 0; i < a[u].size(); ++i) {
int v = a[u][i].second;
long long w = a[u][i].first;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
tr[v] = tr[u];
q.push({d[v], v});
}
}
}
}
void dfs(int u, int pa, long long w) {
h[u] = h[pa] + 1;
f[u][0] = pa;
gt[u][0] = w;
for (int i = 0; i < ke[u].size(); ++i) {
int v = ke[u][i].second;
long long w = ke[u][i].first;
if (v == pa) continue;
dfs(v, u, w);
}
}
void khoitao() {
for (int K = 1; (1 << K) <= k; ++K)
for (int i = 1; i <= k; ++i)
if (f[i][K - 1] != -1) {
f[i][K] = f[f[i][K - 1]][K - 1];
gt[i][K] = max(gt[i][K - 1], gt[f[i][K - 1]][K - 1]);
}
}
long long lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
int log = trunc(log2(h[u])) + 1;
long long kq = 0;
for (int i = log; i >= 0; --i)
if (f[u][i] != -1 && h[f[u][i]] >= h[v]) {
kq = max(kq, gt[u][i]);
u = f[u][i];
}
if (u == v) return kq;
for (int i = log; i >= 0; --i)
if (f[u][i] != f[v][i]) {
kq = max(kq, max(gt[u][i], gt[v][i]));
u = f[u][i];
v = f[v][i];
}
return max(kq, max(gt[u][0], gt[v][0]));
}
int phin(int u) { return lab[u] < 0 ? u : lab[u] = phin(lab[u]); }
void uni(int u, int v) {
if (lab[u] > lab[v]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> Q;
oo = 1e18;
for (int i = 1; i <= m; ++i) {
cin >> u >> v >> w;
a[u].push_back({w, v});
a[v].push_back({w, u});
ed[i] = {w, {u, v}};
}
ditcha();
for (int i = 1; i <= m; ++i) {
u = ed[i].second.first;
v = ed[i].second.second;
w = ed[i].first;
ed[i] = {d[u] + d[v] + w, {tr[u], tr[v]}};
}
sort(ed + 1, ed + m + 1);
memset(lab, -1, sizeof(lab));
for (int i = 1; i <= m; ++i) {
u = ed[i].second.first;
v = ed[i].second.second;
w = ed[i].first;
ru = phin(u);
rv = phin(v);
if (ru != rv) {
uni(ru, rv);
ke[u].push_back({w, v});
ke[v].push_back({w, u});
}
}
memset(f, -1, sizeof(f));
dfs(1, 1, 0);
f[1][0] = -1;
khoitao();
for (int i = 1; i <= Q; ++i) {
cin >> u >> v;
cout << lca(u, v) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v[300010], w[300010];
long long tt[300010], lg[300010], lvl[300010];
priority_queue<pair<long long, long long> > h;
long long dist[300010];
pair<long long, long long> fth[20][300010];
pair<long long, pair<long long, long long> > mch[300010];
long long n;
long long rad(long long x) {
while (tt[x] > 0) x = tt[x];
return x;
}
void dfs(long long nod, long long tata, long long cost) {
long long i;
fth[0][nod] = make_pair(tata, cost);
for (i = 0; i < w[nod].size(); i++) {
if (w[nod][i].first != tata) {
lvl[w[nod][i].first] = 1 + lvl[nod];
dfs(w[nod][i].first, nod, w[nod][i].second);
}
}
}
long long path(long long x, long long y) {
long long dif, p2;
long long sol;
sol = 0;
if (lvl[x] < lvl[y]) swap(x, y);
dif = lvl[x] - lvl[y];
while (dif && x != 0) {
sol = max(sol, fth[lg[dif]][x].second);
x = fth[lg[dif]][x].first;
dif = dif - (1 << lg[dif]);
}
if (x == y) {
return sol;
}
for (p2 = lg[n]; p2 >= 0; p2--) {
if (fth[p2][x].first != fth[p2][y].first) {
sol = max(sol, max(fth[p2][x].second, fth[p2][y].second));
x = fth[p2][x].first;
y = fth[p2][y].first;
}
}
p2 = 0;
sol = max(sol, max(fth[p2][x].second, fth[p2][y].second));
return sol;
}
int main() {
FILE *fin = stdin;
FILE *fout = stdout;
long long m, k, q, x, y, i, nod, vecin, rx, ry, elem, j;
long long z, cost, c;
fscanf(fin, "%lld%lld%lld%lld", &n, &m, &k, &q);
for (i = 1; i <= m; i++) {
fscanf(fin, "%lld%lld%lld", &x, &y, &z);
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
}
for (i = 2; i <= n; i++) {
lg[i] = lg[i / 2] + 1;
}
for (i = 1; i <= n; i++) {
dist[i] = 2000000000000000000;
tt[i] = -1;
}
for (i = 1; i <= k; i++) {
h.push(make_pair(0, i));
dist[i] = 0;
}
while (!h.empty()) {
cost = -h.top().first;
nod = h.top().second;
h.pop();
if (dist[nod] != cost) {
continue;
}
for (i = 0; i < v[nod].size(); i++) {
vecin = v[nod][i].first;
c = v[nod][i].second;
if (dist[vecin] > dist[nod] + c) {
dist[vecin] = dist[nod] + c;
h.push(make_pair(-dist[vecin], vecin));
}
}
}
elem = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j < v[i].size(); j++) {
v[i][j].second += dist[i] + dist[v[i][j].first];
if (v[i][j].first > i) {
elem++;
mch[elem].first = v[i][j].second;
mch[elem].second.first = i;
mch[elem].second.second = v[i][j].first;
}
}
}
sort(mch + 1, mch + elem + 1);
for (i = 1; i <= elem; i++) {
x = mch[i].second.first;
y = mch[i].second.second;
rx = rad(x);
ry = rad(y);
if (rx != ry) {
w[x].push_back(make_pair(y, mch[i].first));
w[y].push_back(make_pair(x, mch[i].first));
if (tt[rx] < tt[ry]) {
tt[rx] += tt[ry];
tt[ry] = rx;
} else {
tt[ry] += tt[rx];
tt[rx] = ry;
}
}
}
dfs(1, 0, 0);
k = 1;
while ((1 << k) <= n) {
for (i = 1; i <= n; i++) {
fth[k][i].first = fth[k - 1][fth[k - 1][i].first].first;
fth[k][i].second =
max(fth[k - 1][i].second, fth[k - 1][fth[k - 1][i].first].second);
}
k++;
}
for (; q; q--) {
fscanf(fin, "%lld%lld", &x, &y);
fprintf(fout, "%lld\n", path(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 100007, __ = 300007, _n = _ << 1, lglg = 19;
vector<pair<int, int>> e[_];
inline void adde(int a, int b, int c) { e[a].emplace_back(b, c); }
inline void addde(int a, int b, int c) { adde(a, b, c), adde(b, a, c); }
int n, m, chx, qn;
long long dis[_], via[_];
int ed[_];
struct cxk {
int a, b;
long long v;
cxk(int a_ = 0, int b_ = 0, long long v_ = 0) { a = a_, b = b_, v = v_; }
friend int operator<(cxk a, cxk b) { return a.v < b.v; }
} es[__];
int ecnts = 0;
void dijks() {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
memset(dis, 63, sizeof(dis)), memset(ed, 0, sizeof(ed));
for (int i = 1; i <= chx; i++) dis[i] = 0, via[i] = i, q.emplace(dis[i], i);
while (!q.empty()) {
int a = q.top().second;
q.pop();
if (ed[a]) continue;
ed[a] = 1;
for (auto [b, c] : e[a]) {
if (dis[b] <= dis[a] + c) continue;
dis[b] = dis[a] + c, via[b] = via[a];
if (!ed[b]) q.emplace(dis[b], b);
}
}
for (int i = 1; i <= n; i++)
for (auto [b, c] : e[i])
if (b > i && via[i] != via[b])
es[++ecnts] = cxk(via[i], via[b], dis[i] + dis[b] + c);
}
int bfa[_n] = {0};
int findbfa(int x) { return bfa[x] == x ? x : bfa[x] = findbfa(bfa[x]); }
int pfa[_n][lglg + 1] = {0}, pdep[_n] = {0}, pcnt = 0;
long long pva[_n] = {0};
int lca(int a, int b) {
if (pdep[a] < pdep[b]) swap(a, b);
for (int i = lglg; i >= 0; i--)
if (pdep[pfa[a][i]] >= pdep[b]) a = pfa[a][i];
if (a == b) return a;
for (int i = lglg; i >= 0; i--)
if (pfa[a][i] != pfa[b][i]) a = pfa[a][i], b = pfa[b][i];
if (a != b) a = pfa[a][0], b = pfa[b][0];
return a;
}
void kuro() {
sort(es + 1, es + ecnts + 1);
pcnt = n;
for (int i = 1; i <= pcnt; i++) bfa[i] = i;
for (int i = 1; i <= ecnts; i++) {
auto [a, b, c] = es[i];
int aa = findbfa(a), bb = findbfa(b);
if (aa == bb) continue;
pcnt++, bfa[pcnt] = bfa[aa] = bfa[bb] = pcnt, pva[pcnt] = c,
pfa[aa][0] = pfa[bb][0] = pcnt;
}
for (int i = pcnt; i >= 1; i--) pdep[i] = pdep[pfa[i][0]] + 1;
for (int i = 1; i <= lglg; i++)
for (int j = 1; j <= pcnt; j++) pfa[j][i] = pfa[pfa[j][i - 1]][i - 1];
}
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty(), chx = ty(), qn = ty();
for (int i = 1, a, b, c; i <= m; i++)
a = ty(), b = ty(), c = ty(), addde(a, b, c);
dijks(), kuro();
for (int qq = 1; qq <= qn; qq++) {
int a = ty(), b = ty();
cout << pva[lca(a, b)] << lf;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pai = acos(-1);
const double eps = 1e-8;
const long long mod = 1e9 + 7;
const int MXN = 2e5;
const int MXLOG = 20;
vector<pair<long long, int> > g[MXN], G[MXN];
long long d[MXN];
int dfg[MXN], sour[MXN];
int fa[MXN];
int found(int x) {
if (x == fa[x]) return x;
return fa[x] = found(fa[x]);
}
int bei[MXN][MXLOG], de[MXN];
long long val[MXN][MXLOG];
void dfs(int u, int p) {
for (auto i : G[u]) {
if (i.second != p) {
de[i.second] = de[u] + 1;
bei[i.second][0] = u;
val[i.second][0] = i.first;
dfs(i.second, u);
}
}
}
void initLCA(int nn) {
bei[1][0] = -1;
de[1] = 0;
dfs(1, -1);
for (int k = 0; k < MXLOG - 1; k++) {
for (int v = 1; v <= nn; v++) {
if (bei[v][k] < 0)
bei[v][k + 1] = -1;
else
bei[v][k + 1] = bei[bei[v][k]][k],
val[v][k + 1] = max(val[v][k], val[bei[v][k]][k]);
}
}
}
long long query(int u, int v) {
if (de[u] > de[v]) swap(u, v);
long long re = -1;
for (int k = 0; k < MXLOG; k++) {
if ((de[v] - de[u]) >> k & 1) re = max(re, val[v][k]), v = bei[v][k];
}
if (u == v) return re;
for (int k = MXLOG - 1; k >= 0; k--) {
if (bei[u][k] != bei[v][k]) {
re = max(re, val[v][k]), re = max(re, val[u][k]);
u = bei[u][k], v = bei[v][k];
}
}
re = max(re, val[u][0]);
re = max(re, val[v][0]);
return re;
}
int main() {
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++) {
int su, sv, sw;
scanf("%d%d%d", &su, &sv, &sw);
g[su].push_back(make_pair(sw, sv));
g[sv].push_back(make_pair(sw, su));
}
priority_queue<pair<long long, int> > pq;
for (int i = 1; i <= n; i++) d[i] = LLONG_MAX / 2;
for (int i = 1; i <= k; i++) pq.push(make_pair(0, i)), d[i] = 0, sour[i] = i;
while (!pq.empty()) {
auto now = pq.top();
pq.pop();
int u = now.second;
if (dfg[u]) continue;
dfg[u] = 1;
for (auto ed : g[u]) {
long long dis = ed.first + d[u];
if (dis > d[ed.second]) continue;
d[ed.second] = dis;
sour[ed.second] = sour[u];
pq.push(make_pair(-dis, ed.second));
}
}
vector<tuple<long long, int, int> > krs;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= n; i++) {
for (auto ed : g[i]) {
if (sour[i] != sour[ed.second])
krs.push_back(make_tuple(ed.first + d[i] + d[ed.second], sour[i],
sour[ed.second]));
}
}
sort(krs.begin(), krs.end());
for (auto i : krs) {
int xx = found(get<1>(i));
int yy = found(get<2>(i));
if (xx == yy) continue;
fa[xx] = fa[yy];
G[get<1>(i)].push_back(make_pair(get<0>(i), get<2>(i)));
G[get<2>(i)].push_back(make_pair(get<0>(i), get<1>(i)));
}
initLCA(n);
while (q--) {
int sa, sb;
scanf("%d%d", &sa, &sb);
cout << query(sa, sb) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAX_SIZE = 112345;
const int MAX_SIZE_LOG = 20;
int N, M, K, Q;
std::vector<std::pair<int, int>> g[MAX_SIZE];
std::pair<long long int, int> dist[MAX_SIZE];
int parent[MAX_SIZE];
std::vector<std::pair<long long int, std::pair<int, int>>> edges;
std::vector<std::pair<int, long long int>> tree[MAX_SIZE];
int parent_lca[MAX_SIZE][MAX_SIZE_LOG];
long long int mx_lca[MAX_SIZE][MAX_SIZE_LOG];
int depth[MAX_SIZE];
void UNION(const int &x, const int &y) { parent[x] = parent[y]; }
int FIND(const int &x) {
if (x != parent[x]) {
parent[x] = FIND(parent[x]);
}
return parent[x];
}
void build_dijkstra() {
for (int i = 0; i < N; i += 1) {
dist[i] = {LLONG_MAX, -1};
}
std::priority_queue<std::pair<long long int, int>> pq;
for (int i = 0; i < K; i += 1) {
dist[i] = {0, i};
pq.push({-dist[i].first, i});
}
while (!pq.empty()) {
const long long int cost = -pq.top().first;
const int i = pq.top().second;
pq.pop();
if (cost > dist[i].first) {
continue;
}
for (const auto &j : g[i]) {
const long long int nxt = cost + j.second;
if (nxt < dist[j.first].first) {
dist[j.first] = {nxt, dist[i].second};
pq.push({-nxt, j.first});
}
}
}
}
void build_tree() {
for (int i = 0; i < N; i += 1) {
for (const auto &j : g[i]) {
edges.push_back({dist[i].first + dist[j.first].first + j.second,
{dist[i].second, dist[j.first].second}});
}
}
std::sort(edges.begin(), edges.end());
for (int i = 0; i < N; i += 1) {
parent[i] = i;
}
for (const auto &edge : edges) {
const int &x = FIND(edge.second.first);
const int &y = FIND(edge.second.second);
if (x != y) {
UNION(x, y);
if (edge.second.first >= K or edge.second.second >= K) {
continue;
}
tree[edge.second.first].push_back({edge.second.second, edge.first});
tree[edge.second.second].push_back({edge.second.first, edge.first});
}
}
}
void dfs(const int &i, const int &p) {
depth[i] = depth[p] + 1;
parent_lca[i][0] = p;
for (int j = 1; j < MAX_SIZE_LOG; j += 1) {
parent_lca[i][j] = parent_lca[parent_lca[i][j - 1]][j - 1];
mx_lca[i][j] =
std::max(mx_lca[i][j - 1], mx_lca[parent_lca[i][j - 1]][j - 1]);
}
for (const auto &j : tree[i]) {
if (j.first == p) {
continue;
}
mx_lca[j.first][0] = j.second;
dfs(j.first, i);
}
}
int query_lca(const int &x, const int &y) {
int a = x;
int b = y;
if (depth[a] < depth[b]) {
std::swap(a, b);
}
const int dist = depth[a] - depth[b];
for (int j = 0; j < MAX_SIZE_LOG; j += 1) {
if (dist & (1 << j)) {
a = parent_lca[a][j];
}
}
if (a == b) {
return a;
}
for (int j = MAX_SIZE_LOG - 1; j >= 0; j -= 1) {
if (parent_lca[a][j] != parent_lca[b][j]) {
a = parent_lca[a][j];
b = parent_lca[b][j];
}
}
return parent_lca[a][0];
}
long long int query(const int &vertex, const int &lca) {
long long int ans = LLONG_MIN;
const int dist = depth[vertex] - depth[lca];
for (int i = 0, x = vertex; i < MAX_SIZE_LOG; i += 1) {
if (dist & (1 << i)) {
ans = std::max(ans, mx_lca[x][i]);
x = parent_lca[x][i];
}
}
return ans;
}
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
std::cin >> N >> M >> K >> Q;
for (int i = 0; i < M; i += 1) {
int x, y, w;
std::cin >> x >> y >> w;
x -= 1;
y -= 1;
g[x].push_back({y, w});
g[y].push_back({x, w});
}
build_dijkstra();
build_tree();
dfs(0, 0);
for (int i = 0; i < Q; i += 1) {
int x, y;
std::cin >> x >> y;
x -= 1;
y -= 1;
const int lca = query_lca(x, y);
std::cout << std::max(query(x, lca), query(y, lca)) << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3e5 + 7;
const long long INF = 1e18 + 7;
vector<pair<long long, long long>> adj[MAXN];
vector<long long> v[MAXN];
long long p[MAXN], sz[MAXN], mp[2 * MAXN];
long long ans[MAXN];
long long n, m, k, q;
struct Edge {
long long u, v, w;
};
vector<long long> djk() {
vector<long long> dist(n);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (long long i = 0; i < n; i++) {
if (i < k) {
pq.push(pair<long long, long long>(0, i));
dist[i] = 0;
} else {
dist[i] = INF;
}
}
while (!pq.empty()) {
long long d = pq.top().first, u = pq.top().second;
pq.pop();
if (dist[u] < d) continue;
for (pair<long long, long long> x : adj[u]) {
long long v = x.first, w = x.second;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push(pair<long long, long long>(dist[v], v));
}
}
}
return dist;
}
long long find(long long a) {
if (p[a] == a) return a;
return p[a] = find(p[a]);
}
void merge(long long a, long long b, long long w) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] > sz[b]) swap(a, b);
for (long long tk1 : v[a]) {
long long tk2 = tk1 ^ 1;
if (find(mp[tk2]) == b) {
long long idx = tk1 / 2;
ans[idx] = w;
}
v[b].push_back(tk1);
}
v[a].resize(0);
sz[b] += sz[a];
p[a] = b;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> q;
for (long long i = 0; i < MAXN; i++) {
p[i] = i;
sz[i] = 1;
}
vector<Edge> edges;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--;
v--;
adj[u].push_back(pair<long long, long long>(v, w));
adj[v].push_back(pair<long long, long long>(u, w));
edges.push_back({u, v, w});
}
vector<long long> dist = djk();
for (long long i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
long long tk1 = 2 * i, tk2 = tk1 + 1;
mp[tk1] = a;
mp[tk2] = b;
v[a].push_back(tk1);
v[b].push_back(tk2);
}
for (Edge &e : edges) {
e.w += dist[e.u] + dist[e.v];
}
sort(edges.begin(), edges.end(), [](Edge a, Edge b) { return a.w < b.w; });
for (long long i = 0; i < m; i++) {
merge(edges[i].u, edges[i].v, edges[i].w);
}
for (long long i = 0; i < q; i++) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 123456;
const int LN = 19;
const long long INF = 1LL << 60LL;
int n, m, k, q;
int parent[N];
int depth[N];
int anc[LN][N];
long long dp[LN][N];
long long dist[N];
vector<pair<int, int>> adj[N];
vector<tuple<long long, int, int>> edges;
vector<pair<int, long long>> tree[N];
void dijkstra() {
priority_queue<pair<long long, int>> states;
for (int i = 1; i <= n; i++) {
dist[i] = INF;
}
for (int i = 1; i <= k; i++) {
dist[i] = 0;
states.push({-dist[i], i});
}
while (!states.empty()) {
auto [cur_dist, u] = states.top();
cur_dist = -cur_dist;
states.pop();
if (cur_dist > dist[u]) continue;
for (auto [v, w] : adj[u]) {
if (cur_dist + w < dist[v]) {
dist[v] = cur_dist + w;
states.push({-dist[v], v});
}
}
}
}
inline int root(int x) {
if (parent[x] == x) {
return x;
} else {
return parent[x] = root(parent[x]);
}
}
inline bool join(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return false;
parent[v] = u;
return true;
}
void dfs(int u, int p, long long pe = -1) {
anc[0][u] = p;
dp[0][u] = pe;
for (int i = 1; i < LN; i++) {
anc[i][u] = anc[i - 1][anc[i - 1][u]];
dp[i][u] = max(dp[i - 1][u], dp[i - 1][anc[i - 1][u]]);
}
for (auto [v, w] : tree[u]) {
if (v != p) {
depth[v] = depth[u] + 1;
dfs(v, u, w);
}
}
}
inline long long solve(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
long long ans = 0;
for (int i = LN - 1; i >= 0; i--) {
if (depth[u] - (1 << i) >= depth[v]) {
ans = max(ans, dp[i][u]);
u = anc[i][u];
}
}
if (u == v) return ans;
for (int i = LN - 1; i >= 0; i--) {
if (anc[i][u] != anc[i][v]) {
ans = max(ans, max(dp[i][u], dp[i][v]));
u = anc[i][u];
v = anc[i][v];
}
}
return max(ans, max(dp[0][u], dp[0][v]));
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
dijkstra();
for (int i = 1; i <= n; i++) {
parent[i] = i;
for (auto [j, w] : adj[i]) {
if (i > j) continue;
edges.push_back(make_tuple(dist[i] + dist[j] + w, i, j));
}
}
sort(edges.begin(), edges.end());
for (auto [w, u, v] : edges) {
if (join(u, v)) {
tree[u].push_back({v, w});
tree[v].push_back({u, w});
}
}
dfs(1, 1);
while (q--) {
int u, v;
cin >> u >> v;
cout << solve(u, v) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, long long>;
using LL = long long;
const int Maxn = 1e5 + 20, Maxm = (3e5 + 20) * 3;
const LL inf = 0x3f3f3f3f;
struct edge {
int next, from, to;
LL cost;
bool operator<(const edge& val) const { return cost < val.cost; }
} es[Maxm];
int head[Maxn], cnt;
void addedge(int u, int v, LL w) {
es[cnt].next = head[u];
es[cnt].from = u;
es[cnt].to = v;
es[cnt].cost = w;
head[u] = cnt++;
}
int n, m, k, q;
LL dis[Maxn];
void dijkstra() {
memset(dis, inf, sizeof(dis));
priority_queue<P, vector<P>, greater<P>> que;
for (int i = 1; i <= k; ++i) {
dis[i] = 0;
que.push(P(0, i));
}
while (!que.empty()) {
P tmp = que.top();
que.pop();
int u = tmp.second;
if (dis[u] < tmp.first) continue;
for (int i = head[u]; ~i; i = es[i].next) {
int v = es[i].to;
LL w = es[i].cost;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
que.push(P(dis[v], v));
}
}
}
for (int i = 0; i < cnt; ++i) {
es[i].cost += dis[es[i].from] + dis[es[i].to];
}
}
int Par[Maxn], Rank[Maxn];
int Find(int x) {
if (Par[x] == -1) return x;
return Par[x] = Find(Par[x]);
}
void Unite(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return;
if (Rank[x] < Rank[y]) {
Par[x] = y;
} else {
Par[y] = x;
if (Rank[x] == Rank[y]) Rank[x]++;
}
}
bool isSame(int x, int y) {
if (Find(x) == Find(y)) return true;
return false;
}
vector<P> vs[Maxn];
void Kruskal() {
sort(es, es + cnt);
int u, v;
for (int i = 0; i < cnt; ++i) {
int u = es[i].from, v = es[i].to;
LL w = es[i].cost;
if (!isSame(u, v)) {
Unite(u, v);
vs[u].push_back(P(v, w));
vs[v].push_back(P(u, w));
}
}
}
int anc[Maxn][21], dep[Maxn];
LL cost[Maxn][21];
void preLCA(int u = 1, int fa = 0) {
for (int i = 1; (1 << i) <= dep[u]; ++i) {
anc[u][i] = anc[anc[u][i - 1]][i - 1];
cost[u][i] = max(cost[u][i - 1], cost[anc[u][i - 1]][i - 1]);
}
for (auto tmp : vs[u]) {
int v = tmp.first;
if (v == fa) continue;
dep[v] = dep[u] + 1;
anc[v][0] = u;
cost[v][0] = tmp.second;
preLCA(v, u);
}
}
int LCA(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
for (int i = 20; i >= 0; --i) {
if (dep[a] <= dep[b] - (1 << i)) b = anc[b][i];
}
if (a == b) return a;
for (int i = 20; i >= 0; --i) {
if (anc[a][i] == anc[b][i])
continue;
else
a = anc[a][i], b = anc[b][i];
}
return anc[b][0];
}
LL getMax(int u, int sta) {
LL res = 0;
for (int i = 0; i <= 20; ++i) {
if (sta & (1 << i)) res = max(res, cost[u][i]), u = anc[u][i];
}
return res;
}
void init() {
cnt = 0;
memset(head, -1, sizeof(head));
memset(Par, -1, sizeof(Par));
memset(Rank, 0, sizeof(Rank));
memset(anc, 0, sizeof(anc));
}
int main() {
init();
scanf("%d%d%d%d", &n, &m, &k, &q);
int u, v;
LL w;
for (int i = 0; i < m; ++i) {
scanf("%d%d%lld", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
dijkstra();
Kruskal();
preLCA();
int x, y;
int lca;
while (q--) {
cin >> x >> y;
lca = LCA(x, y);
printf("%lld\n",
max(getMax(x, dep[x] - dep[lca]), getMax(y, dep[y] - dep[lca])));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
long long w;
int to, from;
};
const long long INF = 1e18;
const int N = 2e5 + 5;
vector<E> g[N];
int anime[N], from[N];
long long dist[N], ans[N];
set<int> st[N];
int findSet(int x) { return anime[x] < 0 ? x : anime[x] = findSet(anime[x]); }
void un(int a, int b, long long w) {
a = findSet(a);
b = findSet(b);
if (a == b) return;
if (anime[a] > anime[b]) swap(a, b);
anime[a] += anime[b];
anime[b] = a;
for (int x : st[b]) {
if (st[a].count(x)) {
st[a].erase(x);
ans[x] = w;
} else {
st[a].insert(x);
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
a--, b--;
g[a].push_back({w, b, a});
g[b].push_back({w, a, b});
}
fill(from, from + n, -1);
fill(dist, dist + n, INF);
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = 0; i < k; i++) {
anime[i] = -1;
dist[i] = 0;
from[i] = i;
pq.push({0, i});
}
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
x--, y--;
st[x].insert(i);
st[y].insert(i);
}
while (!pq.empty()) {
int node = pq.top().second;
long long cd = pq.top().first;
pq.pop();
if (cd != dist[node]) {
continue;
}
for (E e : g[node]) {
if (dist[e.to] > dist[node] + e.w) {
dist[e.to] = dist[node] + e.w;
from[e.to] = from[node];
pq.push({dist[e.to], e.to});
}
}
}
vector<E> edges;
for (int i = 0; i < n; i++) {
for (E e : g[i]) {
if (e.to > i && from[e.to] != from[i])
edges.push_back({dist[e.to] + dist[i] + e.w, from[i], from[e.to]});
}
}
sort(edges.begin(), edges.end(),
[](const E &a, const E &b) { return a.w < b.w; });
for (E e : edges) {
un(e.to, e.from, e.w);
}
for (int i = 0; i < q; i++) {
cout << ans[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, Q = 3e5 + 10, M = 3e5 + 10;
const long long inf = 1e15 + 42;
struct edge_t {
int u, v;
long long w;
bool operator<(const edge_t &o) const { return w < o.w; }
};
vector<pair<long long, long long>> g[N];
vector<pair<int, int>> queries[N];
edge_t e[M];
long long dist[N], ans[Q];
int back[N], par[N];
int get_root(int u);
void merge(int u, int v, long long w);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; ++i) {
cin >> e[i].u >> e[i].v >> e[i].w;
g[e[i].u].push_back({e[i].v, e[i].w});
g[e[i].v].push_back({e[i].u, e[i].w});
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (int i = 1; i <= k; ++i) {
pq.push({0, i});
back[i] = i;
par[i] = i;
}
for (int i = k + 1; i <= n; ++i) {
dist[i] = inf;
}
while (!pq.empty()) {
auto cur = pq.top();
pq.pop();
int u = cur.second;
if (dist[u] < cur.first) {
continue;
}
for (auto &edge : g[u]) {
int v = edge.first, w = edge.second;
if (dist[u] + w < dist[v]) {
dist[v] = dist[u] + w;
back[v] = back[u];
pq.push({dist[v], v});
}
}
}
vector<edge_t> edges;
for (int i = 1; i <= m; ++i) {
int u = back[e[i].u], v = back[e[i].v];
long long w = dist[e[i].u] + dist[e[i].v] + e[i].w;
if (u != v) {
edges.push_back({u, v, w});
}
}
sort(edges.begin(), edges.end());
for (int i = 1; i <= q; ++i) {
int a, b;
cin >> a >> b;
queries[a].push_back({b, i});
queries[b].push_back({a, i});
ans[i] = inf;
}
for (auto &edge : edges) {
merge(edge.u, edge.v, edge.w);
}
for (int i = 1; i <= q; ++i) {
cout << ans[i] << '\n';
}
}
int get_root(int u) {
if (u != par[u]) {
par[u] = get_root(par[u]);
}
return par[u];
}
void merge(int u, int v, long long w) {
u = get_root(u);
v = get_root(v);
if (u == v) {
return;
} else if (queries[u].size() < queries[v].size()) {
swap(u, v);
}
for (auto &q : queries[v]) {
if (get_root(q.first) == u) {
ans[q.second] = min(ans[q.second], w);
} else {
queries[u].push_back(q);
}
}
par[v] = u;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 4e5 + 5;
const long long MAXM = 6e5 + 5;
const long long INF = 1e9 + 7;
const long long mod = 1e9 + 7;
struct edge {
long long from, to, w, nxt;
} e[MAXM << 2], E[MAXM], E2[MAXM << 1];
long long head[MAXN], num_edge = 0;
long long Head[MAXN], Num_edge = 0;
struct node {
long long bh, val;
bool operator<(const node &b) const { return val > b.val; }
};
long long n, m, k, Q, cnt;
long long dis[MAXN], fa[MAXN], f[MAXN][22], dep[MAXN], maxm[MAXN][22];
bool vis[MAXN];
priority_queue<node> q;
long long read() {
long long s = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= (ch == '-'), ch = getchar();
while (isdigit(ch)) s = (s << 1) + (s << 3) + ch - '0', ch = getchar();
return f ? -s : s;
}
bool cmp(edge x, edge y) { return x.w < y.w; }
void add_edge(long long from, long long to, long long w) {
e[++num_edge] = (edge){from, to, w, head[from]}, head[from] = num_edge;
}
void Add_edge(long long from, long long to, long long w) {
E2[++Num_edge] = (edge){from, to, w, Head[from]}, Head[from] = Num_edge;
}
long long find(long long x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void dij() {
memset(dis, 0x3f, sizeof dis);
dis[0] = 0;
q.push((node){0, 0});
while (!q.empty()) {
node u = q.top();
q.pop();
if (vis[u.bh]) continue;
vis[u.bh] = true;
for (long long i = head[u.bh]; i; i = e[i].nxt) {
long long v = e[i].to;
if (dis[v] > dis[u.bh] + e[i].w) {
dis[v] = dis[u.bh] + e[i].w;
if (!vis[v]) q.push((node){v, dis[v]});
}
}
}
}
void kruskal() {
for (long long i = 1; i <= n; ++i) fa[i] = i;
for (long long i = 1; i <= m; ++i) {
long long uf = find(E[i].from), vf = find(E[i].to);
if (uf != vf) {
fa[vf] = uf;
Add_edge(E[i].from, E[i].to, E[i].w),
Add_edge(E[i].to, E[i].from, E[i].w);
cnt++;
if (cnt == n - 1) return;
}
}
}
void dfs(long long u, long long fa) {
f[u][0] = fa;
for (long long i = Head[u]; i; i = E2[i].nxt) {
long long v = E2[i].to;
if (v == fa) continue;
dep[v] = dep[u] + 1;
maxm[v][0] = E2[i].w;
dfs(v, u);
}
}
void init() {
for (long long i = 1; i <= 20; ++i) {
for (long long j = 1; j <= n; ++j) {
f[j][i] = f[f[j][i - 1]][i - 1];
maxm[j][i] = max(maxm[j][i - 1], maxm[f[j][i - 1]][i - 1]);
}
}
}
long long get_max(long long x, long long y) {
long long ans = 0;
if (dep[x] < dep[y]) swap(x, y);
for (long long i = 20; i >= 0; --i) {
if (dep[f[x][i]] < dep[y]) continue;
ans = max(ans, maxm[x][i]);
x = f[x][i];
}
if (x == y) return ans;
for (long long i = 20; i >= 0; --i) {
if (f[x][i] == f[y][i]) continue;
ans = max(ans, max(maxm[x][i], maxm[y][i]));
x = f[x][i];
y = f[y][i];
}
ans = max(ans, max(maxm[x][0], maxm[y][0]));
return ans;
}
signed main() {
n = read(), m = read(), k = read(), Q = read();
for (long long i = 1, u, v, w; i <= m; ++i) {
u = read(), v = read(), w = read();
add_edge(u, v, w), add_edge(v, u, w);
E[i].from = u, E[i].to = v, E[i].w = w;
}
for (long long i = 1; i <= k; ++i) {
add_edge(0, i, 0), add_edge(i, 0, 0);
}
dij();
for (long long i = 1; i <= m; ++i) {
E[i].w += dis[E[i].from] + dis[E[i].to];
}
sort(E + 1, E + m + 1, cmp);
kruskal();
dep[1] = 1;
dfs(1, -1);
init();
for (long long i = 1, u, v; i <= Q; ++i) {
u = read(), v = read();
cout << get_max(u, v) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 100;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long n, m, k, p, dis[maxn], par[maxn], dsu[maxn], ans[maxn];
bool vis[maxn];
vector<pair<long long, pair<long long, long long> > > e;
vector<pair<long long, long long> > g[maxn], vec[maxn];
vector<long long> a[maxn];
priority_queue<pair<long long, long long> > q;
void init() {
for (long long i = 1; i <= k; i++) {
dsu[i] = i;
a[i].push_back(i);
}
return;
}
void Union(long long v, long long u, long long c) {
long long x, y;
v = dsu[v];
u = dsu[u];
if (v == u) return;
if (a[v].size() < a[u].size()) swap(v, u);
for (long long i = 0; i < a[u].size(); i++) {
x = a[u][i];
a[v].push_back(x);
dsu[x] = v;
for (long long j = 0; j < vec[x].size(); j++) {
y = vec[x][j].first;
if (dsu[y] == dsu[x]) {
ans[vec[x][j].second] = min(ans[vec[x][j].second], c);
}
}
}
return;
}
int main() {
long long v, u, c;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k >> p;
for (long long i = 0; i < m; i++) {
cin >> v >> u >> c;
g[v].push_back({u, c});
g[u].push_back({v, c});
}
for (long long i = 0; i < p; i++) {
cin >> v >> u;
vec[v].push_back({u, i});
vec[u].push_back({v, i});
ans[i] = inf;
}
fill(dis, dis + maxn, inf);
for (long long i = 1; i <= k; i++) {
dis[i] = 0;
par[i] = i;
q.push({-dis[i], i});
}
while (!q.empty()) {
v = q.top().second;
q.pop();
if (vis[v]) continue;
for (long long i = 0; i < g[v].size(); i++) {
u = g[v][i].first;
c = g[v][i].second;
if (dis[u] > dis[v] + c) {
dis[u] = dis[v] + c;
par[u] = par[v];
q.push({-dis[u], u});
}
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < g[i].size(); j++) {
u = g[i][j].first;
c = g[i][j].second;
if (u > i && par[i] != par[u]) {
e.push_back({dis[i] + c + dis[u], {par[i], par[u]}});
}
}
}
init();
sort(e.begin(), e.end());
for (long long i = 0; i < e.size(); i++) {
c = e[i].first;
v = e[i].second.first;
u = e[i].second.second;
Union(v, u, c);
}
for (long long i = 0; i < p; i++) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class edge {
public:
int u, v;
long long w;
edge() {}
edge(int u, int v, long long w) : u(u), v(v), w(w) {}
bool operator<(const edge& other) const { return w < other.w; }
};
class node {
public:
int n;
long long w;
node() {}
node(int n, long long w) : n(n), w(w) {}
bool operator<(const node& other) const { return other.w < w; }
};
const int MAXN = 3e5;
const int LOG = 19;
vector<edge> g[MAXN + 10];
long long D[MAXN + 10];
int n, m, k, q;
edge E[MAXN + 10];
int P[MAXN + 10];
int find(int x) {
if (x == P[x]) return x;
return P[x] = find(P[x]);
}
void join(int x, int y) { P[find(x)] = find(y); }
void dijkstra() {
priority_queue<node> pq;
for (int i = 1; i <= k; i++) {
pq.push(node(i, 0LL));
D[i] = 0;
}
for (int i = k + 1; i <= n; i++) D[i] = LLONG_MAX;
while (!pq.empty()) {
node aux = pq.top();
pq.pop();
int cur = aux.n;
long long w = aux.w;
for (int i = 0; i < (int)g[cur].size(); i++) {
int next = g[cur][i].v;
long long nw = w + g[cur][i].w;
if (D[next] <= nw) continue;
D[next] = nw;
pq.push(node(next, nw));
}
}
}
int p[LOG][MAXN + 10];
int d[MAXN + 10];
long long M[LOG][MAXN + 10];
void dfs(int cur, int prev, int depth = 0, long long w = 0) {
p[0][cur] = prev;
M[0][cur] = w;
d[cur] = depth;
for (int i = 0; i < (int)g[cur].size(); i++) {
int next = g[cur][i].v;
if (next == prev) continue;
dfs(next, cur, depth + 1, g[cur][i].w);
}
}
void pre() {
for (int i = 1; i < LOG; i++) {
for (int j = 1; j <= n; j++) {
p[i][j] = p[i - 1][p[i - 1][j]];
M[i][j] = max(M[i - 1][j], M[i - 1][p[i - 1][j]]);
}
}
}
long long query(int u, int v) {
long long worst = 0;
if (d[u] > d[v]) swap(u, v);
int logi;
for (logi = 0; (1 << logi) <= d[v]; logi++)
;
logi--;
for (int i = logi; i >= 0; i--) {
if (d[v] - (1 << i) >= d[u]) {
worst = max(worst, M[i][v]);
v = p[i][v];
}
}
if (u == v) return worst;
for (int i = logi; i >= 0; i--) {
if (p[i][u] != p[i][v]) {
worst = max(worst, max(M[i][u], M[i][v]));
u = p[i][u];
v = p[i][v];
}
}
worst = max(worst, max(M[0][u], M[0][v]));
return worst;
}
int main() {
scanf("%d %d %d %d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d %d %lld", &u, &v, &w);
E[i] = edge(u, v, w);
g[u].push_back(edge(u, v, w));
g[v].push_back(edge(v, u, w));
}
dijkstra();
for (int i = 0; i < m; i++) {
int u = E[i].u, v = E[i].v;
E[i].w += D[u] + D[v];
}
sort(E, E + m);
for (int i = 1; i <= m; i++) g[i].clear();
for (int i = 1; i <= n; i++) P[i] = i;
for (int i = 0; i < m; i++) {
int u = E[i].u, v = E[i].v;
if (find(u) == find(v)) continue;
join(u, v);
g[u].push_back(edge(u, v, E[i].w));
g[v].push_back(edge(v, u, E[i].w));
}
dfs(1, 1);
pre();
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d %d", &u, &v);
printf("%lld\n", query(u, v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class DebugStream {
} LOG;
template <typename T>
DebugStream &operator<<(DebugStream &s, const T &) {
return s;
}
mt19937 rnd(time(NULL));
const int maxN = 1e5 + 9, maxV = 1e6 + 9, MOD = 1e9 + 7, SQ = 335, lg = 20,
bs = 29;
vector<pair<long long, long long>> adj[maxN];
vector<pair<long long, long long>> qrs[maxN];
int comp[maxN], n, k, m, q;
long long dst[maxN], ans[maxN * 3];
namespace DSU {
int comp[maxN];
void prepare() {
for (int i = 0; i < n; i++) comp[i] = i;
}
int get(int u) {
if (comp[u] != u) comp[u] = get(comp[u]);
return comp[u];
}
void considerEdge(long long weight, int u, int v) {
u = get(u), v = get(v);
if (u == v) return;
if (qrs[u].size() > qrs[v].size()) swap(u, v);
for (auto el : qrs[u])
if (get(el.second) == v)
ans[el.first] = weight;
else
qrs[v].push_back(el);
comp[u] = v;
}
} // namespace DSU
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
priority_queue<pair<long long, pair<long long, long long>>,
vector<pair<long long, pair<long long, long long>>>,
greater<pair<long long, pair<long long, long long>>>>
pq;
cin >> n >> m >> k >> q;
for (int i = 0; i < n; i++) {
if (i < k)
pq.push(pair<long long, pair<long long, long long>>(
0, pair<long long, long long>(i, i)));
comp[i] = -1;
}
for (long long i = 0, u, v, c; i < m; i++) {
cin >> u >> v >> c, u--, v--;
adj[u].push_back(pair<long long, long long>(c, v));
adj[v].push_back(pair<long long, long long>(c, u));
}
for (int i = 0, u, v; i < q; i++) {
cin >> u >> v;
u--, v--;
qrs[u].emplace_back(i, v);
qrs[v].emplace_back(i, u);
}
while (pq.size()) {
auto cr = pq.top();
pq.pop();
if (comp[cr.second.first] != -1) continue;
comp[cr.second.first] = cr.second.second;
dst[cr.second.first] = cr.first;
for (auto sn : adj[cr.second.first])
if (comp[sn.second] == -1)
pq.push(pair<long long, pair<long long, long long>>(
cr.first + sn.first,
pair<long long, long long>(sn.second, cr.second.second)));
}
vector<pair<long long, pair<long long, long long>>> edg;
DSU::prepare();
for (int i = 0; i < n; i++)
for (auto el : adj[i])
if (comp[i] != comp[el.second])
edg.emplace_back(dst[i] + dst[el.second] + el.first,
pair<long long, long long>(comp[i], comp[el.second]));
sort(edg.begin(), edg.end());
for (auto el : edg)
DSU::considerEdge(el.first, el.second.first, el.second.second);
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 4e5, MOD = 1e9 + 7;
long long n, m, k, q;
long long P[MX];
vector<tuple<long long, long long, long long>> edges;
vector<pair<long long, long long>> adjList[MX];
set<int> qr[MX];
long long r[MX], p[MX];
long long ans[MX];
long long curAns = 0;
void dijkstra() {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (int i = int(0); i < int(n); i++) P[i] = 1e18;
for (int i = int(0); i < int(k); i++) pq.push({0, i}), P[i] = 0;
while (!pq.empty()) {
pair<long long, long long> p = pq.top();
pq.pop();
long long u = p.second, w = p.first;
if (P[u] != w) continue;
for (pair<long long, long long> v : adjList[u])
if (w + v.second < P[v.first])
pq.push({w + v.second, v.first}), P[v.first] = w + v.second;
}
}
void buildDSU() {
for (int i = int(0); i < int(n); i++) r[i] = 0, p[i] = i;
}
int getSet(int i) { return i == p[i] ? i : p[i] = getSet(p[i]); }
bool isSameSet(int i, int j) { return getSet(i) == getSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
i = getSet(i), j = getSet(j);
if (r[i] > r[j]) {
p[j] = i;
for (long long u : qr[j]) {
if (qr[i].count(u)) {
qr[i].erase(u);
ans[u] = curAns;
} else {
qr[i].insert(u);
}
}
} else {
p[i] = j;
for (long long u : qr[i]) {
if (qr[j].count(u)) {
qr[j].erase(u);
ans[u] = curAns;
} else {
qr[j].insert(u);
}
}
if (r[i] == r[j]) r[j]++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k >> q;
for (int i = int(0); i < int(m); i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
adjList[u].push_back({v, w});
adjList[v].push_back({u, w});
edges.push_back({u, v, w});
}
dijkstra();
buildDSU();
for (int Q = int(0); Q < int(q); Q++) {
int a, b;
cin >> a >> b;
a--;
b--;
qr[a].insert(Q);
qr[b].insert(Q);
}
priority_queue<tuple<long long, long long, long long>,
vector<tuple<long long, long long, long long>>,
greater<tuple<long long, long long, long long>>>
pq;
for (int i = int(0); i < int(m); i++) {
long long u, v, w;
tie(u, v, w) = edges[i];
pq.push({w + P[u] + P[v], u, v});
}
while (!pq.empty()) {
long long u, v, w;
tie(w, u, v) = pq.top();
pq.pop();
if (!isSameSet(u, v)) {
curAns = w;
unionSet(u, v);
}
}
for (int i = int(0); i < int(q); i++) cout << ans[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFindPersistent {
vector<int> par;
vector<int64_t> time;
vector<vector<pair<int64_t, int>>> sz;
const int64_t INF = 1e18;
UnionFindPersistent(int n = 0) {
if (n > 0) initialize(n);
}
void initialize(int n) {
par.resize(n);
time.resize(n);
sz.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
time[i] = INF;
sz[i].push_back({-1, 1});
}
}
int find(int x, int64_t t) {
if (time[x] > t) {
return x;
} else {
return find(par[x], t);
}
}
int size(int x, int64_t t) {
x = find(x, t);
return (*(lower_bound(sz[x].begin(), sz[x].end(), make_pair(t + 1, 0)) - 1))
.second;
}
void unite(int x, int y, int64_t t) {
x = find(x, t);
y = find(y, t);
if (x == y) return;
int new_sz = sz[x].back().second + sz[y].back().second;
if (sz[x].back().second > sz[y].back().second) swap(x, y);
par[x] = y;
time[x] = t;
sz[y].push_back({t, new_sz});
}
bool same(int x, int y, int64_t t) { return find(x, t) == find(y, t); }
};
int main() {
int N, M, K, Q;
cin >> N >> M >> K >> Q;
vector<pair<int64_t, int64_t>> edges[100000];
for (int i = 0; i < M; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
edges[a].emplace_back(b, c);
edges[b].emplace_back(a, c);
}
vector<pair<int64_t, int64_t>> dist(N);
pair<int64_t, int64_t> INFP = {1e18, 1e18};
priority_queue<vector<int64_t>, vector<vector<int64_t>>,
greater<vector<int64_t>>>
que;
for (int i = 0; i < K; i++) {
dist[i] = {0, i};
que.push({0, i, i});
}
for (int i = K; i < N; i++) dist[i] = INFP;
while (que.size()) {
auto p = que.top();
que.pop();
int64_t d = p[0], i = p[1], s = p[2];
if (dist[i].first < d) continue;
for (auto& e : edges[i]) {
int64_t j = e.first, d2 = d + e.second;
if (dist[j].first > d2) {
dist[j] = {d2, s};
que.push({d2, j, s});
}
}
}
vector<vector<int64_t>> es;
for (int i = 0; i < N; i++)
for (auto& e : edges[i]) {
int j = e.first, c = e.second;
es.push_back(
{dist[i].first + dist[j].first + c, dist[i].second, dist[j].second});
}
sort(es.begin(), es.end());
UnionFindPersistent uf(N);
for (auto& e : es) uf.unite(e[1], e[2], e[0]);
for (int i = 0; i < Q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
int64_t ok = 1e18, ng = -1;
while (ok - ng > 1) {
int64_t mid = (ok + ng) / 2;
(uf.same(a, b, mid) ? ok : ng) = mid;
}
printf("%lld\n", ok);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, q;
vector<vector<pair<long long, long long>>> graph;
vector<vector<pair<long long, long long>>> tree;
vector<vector<long long>> edges;
void dijkstra() {
vector<long long> dist(n, 1e18);
vector<int> used(n, 0);
vector<int> prev(n, -1);
priority_queue<vector<long long>> q;
for (long long i = 0; i < k; i++) {
dist[i] = 0;
q.push({-dist[i], i});
prev[i] = i;
}
while (q.size()) {
long long v = q.top()[1];
q.pop();
if (used[v]) continue;
used[v] = 1;
for (auto e : graph[v]) {
if (dist[e.first] > dist[v] + e.second) {
prev[e.first] = prev[v];
dist[e.first] = dist[v] + e.second;
q.push({-dist[e.first], e.first});
}
if (prev[v] - prev[e.first])
edges.push_back(
{prev[v], prev[e.first], dist[e.first] + dist[v] + e.second});
}
}
}
vector<int> p;
vector<int> sz;
int get(int a) {
if (a == p[a]) return a;
return p[a] = get(p[a]);
}
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
p[b] = a;
}
bool comp(vector<long long> &a, vector<long long> &b) { return (a[2] < b[2]); }
int t = 0, len = 20;
vector<int> tin;
vector<int> tout;
vector<vector<int>> up;
vector<vector<long long>> mx;
void dfs(long long v, long long p) {
tin[v] = t++;
up[0][v] = p;
for (long long i = 1; i < len; i++) {
up[i][v] = up[i - 1][up[i - 1][v]];
mx[i][v] = max(mx[i - 1][v], mx[i - 1][up[i - 1][v]]);
}
for (auto h : tree[v]) {
if (h.first == p) continue;
mx[0][h.first] = h.second;
dfs(h.first, v);
}
tout[v] = t++;
}
int isancestor(long long a, long long b) {
return (tin[a] <= tin[b] and tout[b] <= tout[a]);
}
int getlca(long long a, long long b) {
if (isancestor(a, b)) return a;
if (isancestor(b, a)) return b;
for (long long i = len - 1; i >= 0; i--) {
if (!isancestor(up[i][a], b)) a = up[i][a];
}
return up[0][a];
}
long long getmx(long long a, long long b) {
if (a == b) return 0;
long long ans = 0;
for (long long i = len - 1; i >= 0; i--) {
if (!isancestor(up[i][a], b)) {
ans = max(ans, mx[i][a]);
a = up[i][a];
}
}
return max(ans, mx[0][a]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
graph.assign(n, vector<pair<long long, long long>>());
for (long long i = 0; i < m; i++) {
long long a, b, w;
cin >> a >> b >> w;
a--;
b--;
graph[a].push_back({b, w});
graph[b].push_back({a, w});
}
dijkstra();
p.assign(k, 0);
sz.assign(k, 1);
tree.assign(k, vector<pair<long long, long long>>());
for (long long i = 0; i < k; i++) p[i] = i;
sort(edges.begin(), edges.end(), comp);
for (auto e : edges) {
if (get(e[0]) == get(e[1])) continue;
tree[e[0]].push_back({e[1], e[2]});
tree[e[1]].push_back({e[0], e[2]});
unite(e[0], e[1]);
}
up.assign(len, vector<int>(k, 0));
mx.assign(len, vector<long long>(k, 0));
tin.assign(k, 0);
tout.assign(k, 0);
dfs(0, 0);
for (q; q; q--) {
int a, b;
cin >> a >> b;
a--;
b--;
int lca = getlca(a, b);
long long ans = max(getmx(a, lca), getmx(b, lca));
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto i = begin(v); i != end(v); i++) is >> *i;
return is;
}
int n, m, k, q;
vector<pair<int, int>> edg[101000];
vector<long long> best_dists(101000, 10000000000000000LL);
set<int> markers[101000];
int dsu[101000];
int drank[101000];
vector<long long> ans(301000, 10000000000000000LL);
struct Edg {
int u, v;
long long w;
};
int dsu_find(int a) {
if (dsu[a] == a) return a;
return dsu[a] = dsu_find(dsu[a]);
}
void dsu_union(int a, int b, long long curr_ans) {
a = dsu_find(a);
b = dsu_find(b);
if (a == b) return;
if (markers[a].size() < markers[b].size()) swap(a, b);
dsu[b] = a;
for (int x : markers[b]) {
if (markers[a].find(x) != markers[a].end()) {
ans[x] = curr_ans;
} else {
markers[a].insert(x);
}
}
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin >> n >> m >> k >> q;
vector<Edg> edges;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
edg[u].push_back({v, w});
edg[v].push_back({u, w});
edges.push_back(Edg{u, v, w});
}
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
std::greater<pair<long long, int>>>
ss;
for (int i = 0; i < k; i++) {
ss.push({0, i});
best_dists[i] = 0;
}
while (ss.size() > 0) {
auto curr = ss.top();
ss.pop();
if (curr.first != best_dists[curr.second]) continue;
for (auto x : edg[curr.second]) {
long long new_dist = curr.first + x.second;
if (new_dist < best_dists[x.first]) {
best_dists[x.first] = new_dist;
ss.push({best_dists[x.first], x.first});
}
}
}
for (int i = 0; i < m; i++) {
edges[i].w += best_dists[edges[i].u] + best_dists[edges[i].v];
}
sort(edges.begin(), edges.end(), [&](Edg& x, Edg& y) { return x.w < y.w; });
vector<pair<int, int>> qs(q);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--, b--;
qs[i] = {a, b};
markers[a].insert(i);
markers[b].insert(i);
}
for (int i = 0; i < n; i++) {
dsu[i] = i;
drank[i] = 1;
}
for (int i = 0; i < m; i++) {
dsu_union(edges[i].u, edges[i].v, edges[i].w);
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 600005;
long long n, m, k, q;
struct Edge {
int u, v;
long long c;
bool operator<(const Edge x) const { return c < x.c; }
} e[maxn];
struct Node {
int v;
long long c;
Node *next;
} * h[maxn], pool[maxn];
int tot;
void addEdge(int u, int v, long long c) {
Node *p = &pool[++tot];
p->v = v;
p->c = c;
p->next = h[u];
h[u] = p;
}
struct Que {
int v;
long long dis;
bool operator<(const Que a) const { return a.dis < dis; }
};
priority_queue<Que> pq;
void push(int v, long long dis) {
Que temp;
temp.v = v;
temp.dis = dis;
pq.push(temp);
}
long long vis[maxn], dis[maxn];
void dij() {
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= k; i++) {
dis[i] = 0;
push(i, 0);
}
while (!pq.empty()) {
int u = pq.top().v;
pq.pop();
if (vis[u] == 1) continue;
vis[u] = 1;
for (Node *p = h[u]; p; p = p->next) {
if (dis[p->v] > dis[u] + p->c) {
dis[p->v] = dis[u] + p->c;
if (vis[p->v] == 0) push(p->v, dis[p->v]);
}
}
}
}
int fa[maxn];
int getfather(int x) {
if (fa[x] == x)
return x;
else
return fa[x] = getfather(fa[x]);
}
void Merge(int x, int y) {
int fx = getfather(x);
int fy = getfather(y);
if (fx == fy) return;
fa[fx] = fy;
}
long long f[maxn][25], b[maxn][25];
int dep[maxn];
void dfs(int u, int fa) {
for (Node *p = h[u]; p; p = p->next) {
if (p->v == fa) continue;
f[p->v][0] = u;
b[p->v][0] = p->c;
dep[p->v] = dep[u] + 1;
dfs(p->v, u);
}
}
long long query(int u, int v) {
long long ans = 0;
if (dep[u] < dep[v]) swap(u, v);
int t = dep[u] - dep[v];
for (int i = 0; i < 24; i++) {
if ((1 << i) & t) {
ans = max(ans, b[u][i]);
u = f[u][i];
}
}
if (u == v) return ans;
for (int i = 23; i >= 0; i--) {
if (f[u][i] != f[v][i]) {
ans = max(ans, max(b[u][i], b[v][i]));
u = f[u][i];
v = f[v][i];
}
}
return max(ans, max(b[v][0], b[u][0]));
}
int main() {
memset(f, -1, sizeof(f));
cin >> n >> m >> k >> q;
int x, y, z;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].c);
addEdge(e[i].u, e[i].v, e[i].c);
addEdge(e[i].v, e[i].u, e[i].c);
}
dij();
for (int i = 1; i <= m; i++) {
e[i].c = e[i].c + dis[e[i].u] + dis[e[i].v];
}
sort(e + 1, e + m + 1);
int tc = 0;
memset(h, NULL, sizeof(h));
tot = 0;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (getfather(e[i].u) != getfather(e[i].v)) {
Merge(e[i].u, e[i].v);
addEdge(e[i].u, e[i].v, e[i].c);
addEdge(e[i].v, e[i].u, e[i].c);
tc++;
if (tc == n - 1) break;
}
}
dfs(1, -1);
for (int i = 1; i <= 23; i++) {
for (int j = 1; j <= n; j++) {
if (f[j][i - 1] != -1) {
f[j][i] = f[f[j][i - 1]][i - 1];
b[j][i] = max(b[j][i - 1], b[f[j][i - 1]][i - 1]);
}
}
}
for (int i = 1; i <= q; i++) {
scanf("%d %d", &x, &y);
printf("%lld\n", query(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100007;
const int maxq = 300007;
vector<int> head[maxn];
int n, m, q, k;
struct rev {
int from;
int to;
long long we;
rev(int uu = 0, int vv = 0, long long ww = -1) {
from = uu, to = vv, we = ww;
}
bool operator<(const rev& b) const {
if (we != b.we) return we < b.we;
if (to != b.to) return to < b.to;
return from < b.from;
}
};
vector<rev> edge;
int id[maxq << 1];
long long ans[maxq << 1];
inline void add_edge(int u, int v, int w) {
head[u].push_back(edge.size()), edge.push_back(rev(u, v, w));
}
vector<int> has[maxn];
int fa[maxn];
int sz[maxn];
int fd(int x) {
while (fa[x] != x) x = fa[x];
return x;
}
void merge(int x, int y, long long slack) {
int fx, fy;
fx = fd(x), fy = fd(y);
if (fx == fy) return;
if (sz[fx] > sz[fy]) swap(fx, fy);
fa[fx] = fy, sz[fy] += sz[fx];
for (auto o : has[fx]) {
has[fy].push_back(o);
if (fd(id[o ^ 1]) == fy) {
if (ans[min(o, o ^ 1)] == -1) ans[min(o, o ^ 1)] = slack;
}
}
}
long long dis[maxn];
void dij() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
for (int i = (1); i <= (n); ++i) {
if (i <= k)
q.push({0LL, i});
else
dis[i] = -1;
}
while (!q.empty()) {
auto tp = q.top();
q.pop();
int u = tp.second;
long long slack = tp.first;
if (slack != dis[u]) continue;
for (auto i : head[u]) {
auto e = edge[i];
int v = e.to;
long long we = e.we;
if (dis[v] == -1 || we + slack < dis[v])
dis[v] = we + slack, q.push({dis[v], v});
}
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k >> q;
for (int i = (0); i < (m); ++i) {
int u, v, w;
cin >> u >> v >> w;
add_edge(u, v, w), add_edge(v, u, w);
}
int now = 0;
for (int i = (0); i < (q); ++i) {
int a, b;
cin >> a >> b;
has[a].push_back(now), has[b].push_back(now + 1);
id[now++] = a, id[now++] = b;
}
for (int i = (0); i < (2 * q); ++i) ans[i] = -1;
dij();
vector<rev> es;
for (int i = 0; i < 2 * m; i += 2) {
auto e = edge[i];
int u, v;
u = e.from, v = e.to;
long long we = dis[u] + dis[v] + e.we;
es.push_back(rev(u, v, we));
}
sort((es).begin(), (es).end());
for (int i = (1); i <= (n); ++i) {
fa[i] = i, sz[i] = 1;
}
for (auto e : es) merge(e.from, e.to, e.we);
for (int i = 0; i < 2 * q; i += 2) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dist[100005];
long long int n, m, k, q, ind[100005], parent[100005], depth[100005],
maxi[100005][25], parent2[100005][25], sol[300005];
vector<pair<int, int> > v[100005];
vector<pair<int, long long int> > v2[100005];
set<pair<long long int, int> > s;
map<pair<int, int>, long long int> m1;
vector<pair<int, pair<int, int> > > e;
vector<pair<long long int, pair<int, int> > > e2;
set<int> s1[100005];
void dijkstra() {
for (int i = 0; i < n; i++) {
dist[i] = 1e18;
if (i < k) {
dist[i] = 0;
ind[i] = i;
}
s.insert(make_pair(dist[i], i));
}
while (!s.empty()) {
long long int d = (*s.begin()).first, x = (*s.begin()).second;
s.erase(s.begin());
for (int i = 0; i < v[x].size(); i++) {
if (d + v[x][i].second < dist[v[x][i].first]) {
ind[v[x][i].first] = ind[x];
s.erase(make_pair(dist[v[x][i].first], v[x][i].first));
dist[v[x][i].first] = d + v[x][i].second;
s.insert(make_pair(dist[v[x][i].first], v[x][i].first));
}
}
}
}
int find_par(int x) {
if (x == parent[x]) return x;
int par = find_par(parent[x]);
parent[x] = par;
return par;
}
void spoji(int x, int y, long long int a) {
x = find_par(x);
y = find_par(y);
if (x == y) return;
if (depth[x] == depth[y]) depth[x] += 1;
if (depth[x] > depth[y])
parent[y] = x;
else
parent[x] = y;
if (s1[x].size() > s1[y].size()) {
for (set<int>::iterator it = s1[y].begin(); it != s1[y].end(); it++) {
if (s1[x].find(*it) != s1[x].end()) sol[*it] = a;
s1[x].insert(*it);
}
s1[y].clear();
if (x != parent[y]) swap(s1[x], s1[y]);
} else {
for (set<int>::iterator it = s1[x].begin(); it != s1[x].end(); it++) {
if (s1[y].find(*it) != s1[y].end()) sol[*it] = a;
s1[y].insert(*it);
}
s1[x].clear();
if (y != parent[x]) swap(s1[x], s1[y]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
v[a - 1].push_back(make_pair(b - 1, w));
v[b - 1].push_back(make_pair(a - 1, w));
e.push_back(make_pair(w, make_pair(a - 1, b - 1)));
}
dijkstra();
for (int i = 0; i < m; i++) {
int x = e[i].second.first, y = e[i].second.second;
if (ind[x] == ind[y]) continue;
if (m1[make_pair(ind[x], ind[y])] == 0 or
dist[x] + e[i].first + dist[y] < m1[make_pair(ind[x], ind[y])]) {
m1[make_pair(ind[x], ind[y])] = dist[x] + e[i].first + dist[y];
m1[make_pair(ind[y], ind[x])] = dist[x] + e[i].first + dist[y];
}
}
for (int i = 0; i < m; i++) {
int x = e[i].second.first, y = e[i].second.second;
if (ind[x] == ind[y] or m1[make_pair(ind[x], ind[y])] == 0) continue;
e2.push_back(
make_pair(m1[make_pair(ind[x], ind[y])], make_pair(ind[x], ind[y])));
m1[make_pair(ind[x], ind[y])] = 0;
m1[make_pair(ind[y], ind[x])] = 0;
}
sort(e2.begin(), e2.end());
for (int i = 0; i < k; i++) parent[i] = i;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
s1[ind[a - 1]].insert(i);
s1[ind[b - 1]].insert(i);
}
for (int i = 0; i < e2.size(); i++) {
int x = e2[i].second.first, y = e2[i].second.second;
if (find_par(x) == find_par(y)) continue;
spoji(x, y, e2[i].first);
}
for (int i = 0; i < q; i++) {
cout << sol[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, q;
vector<pair<long long, long long>> adj[100001];
int owner[100001];
long long dst[100001];
struct edge {
long long a, b, c;
bool operator<(const edge& masik) const { return c < masik.c; }
};
vector<edge> lst;
int par[100001];
set<int> qs[100001];
long long ans[300001];
void init() {
for (int i = 1; i <= n; ++i) {
par[i] = -1;
}
}
int get(int x) {
if (par[x] == -1) return x;
return par[x] = get(par[x]);
}
void merge(int x, int y, long long w) {
int px = get(x), py = get(y);
if (px == py) return;
if (qs[px].size() > qs[py].size()) {
swap(px, py);
}
for (auto i : qs[px]) {
auto it = qs[py].find(i);
if (it != qs[py].end()) {
qs[py].erase(i);
ans[i] = w;
} else {
qs[py].insert(i);
}
}
par[px] = py;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (int i = 1; i <= k; ++i) {
owner[i] = i;
pq.push({0, i});
}
while (!pq.empty()) {
auto tp = pq.top();
pq.pop();
if (dst[tp.second] < tp.first) continue;
for (auto i : adj[tp.second]) {
if (owner[i.first] != owner[tp.second]) {
if (owner[i.first] == 0) {
dst[i.first] = i.second + tp.first;
owner[i.first] = owner[tp.second];
pq.push({dst[i.first], i.first});
} else {
if (dst[i.first] > i.second + tp.first) {
dst[i.first] = i.second + tp.first;
owner[i.first] = owner[tp.second];
pq.push({dst[i.first], i.first});
} else {
lst.push_back({owner[i.first], owner[tp.second],
dst[i.first] + dst[tp.second] + i.second});
}
}
} else {
if (dst[i.first] > i.second + tp.first) {
dst[i.first] = i.second + tp.first;
pq.push({dst[i.first], i.first});
}
}
}
}
sort(lst.begin(), lst.end());
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
qs[a].insert(i);
qs[b].insert(i);
}
init();
for (auto i : lst) {
merge(i.a, i.b, i.c);
}
for (int i = 0; i < q; ++i) {
cout << ans[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 10;
const int M = 3 * N;
long long dis[N];
int col[N];
vector<pair<int, int>> c[N];
vector<pair<long long, pair<int, int>>> edges;
vector<int> ch[M];
int par[N];
set<pair<long long, int>> curr;
long long qx[M], qy[M], ql[M], qr[M];
int dfind(int u) { return par[u] < 0 ? u : par[u] = dfind(par[u]); }
void dmerge(int u, int v) {
u = dfind(u);
v = dfind(v);
if (u == v) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
c[u].push_back({v, w});
c[v].push_back({u, w});
}
memset(dis, 63, sizeof dis);
for (int i = 0; i < k; i++) {
dis[i] = 0;
col[i] = i;
curr.insert({dis[i], i});
}
while (curr.size()) {
int s = curr.begin()->second;
curr.erase(curr.begin());
for (auto x : c[s])
if (dis[x.first] > dis[s] + x.second) {
curr.erase({dis[x.first], x.first});
dis[x.first] = dis[s] + x.second;
col[x.first] = col[s];
curr.insert({dis[x.first], x.first});
}
}
for (int x = 0; x < n; x++)
for (auto y : c[x]) {
if (x < y.first && col[x] != col[y.first])
edges.push_back(
{dis[x] + dis[y.first] + y.second, {col[x], col[y.first]}});
}
sort(edges.begin(), edges.end());
for (int i = 0; i < q; i++) {
cin >> qx[i] >> qy[i];
qx[i]--;
qy[i]--;
ql[i] = -1, qr[i] = ((int)(edges).size()) - 1;
}
for (int t = 0; t < 20; t++) {
for (int i = 0; i < q; i++)
if (qr[i] - ql[i] > 1) {
int mid = (ql[i] + qr[i]) / 2;
ch[mid].push_back(i);
}
memset(par, -1, sizeof par);
for (int i = 0; i < ((int)(edges).size()); i++) {
dmerge(edges[i].second.first, edges[i].second.second);
for (auto x : ch[i])
if (dfind(qx[x]) == dfind(qy[x]))
qr[x] = i;
else
ql[x] = i;
ch[i].clear();
}
}
for (int i = 0; i < q; i++) cout << edges[qr[i]].first << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const ms = 1e5 + 10, mlg = 30;
vector<pair<long long, long long>> g[ms];
vector<pair<long long, long long>> mst[ms];
long long d1[ms];
long long n, m, k, q;
struct edge {
long long u, v, w;
edge() {}
edge(long long u, long long v, long long w) : u(u), v(v), w(w) {}
};
vector<edge> me;
void dij() {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
hp;
for (int i = 0; i < n; i++) {
if (i < k) {
d1[i] = 0;
hp.push({0, i});
} else
d1[i] = 1e18;
}
while (hp.size()) {
long long nv = hp.top().second, dv = hp.top().first;
hp.pop();
if (d1[nv] < dv) continue;
for (auto e : g[nv]) {
long long av = e.first, wv = e.second;
if (d1[nv] + wv < d1[av]) {
d1[av] = d1[nv] + wv;
hp.push({d1[av], av});
}
}
}
}
void cong(long long a, long long b, long long w) {
g[a].push_back({b, w});
g[b].push_back({a, w});
}
void conm(long long a, long long b, long long w) {
mst[a].push_back({b, w});
mst[b].push_back({a, w});
}
long long ds[ms], sz[ms];
void mks() {
for (int i = 0; i < n; i++) ds[i] = i, sz[i] = 1;
}
long long find(long long i) {
if (ds[i] == i)
return i;
else
return ds[i] = find(ds[i]);
}
void onion(long long a, long long b) {
a = find(a), b = find(b);
if (sz[a] < sz[b]) swap(a, b);
if (a != b) sz[a] += sz[b];
ds[b] = a;
}
long long par[ms][mlg + 1], maxw[ms][mlg + 1], lvl[ms];
void dfs(long long v, long long p, long long l = 0, long long take = 0) {
lvl[v] = l;
par[v][0] = p;
maxw[v][0] = take;
for (long long kk = 1; kk <= mlg; kk++) {
par[v][kk] = par[par[v][kk - 1]][kk - 1];
maxw[v][kk] = max(maxw[v][kk - 1], maxw[par[v][kk - 1]][kk - 1]);
}
for (auto &u : mst[v]) {
if (u.first != p) dfs(u.first, v, l + 1, u.second);
}
}
long long lca(long long a, long long b) {
if (lvl[b] > lvl[a]) swap(a, b);
for (long long i = mlg; i >= 0; i--) {
if (lvl[a] - (1 << i) >= lvl[b]) a = par[a][i];
}
if (a == b) return a;
for (long long i = mlg; i >= 0; i--) {
if (par[a][i] != par[b][i]) a = par[a][i], b = par[b][i];
}
return par[a][0];
}
long long lift(long long v, long long d) {
long long ret = 0;
for (long long i = mlg; i >= 0; i--) {
if ((1 << i) <= d) ret = max(ret, maxw[v][i]), v = par[v][i], d -= (1 << i);
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n >> m >> k >> q;
long long a, b, w;
for (int i = 0; i < m; i++) {
cin >> a >> b >> w;
a--, b--;
cong(a, b, w);
}
dij();
for (int i = 0; i < n; i++) {
for (auto e : g[i]) {
me.push_back(edge(i, e.first, d1[i] + d1[e.first] + e.second));
}
}
sort(me.begin(), me.end(),
[](edge &a, edge &b) -> bool { return a.w < b.w; });
mks();
for (int i = 0; i < me.size(); i++) {
if (find(me[i].u) != find(me[i].v)) {
conm(me[i].u, me[i].v, me[i].w);
onion(me[i].u, me[i].v);
}
}
memset(maxw, 0, sizeof maxw);
dfs(0, 0);
long long q1, q2, lc;
while (q--) {
cin >> q1 >> q2;
q1--, q2--;
lc = lca(q1, q2);
cout << max(lift(q1, lvl[q1] - lvl[lc]), lift(q2, lvl[q2] - lvl[lc]))
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 100;
const int mod = (int)1e9 + 7;
const long long INF = (long long)1ll << 61;
int n, m, k, q, fa[maxn];
long long dis[maxn], ans[maxn * 6];
vector<pair<int, long long> > g[maxn * 6];
vector<pair<int, int> > que[maxn];
vector<tuple<long long, int, int> > e;
set<int> ele[maxn];
void dij() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
for (int i = (1); i <= (n); ++i) {
if (i <= k)
Q.push({0, i});
else
dis[i] = INF;
}
while (!Q.empty()) {
int u = Q.top().second, d = Q.top().first;
Q.pop();
if (d > dis[u]) continue;
for (auto [v, w] : g[u]) {
if (dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
Q.push({dis[v], v});
}
}
}
}
void init() {
for (int i = (1); i <= (n); ++i) fa[i] = i, ele[i].insert(i);
}
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = (1); i <= (m); ++i) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
g[u].push_back({v, w});
g[v].push_back({u, w});
}
dij();
for (int u = (1); u <= (n); ++u)
for (auto [v, w] : g[u])
if (u < v) e.push_back({dis[u] + dis[v] + w, u, v});
sort(e.begin(), e.end());
for (int i = (1); i <= (q); ++i) {
int u, v;
scanf("%d%d", &u, &v);
que[u].push_back({v, i});
que[v].push_back({u, i});
}
init();
for (auto [w, x, y] : e) {
x = find(x);
y = find(y);
if (x == y) continue;
if (ele[x].size() < ele[y].size()) swap(x, y);
fa[y] = x;
for (auto u : ele[y])
for (auto [v, id] : que[u])
if (ele[x].count(v)) ans[id] = w;
for (auto u : ele[y]) ele[x].insert(u);
}
for (int i = (1); i <= (q); ++i) printf("%lld\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5;
int n, m, k, q;
struct node {
int v;
int nxt;
long long w;
node() {}
node(int v, long long w) : v(v), w(w) {}
} edge[maxn * 2 + 10];
struct Node {
int u;
int v;
long long w;
Node() {}
Node(int u, int v, long long w) : u(u), v(v), w(w) {}
bool operator<(const Node &C) const { return w > C.w; }
};
int head[maxn + 10];
bool vis[maxn + 10];
vector<Node> ve[maxn + 10];
priority_queue<Node> Q, P;
int fa[maxn + 10];
int tot;
int f[maxn + 10][25];
long long dis[maxn + 10][25];
int dep[maxn + 10];
long long d[maxn + 10];
void init() {
tot = 0;
memset(vis, false, sizeof(vis));
memset(head, -1, sizeof(head));
for (int i = 0; i <= n; i++) ve[i].clear();
while (!Q.empty()) {
Q.pop();
}
while (!P.empty()) {
P.pop();
}
for (int i = 0; i <= n; i++) fa[i] = i;
memset(dis, 0, sizeof(dis));
memset(d, 0, sizeof(d));
}
int cha(int u) {
if (fa[u] != u) {
fa[u] = cha(fa[u]);
}
return fa[u];
}
void addedge(int u, int v, long long w) {
edge[tot].v = v;
edge[tot].w = w;
edge[tot].nxt = head[u];
head[u] = tot++;
edge[tot].v = u;
edge[tot].w = w;
edge[tot].nxt = head[v];
head[v] = tot++;
}
void dfs(int u, int pre) {
dep[u] = dep[pre] + 1;
f[u][0] = pre;
for (int i = 1; i <= 20; i++) {
f[u][i] = f[f[u][i - 1]][i - 1];
dis[u][i] = max(dis[f[u][i - 1]][i - 1], dis[u][i - 1]);
}
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
if (v == pre) continue;
dep[v] = dep[u] + 1;
f[v][0] = u;
dis[v][0] = edge[i].w;
dfs(v, u);
}
}
long long lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
long long ans = 0;
for (int i = 20; i >= 0; i--) {
if (dep[f[x][i]] >= dep[y]) {
ans = max(ans, dis[x][i]);
x = f[x][i];
}
if (x == y) return ans;
}
for (int i = 20; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
ans = max(ans, dis[x][i]);
ans = max(ans, dis[y][i]);
x = f[x][i];
y = f[y][i];
}
}
if (x != y) {
ans = max(ans, dis[x][0]);
ans = max(ans, dis[y][0]);
}
return ans;
}
int main() {
while (~scanf("%d%d%d%d", &n, &m, &k, &q)) {
init();
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
u--, v--;
ve[u].push_back(Node(u, v, w));
ve[v].push_back(Node(v, u, w));
}
for (int i = 0; i < k; i++) {
vis[i] = true;
d[i] = 0;
for (int j = 0; j < ve[i].size(); j++) {
Q.push(Node(ve[i][j].u, ve[i][j].v, ve[i][j].w));
}
}
while (!Q.empty()) {
Node tmp = Q.top();
Q.pop();
int uu = cha(tmp.u);
int vv = cha(tmp.v);
if (uu == vv) continue;
if (vis[tmp.v]) {
P.push(Node(tmp.u, tmp.v, tmp.w + d[tmp.v]));
continue;
}
fa[uu] = vv;
addedge(tmp.u, tmp.v, tmp.w);
vis[tmp.v] = true;
d[tmp.v] = tmp.w;
int v = tmp.v;
for (int i = 0; i < ve[v].size(); i++) {
Q.push(Node(v, ve[v][i].v, ve[v][i].w + tmp.w));
}
}
while (!P.empty()) {
Node tmp = P.top();
P.pop();
int uu = cha(tmp.u);
int vv = cha(tmp.v);
if (uu == vv) continue;
int v = tmp.v;
addedge(tmp.u, tmp.v, tmp.w);
fa[uu] = vv;
}
dfs(0, 0);
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
printf("%lld\n", lca(u, v));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
template <typename T, bool maximum_mode = false>
struct RMQ {
int n = 0, levels = 0;
vector<T> values;
vector<vector<int>> range_low;
RMQ(const vector<T> &_values = {}) {
if (!_values.empty()) build(_values);
}
static int largest_bit(int x) { return 31 - __builtin_clz(x); }
int better_index(int a, int b) const {
return (values[a] < values[b]) ^ maximum_mode ? a : b;
}
void build(const vector<T> &_values) {
values = _values;
n = values.size();
levels = largest_bit(n) + 1;
range_low.resize(levels);
for (int k = 0; k < levels; k++) range_low[k].resize(n - (1 << k) + 1);
for (int i = 0; i < n; i++) range_low[0][i] = i;
for (int k = 1; k < levels; k++)
for (int i = 0; i <= n - (1 << k); i++)
range_low[k][i] = better_index(range_low[k - 1][i],
range_low[k - 1][i + (1 << (k - 1))]);
}
int query_index(int a, int b) const {
assert(0 <= a && a < b && b <= n);
int level = largest_bit(b - a);
return better_index(range_low[level][a],
range_low[level][b - (1 << level)]);
}
T query_value(int a, int b) const { return values[query_index(a, b)]; }
};
struct edge {
int node = -1;
long long weight = 0;
edge() {}
edge(int _node, long long _weight) : node(_node), weight(_weight) {}
};
template <typename T_weight>
struct weighted_LCA {
int n = 0;
vector<vector<edge>> adj;
vector<int> parent, depth, subtree_size;
vector<T_weight> weighted_depth, up_weight;
vector<int> euler, first_occurrence;
vector<int> tour_start, tour_end, tour_list, postorder;
vector<int> heavy_root;
RMQ<int> rmq;
weighted_LCA(int _n = 0) { init(_n); }
weighted_LCA(const vector<vector<edge>> &_adj) { init(_adj); }
void init(int _n) {
n = _n;
adj.assign(n, {});
parent.resize(n);
depth.resize(n);
subtree_size.resize(n);
weighted_depth.resize(n);
up_weight.assign(n, numeric_limits<T_weight>::min());
first_occurrence.resize(n);
tour_start.resize(n);
tour_end.resize(n);
tour_list.resize(n);
postorder.resize(n);
heavy_root.resize(n);
}
void init(const vector<vector<edge>> &_adj) {
init(_adj.size());
adj = _adj;
}
void add_edge(int a, int b, T_weight weight) {
adj[a].emplace_back(b, weight);
adj[b].emplace_back(a, weight);
}
void erase_edge(int from, int to) {
for (edge &e : adj[from])
if (e.node == to) {
swap(e, adj[from].back());
adj[from].pop_back();
return;
}
assert(false);
}
void dfs(int node, int par, T_weight weight) {
parent[node] = par;
depth[node] = par < 0 ? 0 : depth[par] + 1;
subtree_size[node] = 1;
weighted_depth[node] = weight;
if (par >= 0) erase_edge(node, par);
for (edge &e : adj[node]) {
up_weight[e.node] = e.weight;
dfs(e.node, node, weight + e.weight);
subtree_size[node] += subtree_size[e.node];
}
sort(adj[node].begin(), adj[node].end(), [&](const edge &a, const edge &b) {
return subtree_size[a.node] > subtree_size[b.node];
});
}
int tour, post_tour;
void tour_dfs(int node, bool heavy) {
heavy_root[node] = heavy ? heavy_root[parent[node]] : node;
first_occurrence[node] = euler.size();
euler.push_back(node);
tour_list[tour] = node;
tour_start[node] = tour++;
bool heavy_child = true;
for (edge &e : adj[node]) {
tour_dfs(e.node, heavy_child);
euler.push_back(node);
heavy_child = false;
}
tour_end[node] = tour;
postorder[node] = post_tour++;
}
void build() {
parent.assign(n, -1);
for (int i = 0; i < n; i++)
if (parent[i] < 0) dfs(i, -1, 0);
tour = post_tour = 0;
for (int i = 0; i < n; i++)
if (parent[i] < 0) {
tour_dfs(i, false);
euler.push_back(-1);
}
assert((int)euler.size() == 2 * n);
vector<int> euler_depths;
for (int node : euler)
euler_depths.push_back(node < 0 ? node : depth[node]);
rmq.build(euler_depths);
build_path_maxes();
}
int get_lca(int a, int b) const {
a = first_occurrence[a];
b = first_occurrence[b];
if (a > b) swap(a, b);
return euler[rmq.query_index(a, b + 1)];
}
bool is_ancestor(int a, int b) const {
return tour_start[a] <= tour_start[b] && tour_start[b] < tour_end[a];
}
bool on_path(int x, int a, int b) const {
int anc = get_lca(a, b);
return is_ancestor(anc, x) && (is_ancestor(x, a) || is_ancestor(x, b));
}
int get_dist(int a, int b) const {
return depth[a] + depth[b] - 2 * depth[get_lca(a, b)];
}
T_weight get_weighted_dist(int a, int b) const {
return weighted_depth[a] + weighted_depth[b] -
2 * weighted_depth[get_lca(a, b)];
}
int child_ancestor(int a, int b) const {
assert(a != b);
assert(is_ancestor(a, b));
int child =
euler[rmq.query_index(first_occurrence[a], first_occurrence[b] + 1) +
1];
assert(is_ancestor(child, b));
return child;
}
static int largest_bit(int x) { return 31 - __builtin_clz(x); }
vector<vector<pair<int, T_weight>>> ancestor_max;
void build_path_maxes() {
ancestor_max.assign(largest_bit(n) + 1, vector<pair<int, T_weight>>(n));
for (int i = 0; i < n; i++) ancestor_max[0][i] = {parent[i], up_weight[i]};
for (int k = 0; k < largest_bit(n); k++)
for (int i = 0; i < n; i++) {
int k_anc = ancestor_max[k][i].first;
T_weight k_max = ancestor_max[k][i].second;
if (k_anc < 0)
ancestor_max[k + 1][i] = {-1, k_max};
else
ancestor_max[k + 1][i] = {ancestor_max[k][k_anc].first,
max(k_max, ancestor_max[k][k_anc].second)};
}
}
T_weight query_path_max(int a, int b) const {
int anc = get_lca(a, b);
int a_dist = depth[a] - depth[anc];
int b_dist = depth[b] - depth[anc];
T_weight path_max = numeric_limits<T_weight>::min();
for (int k = 0; 1 << k <= a_dist; k++)
if (a_dist >> k & 1) {
path_max = max(path_max, ancestor_max[k][a].second);
a = ancestor_max[k][a].first;
}
for (int k = 0; 1 << k <= b_dist; k++)
if (b_dist >> k & 1) {
path_max = max(path_max, ancestor_max[k][b].second);
b = ancestor_max[k][b].first;
}
return path_max;
}
};
struct dijkstra_state {
long long dist;
int node;
dijkstra_state() {}
dijkstra_state(long long _dist, int _node) : dist(_dist), node(_node) {}
bool operator<(const dijkstra_state &other) const {
return dist > other.dist;
}
};
int N, M, K, Q;
vector<vector<edge>> adj;
vector<long long> dist;
void dijkstra_check(priority_queue<dijkstra_state> &pq, int node,
long long current_dist) {
if (current_dist < dist[node]) {
dist[node] = current_dist;
pq.emplace(current_dist, node);
}
}
void dijkstra() {
dist.assign(N, LL_INF);
priority_queue<dijkstra_state> pq;
for (int source = 0; source < K; source++) dijkstra_check(pq, source, 0);
while (!pq.empty()) {
dijkstra_state top = pq.top();
pq.pop();
if (top.dist > dist[top.node]) continue;
for (edge &e : adj[top.node])
dijkstra_check(pq, e.node, top.dist + e.weight);
}
}
struct union_find {
vector<int> parent;
vector<int> size;
int components = 0;
union_find(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
parent.resize(n + 1);
size.assign(n + 1, 1);
components = n;
for (int i = 0; i <= n; i++) parent[i] = i;
}
int find(int x) { return x == parent[x] ? x : parent[x] = find(parent[x]); }
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (size[x] < size[y]) swap(x, y);
parent[y] = x;
size[x] += size[y];
components--;
return true;
}
};
template <typename T>
struct kruskal {
struct edge {
int a, b;
T weight;
bool in_tree = false;
edge() {}
edge(int _a, int _b, T _weight) : a(_a), b(_b), weight(_weight) {}
bool operator<(const edge &other) const { return weight < other.weight; }
};
union_find UF;
vector<edge> edges;
kruskal(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
UF.init(n);
edges = {};
}
void add_edge(int a, int b, T weight) { edges.emplace_back(a, b, weight); }
T solve() {
sort(edges.begin(), edges.end());
T total = 0;
for (edge &e : edges)
if (UF.unite(e.a, e.b)) {
total += e.weight;
e.in_tree = true;
}
return total;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> K >> Q;
adj.assign(N, {});
for (int i = 0; i < M; i++) {
int u, v, weight;
cin >> u >> v >> weight;
u--;
v--;
adj[u].emplace_back(v, weight);
adj[v].emplace_back(u, weight);
}
dijkstra();
kruskal<long long> mst(N);
for (int i = 0; i < N; i++)
for (edge &e : adj[i]) {
e.weight += dist[i] + dist[e.node];
mst.add_edge(i, e.node, e.weight);
}
mst.solve();
weighted_LCA<long long> lca(N);
for (kruskal<long long>::edge &e : mst.edges)
if (e.in_tree) lca.add_edge(e.a, e.b, e.weight);
lca.build();
for (int q = 0; q < Q; q++) {
int a, b;
cin >> a >> b;
a--;
b--;
cout << max(lca.query_path_max(a, b), 0LL) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct state {
long long len;
int node;
const bool operator<(const state oth) const { return len > oth.len; }
};
struct edge {
int a, b;
long long c;
} e[400005];
int n, m, k, q;
int dad[400005], up[20][400005], dep[400005];
long long mx[20][400005], d[400005];
vector<int> v[400005];
int find(int x) {
if (x == dad[x]) return x;
return dad[x] = find(dad[x]);
}
void merge(int x, int y) { dad[dad[x]] = dad[y]; }
void dfs(int node, int u) {
dep[node] = dep[u] + 1;
for (int i = 1; i < 20; i++) {
mx[i][node] = max(mx[i - 1][node], mx[i - 1][up[i - 1][node]]);
up[i][node] = up[i - 1][up[i - 1][node]];
}
for (int ed : v[node]) {
int go = e[ed].a ^ e[ed].b ^ node;
if (go == u) continue;
mx[0][go] = e[ed].c;
up[0][go] = node;
dfs(go, node);
}
}
long long query(int a, int b) {
long long ans = -1;
if (dep[a] > dep[b]) swap(a, b);
for (int i = 20 - 1; i >= 0; i--) {
if (dep[b] - (1 << i) >= dep[a]) {
ans = max(ans, mx[i][b]);
b = up[i][b];
}
}
if (a == b) return ans;
for (int i = 20 - 1; i >= 0; i--) {
if (up[i][a] != up[i][b]) {
ans = max(ans, max(mx[i][a], mx[i][b]));
a = up[i][a];
b = up[i][b];
}
}
ans = max(ans, max(mx[0][a], mx[0][b]));
return ans;
}
void build_tree() {
for (int i = 1; i <= n; i++) {
dad[i] = i;
v[i].clear();
}
for (int i = 1; i <= m; i++) {
e[i].c = d[e[i].a] + d[e[i].b] + e[i].c;
}
sort(e + 1, e + 1 + m, [](edge a, edge b) { return a.c < b.c; });
for (int i = 1; i <= m; i++) {
if (find(e[i].a) != find(e[i].b)) {
merge(e[i].a, e[i].b);
v[e[i].a].push_back(i);
v[e[i].b].push_back(i);
}
}
dfs(1, up[0][1]);
}
void msp() {
memset(d, -1, sizeof(d));
priority_queue<state> Q;
for (int i = 1; i <= k; i++) Q.push({0, i});
while (!Q.empty()) {
state cur = Q.top();
Q.pop();
if (~d[cur.node]) continue;
d[cur.node] = cur.len;
for (int ed : v[cur.node]) {
int go = e[ed].a ^ e[ed].b ^ cur.node;
Q.push({cur.len + e[ed].c, go});
}
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &k, &q);
for (int i = 1; i <= m; i++) {
scanf("%d %d %lld", &e[i].a, &e[i].b, &e[i].c);
v[e[i].a].push_back(i);
v[e[i].b].push_back(i);
}
msp();
build_tree();
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
printf("%lld\n", query(x, y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, long long>;
using LL = long long;
const int Maxn = 1e5 + 20, Maxm = (3e5 + 20) * 3;
const LL inf = 0x3f3f3f3f;
struct edge {
int next, from, to;
LL cost;
bool operator<(const edge& val) const { return cost < val.cost; }
} es[Maxm];
int head[Maxn], cnt;
void addedge(int u, int v, LL w) {
es[cnt].next = head[u];
es[cnt].from = u;
es[cnt].to = v;
es[cnt].cost = w;
head[u] = cnt++;
}
int n, m, k, q;
int last[Maxn];
LL dis[Maxn];
void dijkstra() {
memset(dis, inf, sizeof(dis));
priority_queue<P, vector<P>, greater<P>> que;
for (int i = 1; i <= k; ++i) {
dis[i] = 0;
last[i] = i;
que.push(P(0, i));
}
while (!que.empty()) {
P tmp = que.top();
que.pop();
int u = tmp.second;
if (dis[u] < tmp.first) continue;
for (int i = head[u]; ~i; i = es[i].next) {
int v = es[i].to;
LL w = es[i].cost;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
last[v] = last[u];
que.push(P(dis[v], v));
}
}
}
for (int i = 0; i < cnt; ++i) {
es[i].cost += dis[es[i].from] + dis[es[i].to];
es[i].from = last[es[i].from];
es[i].to = last[es[i].to];
}
}
int Par[Maxn], Rank[Maxn];
int Find(int x) {
if (Par[x] == -1) return x;
return Par[x] = Find(Par[x]);
}
void Unite(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return;
if (Rank[x] < Rank[y]) {
Par[x] = y;
} else {
Par[y] = x;
if (Rank[x] == Rank[y]) Rank[x]++;
}
}
bool isSame(int x, int y) {
if (Find(x) == Find(y)) return true;
return false;
}
vector<P> vs[Maxn];
void Kruskal() {
sort(es, es + cnt);
int u, v;
for (int i = 0; i < cnt; ++i) {
int u = es[i].from, v = es[i].to;
LL w = es[i].cost;
if (!isSame(u, v)) {
Unite(u, v);
vs[u].push_back(P(v, w));
vs[v].push_back(P(u, w));
}
}
}
int anc[Maxn][21], dep[Maxn];
LL cost[Maxn][21];
void preLCA(int u = 1, int fa = 0) {
for (int i = 1; (1 << i) <= dep[u]; ++i) {
anc[u][i] = anc[anc[u][i - 1]][i - 1];
cost[u][i] = max(cost[u][i - 1], cost[anc[u][i - 1]][i - 1]);
}
for (auto tmp : vs[u]) {
int v = tmp.first;
if (v == fa) continue;
dep[v] = dep[u] + 1;
anc[v][0] = u;
cost[v][0] = tmp.second;
preLCA(v, u);
}
}
int LCA(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
for (int i = 20; i >= 0; --i) {
if (dep[a] <= dep[b] - (1 << i)) b = anc[b][i];
}
if (a == b) return a;
for (int i = 20; i >= 0; --i) {
if (anc[a][i] == anc[b][i])
continue;
else
a = anc[a][i], b = anc[b][i];
}
return anc[b][0];
}
LL getMax(int u, int sta) {
LL res = 0;
for (int i = 0; i <= 20; ++i) {
if (sta & (1 << i)) res = max(res, cost[u][i]), u = anc[u][i];
}
return res;
}
void init() {
cnt = 0;
memset(head, -1, sizeof(head));
memset(Par, -1, sizeof(Par));
memset(Rank, 0, sizeof(Rank));
memset(anc, 0, sizeof(anc));
}
int main() {
init();
scanf("%d%d%d%d", &n, &m, &k, &q);
int u, v;
LL w;
for (int i = 0; i < m; ++i) {
scanf("%d%d%lld", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
dijkstra();
Kruskal();
preLCA();
int x, y;
int lca;
while (q--) {
scanf("%d%d", &x, &y);
lca = LCA(x, y);
printf("%lld\n",
max(getMax(x, dep[x] - dep[lca]), getMax(y, dep[y] - dep[lca])));
}
return 0;
}
|
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[10000100];
long long inv[10000010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
struct unionfind {
private:
public:
vector<long long> par, ranks, kosuu;
void shoki(long long N) {
par.resize(N + 1, 0);
ranks.resize(N + 1, 0);
kosuu.resize(N + 1, 1);
for (long long i = 0; i <= N; i++) {
par[i] = i;
}
}
long long root(long long x) {
return par[x] == x ? x : par[x] = root(par[x]);
}
bool same(long long x, long long y) { return root(x) == root(y); }
bool is_root(long long x) { return x == root(x); }
void unite(long long x, long long y) {
x = root(x);
y = root(y);
long long xx = kosuu[x], yy = kosuu[y];
if (x == y) return;
if (ranks[x] < ranks[y]) {
par[x] = y;
kosuu[y] = yy + xx;
} else {
par[y] = x;
if (ranks[x] == ranks[y]) ranks[x] = ranks[x] + 1;
kosuu[x] = yy + xx;
}
return;
}
};
vector<pair<long long, long long>> G[100020];
long long d[100020];
vector<pair<long long, long long>> T[100020];
vector<pair<long long, long long>> T2[100020];
long long depth[100020];
long long dp[100020][20] = {};
long long oya[100020][20];
void dfs(long long r, long long p, long long dep) {
depth[r] = dep;
for (auto v : T[r])
if (v.first != p) {
oya[v.first][0] = r;
dp[v.first][0] = v.second;
dfs(v.first, r, dep + 1);
}
}
long long lca(long long a, long long b) {
if (depth[a] < depth[b]) swap(a, b);
long long sa = depth[a] - depth[b];
for (long long i = 0; i < 20; i++)
if (sa & (1 << i)) a = oya[a][i];
if (a == b) return a;
for (long long i = 19; i >= 0; i--) {
if (oya[a][i] != oya[b][i]) {
a = oya[a][i];
b = oya[b][i];
}
}
return oya[a][0];
}
long long kyo(long long a, long long d) {
long long ans = -1000000007;
for (long long i = 19; i >= 0; i--)
if (d & (1 << i)) {
ans = max(ans, dp[a][i]);
a = oya[a][i];
}
return ans;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
unionfind uf;
uf.shoki(100020);
long long n, m, k, q;
cin >> n >> m >> k >> q;
for (long long i = 0; i < m; i++) {
long long y, yy, yyy;
cin >> y >> yy >> yyy;
G[y].push_back(make_pair(yy, yyy));
G[yy].push_back(make_pair(y, yyy));
}
for (long long i = 1; i <= n; i++) d[i] = 1000000007 * 10000000ll;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (long long i = 1; i <= k; i++) pq.push(make_pair(0, i));
while (pq.size()) {
pair<long long, long long> z = pq.top();
pq.pop();
if (d[z.second] != 1000000007 * 10000000ll) continue;
d[z.second] = z.first;
for (auto v : G[z.second]) pq.push(make_pair(z.first + v.second, v.first));
}
for (long long i = 1; i <= n; i++) {
for (auto &v : G[i]) v.second += d[i] + d[v.first];
}
vector<pa3> eda;
for (long long i = 1; i <= n; i++)
for (auto v : G[i])
if (i < v.first) {
eda.push_back({v.second, i, v.first});
}
sort(eda.begin(), eda.end());
for (auto v : eda) {
if (uf.same(v.y, v.z)) continue;
uf.unite(v.y, v.z);
T[v.y].push_back(make_pair(v.z, v.x));
T[v.z].push_back(make_pair(v.y, v.x));
}
oya[1][0] = 1;
dfs(1, 1, 1);
for (long long i = 1; i < 20; i++)
for (long long j = 1; j <= n; j++) {
oya[j][i] = oya[oya[j][i - 1]][i - 1];
dp[j][i] = max(dp[j][i - 1], dp[oya[j][i - 1]][i - 1]);
}
for (long long eR = 0; eR < q; eR++) {
long long a, b;
cin >> a >> b;
long long l = lca(a, b);
long long e = -1000000007;
if (a != l) e = max(e, kyo(a, depth[a] - depth[l]));
if (b != l) e = max(e, kyo(b, depth[b] - depth[l]));
cout << e << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto i = begin(v); i != end(v); i++) is >> *i;
return is;
}
int n, m, k, q;
vector<pair<int, int>> edg[101000];
vector<long long> best_dists(101000, 10000000000000000LL);
set<int> markers[101000];
int dsu[101000];
int drank[101000];
vector<long long> ans(301000, 10000000000000000LL);
struct Edg {
int u, v;
long long w;
};
int dsu_find(int a) {
if (dsu[a] == a) return a;
return dsu[a] = dsu_find(dsu[a]);
}
void dsu_union(int a, int b, long long curr_ans) {
a = dsu_find(a);
b = dsu_find(b);
if (a == b) return;
if (markers[a].size() < markers[b].size()) swap(a, b);
dsu[b] = a;
for (int x : markers[b]) {
if (markers[a].find(x) != markers[a].end()) {
ans[x] = curr_ans;
} else {
markers[a].insert(x);
}
}
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cout.tie(NULL);
scanf("%d %d %d %d", &n, &m, &k, &q);
vector<Edg> edges;
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
u--, v--;
edg[u].push_back({v, w});
edg[v].push_back({u, w});
edges.push_back(Edg{u, v, w});
}
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
std::greater<pair<long long, int>>>
ss;
for (int i = 0; i < k; i++) {
ss.push({0, i});
best_dists[i] = 0;
}
while (ss.size() > 0) {
auto curr = ss.top();
ss.pop();
if (curr.first != best_dists[curr.second]) continue;
for (auto x : edg[curr.second]) {
long long new_dist = curr.first + x.second;
if (new_dist < best_dists[x.first]) {
best_dists[x.first] = new_dist;
ss.push({best_dists[x.first], x.first});
}
}
}
for (int i = 0; i < m; i++) {
edges[i].w += best_dists[edges[i].u] + best_dists[edges[i].v];
}
sort(edges.begin(), edges.end(), [&](Edg& x, Edg& y) { return x.w < y.w; });
vector<pair<int, int>> qs(q);
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
qs[i] = {a, b};
markers[a].insert(i);
markers[b].insert(i);
}
for (int i = 0; i < n; i++) {
dsu[i] = i;
drank[i] = 1;
}
for (int i = 0; i < m; i++) {
dsu_union(edges[i].u, edges[i].v, edges[i].w);
}
for (int i = 0; i < q; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
constexpr int maxn = 1e5 + 10;
constexpr int maxd = 20;
vector<pair<int, long long>> G[maxn], G2[maxn];
long long dist[maxn];
int from[maxn];
bool vis[maxn];
int anc[maxn][maxd], dep[maxn], par[maxn];
long long fx[maxn][maxd];
int n, m, k, q;
struct edge {
int u, v;
long long w;
bool operator<(const edge &rhs) const { return w < rhs.w; }
};
vector<edge> es;
void dijkstra() {
memset(dist, 0x3f, sizeof(dist));
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int s = 1; s <= k; s++) {
pq.push(make_pair(0, s));
from[s] = s;
dist[s] = 0;
}
while (!pq.empty()) {
long long dis = pq.top().first;
int u = pq.top().second;
vis[u] = 1;
pq.pop();
if (dis != dist[u]) continue;
for (auto p : G[u]) {
int v = p.first, w = p.second;
if (vis[v] && from[v] != from[u]) {
es.push_back({from[u], from[v], dist[u] + dist[v] + w});
}
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
from[v] = from[u];
pq.push(make_pair(dist[v], v));
}
}
}
}
void dfs(int u, int f) {
dep[u] = dep[f] + 1;
anc[u][0] = f;
for (auto p : G2[u]) {
if (p.first == f) continue;
fx[p.first][0] = p.second;
dfs(p.first, u);
}
}
void init_lca() {
for (int j = 1; j < maxd; j++) {
for (int i = 1; i <= k; i++) {
anc[i][j] = anc[anc[i][j - 1]][j - 1];
fx[i][j] = max(fx[i][j - 1], fx[anc[i][j - 1]][j - 1]);
}
}
}
long long query(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
long long ans = 0;
for (int i = maxd - 1; i >= 0; i--) {
if (dep[anc[u][i]] >= dep[v]) {
ans = max(ans, fx[u][i]);
u = anc[u][i];
}
}
if (u == v) return ans;
for (int i = maxd - 1; i >= 0; i--) {
if (anc[u][i] != anc[v][i]) {
ans = max(ans, max(fx[u][i], fx[v][i]));
u = anc[u][i], v = anc[v][i];
}
}
ans = max(ans, max(fx[u][0], fx[v][0]));
return ans;
}
int find(int x) { return par[x] == x ? par[x] : par[x] = find(par[x]); }
bool unite(int u, int v) {
u = find(u), v = find(v);
if (u != v) {
par[u] = v;
return 1;
} else
return 0;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
dijkstra();
sort(es.begin(), es.end());
for (int i = 1; i <= k; i++) {
par[i] = i;
}
for (auto e : es) {
if (unite(e.u, e.v)) {
G2[e.u].push_back(make_pair(e.v, e.w));
G2[e.v].push_back(make_pair(e.u, e.w));
}
}
dfs(1, 0);
init_lca();
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d%d", &u, &v);
long long ans = query(u, v);
printf("%lld\n", ans);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.