text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long INF = 1e18;
template <class t1, class t2>
bool cmin(t1 &a, const t2 &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class t1, class t2>
bool cmax(t1 &a, const t2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void UseFiles(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
void run();
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
run();
}
struct dsu {
vector<long long> l, h;
dsu(long long n) : l(n), h(n, 1) { iota(l.begin(), l.end(), 0); }
long long get_root(long long v) {
if (l[v] == v) {
return v;
}
return l[v] = get_root(l[v]);
}
bool Union(long long u, long long v) {
u = get_root(u);
v = get_root(v);
if (u == v) {
return false;
}
if (h[u] > h[v]) {
swap(u, v);
}
l[u] = v;
if (h[u] == h[v]) {
++h[v];
}
return true;
}
};
long long n;
vector<vector<pair<long long, long long>>> g;
vector<long long> color, dst;
vector<tuple<long long, long long, long long>> dijkstra(long long k) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
for (long long i = 0; i < k; ++i) {
color[i] = i;
dst[i] = 0;
q.push({0, i});
}
while (((long long)(q).size())) {
auto [d, v] = q.top();
q.pop();
if (dst[v] != d) {
continue;
}
for (auto &[u, w] : g[v]) {
if (cmin(dst[u], d + w)) {
color[u] = color[v];
q.push({dst[u], u});
}
}
}
map<pair<long long, long long>, long long> m;
for (long long i = 0; i < n; ++i) {
for (auto &[v, w] : g[i]) {
if (color[v] > color[i]) {
if (m.count({color[i], color[v]})) {
cmin(m[{color[i], color[v]}], dst[i] + dst[v] + w);
} else {
m[{color[i], color[v]}] = dst[i] + dst[v] + w;
}
}
}
}
vector<tuple<long long, long long, long long>> edges;
for (auto &[x, y] : m) {
edges.push_back({y, x.first, x.second});
}
sort(edges.begin(), edges.end());
return edges;
}
const long long maxlg = 20;
vector<vector<pair<long long, long long>>> tree;
vector<vector<long long>> up, mup;
vector<long long> d;
void dfs(long long v, long long p = -1, long long pw = 0, long long cur_d = 0) {
d[v] = cur_d;
mup[v][0] = pw;
up[v][0] = p;
if (p == -1) {
up[v][0] = v;
}
for (long long i = 1; i < maxlg; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
mup[v][i] = max(mup[v][i - 1], mup[up[v][i - 1]][i - 1]);
}
for (auto &[u, w] : tree[v]) {
if (u == p) {
continue;
}
dfs(u, v, w, cur_d + 1);
}
}
long long lca(long long u, long long v) {
if (d[u] < d[v]) {
swap(u, v);
}
long long ans = 0;
for (long long i = maxlg - 1; i >= 0; --i) {
if (d[up[u][i]] >= d[v]) {
cmax(ans, mup[u][i]);
u = up[u][i];
}
}
if (u == v) {
return ans;
}
for (long long i = maxlg - 1; i >= 0; --i) {
if (up[u][i] != up[v][i]) {
cmax(ans, mup[u][i]);
cmax(ans, mup[v][i]);
u = up[u][i];
v = up[v][i];
}
}
cmax(ans, mup[v][0]);
cmax(ans, mup[u][0]);
return ans;
}
void run() {
long long m, k, q;
cin >> n >> m >> k >> q;
g.resize(n);
color.resize(n, -1);
dst.resize(n, INF);
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
--u, --v;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
vector<tuple<long long, long long, long long>> edges = dijkstra(k);
tree.resize(k);
up.resize(k, vector<long long>(maxlg, -1));
mup.resize(k, vector<long long>(maxlg, -1));
d.resize(k, -1);
dsu D(k);
for (auto &[w, u, v] : edges) {
if (D.Union(u, v)) {
tree[u].push_back({v, w});
tree[v].push_back({u, w});
}
}
dfs(0);
for (long long i = 0; i < q; ++i) {
long long u, v;
cin >> u >> v;
--u, --v;
cout << lca(u, v) << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, k, q, z, dist[100020], ans[300005], p[100005],
src[100020];
vector<pair<long long, long long>> adj[100005];
set<long long> s[100020];
vector<pair<long long, pair<long long, long long>>> edges;
void dijkstra() {
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;
for (int i = 1; i <= k; ++i) pq.push({0, {i, i}});
for (int i = 1; i <= n; ++i) dist[i] = 1e16;
while (pq.size()) {
int u = pq.top().second.first, sorc = pq.top().second.second;
long long w = pq.top().first;
pq.pop();
if (dist[u] < w) continue;
dist[u] = w, src[u] = sorc;
for (auto i : adj[u]) {
if (dist[u] + i.second >= dist[i.first]) continue;
pq.push({dist[u] + i.second, {i.first, sorc}});
}
}
}
int fnd(int i) {
if (p[i] == i) return i;
return p[i] = fnd(p[i]);
}
void uni(int i, int j, long long w) {
i = fnd(i), j = fnd(j);
if (i == j) return;
;
if (s[i].size() > s[j].size()) swap(i, j);
p[i] = j;
for (auto u : s[i]) {
if (s[j].count(u))
s[j].erase(u), ans[u] = w;
else
s[j].insert(u);
}
s[i].clear();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k >> q;
for (int i = 0; i < m; ++i)
cin >> x >> y >> z, adj[x].push_back({y, z}), adj[y].push_back({x, z});
dijkstra();
for (int i = 1; i <= n; p[i] = i, ++i)
for (auto j : adj[i])
if (src[i] != src[j.first])
edges.push_back(
{dist[i] + dist[j.first] + j.second, {src[i], src[j.first]}});
for (int i = 0; i < q; ++i) cin >> x >> y, s[x].insert(i), s[y].insert(i);
sort(edges.begin(), edges.end());
for (auto i : edges) uni(i.second.first, i.second.second, i.first);
for (int i = 0; i < q; ++i) cout << ans[i] << endl;
}
|
#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];
tmp.clear();
for (int j = 0; j < (int)qr[u].size(); j++) {
if (mp[x][qr[u][j].first])
rs[qr[u][j].second] = w;
else
tmp.push_back(qr[u][j]);
}
qr[u] = tmp;
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>
using namespace std;
const int N = 100005;
int n, m, k, Q, used[N], p[N];
vector<int> s[N];
long long d[N], ans[N * 3];
vector<pair<int, long long>> g[N];
map<pair<int, int>, vector<int>> ind;
vector<int> query[N];
priority_queue<pair<long long, int>> q;
vector<pair<long long, pair<int, int>>> add;
void dsu(int a, int b, long long x) {
a = p[a];
b = p[b];
if (a == b) return;
if (s[a].size() < s[b].size()) swap(a, b);
while (!s[b].empty()) {
p[s[b].back()] = a;
s[a].push_back(s[b].back());
for (int i = 0; i < query[s[b].back()].size(); i++) {
int to = query[s[b].back()][i];
if (p[to] == a) {
vector<int> &c = ind[make_pair(s[b].back(), to)];
while (!c.empty()) {
if (ans[c.back()] == 0) ans[c.back()] = x;
c.pop_back();
}
}
}
s[b].pop_back();
}
}
int main() {
cin >> n >> m >> k >> Q;
while (m--) {
int a, b;
long long w;
scanf("%d%d%lld", &a, &b, &w);
g[a].push_back(make_pair(b, w));
g[b].push_back(make_pair(a, w));
}
for (int i = 1; i <= Q; i++) {
int a, b;
scanf("%d%d", &a, &b);
query[a].push_back(b);
query[b].push_back(a);
ind[make_pair(a, b)].push_back(i);
ind[make_pair(b, a)].push_back(i);
}
for (int i = 1; i <= n; i++) d[i] = 1000000007ll * 1000000007ll;
for (int i = 1; i <= k; i++) {
d[i] = 0;
q.push(make_pair(-d[i], i));
}
while (!q.empty()) {
int v = -1;
do {
v = q.top().second;
q.pop();
} while (used[v] && !q.empty());
if (used[v] || v == -1) break;
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
long long w = g[v][i].second;
if (d[v] + w < d[to]) {
d[to] = d[v] + w;
q.push(make_pair(-d[to], to));
}
}
}
for (int v = 1; v <= n; v++) {
p[v] = v;
s[v].push_back(v);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
long long w = g[v][i].second;
if (to > v) add.push_back(make_pair(w + d[v] + d[to], make_pair(to, v)));
}
}
sort(add.begin(), add.end());
for (int i = 0; i < add.size(); i++)
dsu(add[i].second.first, add[i].second.second, add[i].first);
for (int i = 1; i <= Q; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const long long INF = 1e18;
struct Edge {
int u, v, nxt;
long long w;
} edge[maxn << 1], n_edge[maxn << 1];
int fa[maxn][30];
long long mcost[maxn][30];
int depth[maxn];
struct EdgeInfo {
int u, v;
long long w;
bool operator<(const EdgeInfo &rhs) const { return w < rhs.w; }
} ee[maxn], new_e[maxn];
int n, m, k, q;
int head[maxn], nhead[maxn], cnt = -1, ncnt = -1, new_e_info_cnt;
bool vis[maxn];
long long dis[maxn];
int belong[maxn], lg[maxn];
inline void init() {
for (int i = 0; i <= n; ++i) {
head[i] = nhead[i] = -1;
vis[i] = false;
belong[i] = -1;
}
for (int i = 1; i < maxn; ++i) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
}
inline void addedge(int u, int v, long long w) {
edge[++cnt] = {u, v, head[u], w};
head[u] = cnt;
}
inline void addn_edge(int u, int v, long long w) {
n_edge[++ncnt] = {u, v, nhead[u], w};
nhead[u] = ncnt;
}
struct DSU {
int pre[maxn];
DSU() {
for (int i = 0; i < maxn; ++i) pre[i] = i;
}
int Findpre(int x) { return x == pre[x] ? x : pre[x] = Findpre(pre[x]); }
bool Union(int x, int y) {
int fx = Findpre(x);
int fy = Findpre(y);
if (fx != fy) {
pre[fy] = fx;
return true;
}
return false;
}
};
inline void Dijiastra() {
struct Node {
int u;
long long dis;
int from_p;
bool operator<(const Node &rhs) const { return dis > rhs.dis; }
};
priority_queue<Node> pq;
for (int i = 0; i <= n; ++i) {
dis[i] = INF;
vis[i] = false;
belong[i] = i;
if (i <= k && i >= 1) {
dis[i] = 0;
pq.push(Node{i, dis[i], i});
}
}
while (!pq.empty()) {
Node u = pq.top();
pq.pop();
if (vis[u.u]) continue;
vis[u.u] = true;
for (int i = head[u.u]; ~i; i = edge[i].nxt) {
Edge &e = edge[i];
if (dis[e.v] > dis[u.u] + e.w) {
dis[e.v] = dis[u.u] + e.w;
belong[e.v] = u.from_p;
pq.push(Node{e.v, dis[e.v], u.from_p});
}
}
}
}
void dfs(int u, int f) {
fa[u][0] = f;
depth[u] = depth[f] + 1;
for (int i = 1; (1 << i) <= depth[u]; ++i) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
mcost[u][i] = max(mcost[u][i - 1], mcost[fa[u][i - 1]][i - 1]);
}
for (int i = nhead[u]; ~i; i = n_edge[i].nxt) {
Edge &e = n_edge[i];
if (e.v != f) {
mcost[e.v][0] = e.w;
dfs(e.v, u);
}
}
}
long long LCA(int x, int y) {
long long ans = 0;
if (depth[x] < depth[y]) swap(x, y);
while (depth[x] > depth[y]) {
ans = max(ans, mcost[x][lg[depth[x] - depth[y]] - 1]);
x = fa[x][lg[depth[x] - depth[y]] - 1];
}
if (x == y) return ans;
for (int i = lg[depth[x]] - 1; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) {
ans = max(ans, max(mcost[x][i], mcost[y][i]));
x = fa[x][i];
y = fa[y][i];
}
}
return ans = max(ans, max(mcost[x][0], mcost[y][0]));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
init();
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
ee[i] = {u, v, w};
addedge(u, v, w);
addedge(v, u, w);
}
Dijiastra();
for (int i = 0; i < m; ++i) {
EdgeInfo &e = ee[i];
if (belong[e.u] != belong[e.v]) {
new_e[new_e_info_cnt++] = {belong[e.u], belong[e.v],
dis[e.u] + dis[e.v] + e.w};
}
}
sort(new_e, new_e + new_e_info_cnt);
DSU dsu;
int pp = 0;
for (int i = 0; i < new_e_info_cnt; ++i) {
EdgeInfo &e = new_e[i];
int fu = dsu.Findpre(e.u);
int fv = dsu.Findpre(e.v);
if (fu != fv) {
addn_edge(e.u, e.v, e.w);
addn_edge(e.v, e.u, e.w);
dsu.Union(e.u, e.v);
++pp;
}
if (pp == k - 1) break;
}
dfs(1, 0);
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
cout << LCA(a, b) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e16;
const int maxn = 1e5 + 10;
const int maxm = 3e5 + 10;
const int L = 18;
int n, m, k, q;
vector<pair<int, long long> > e[maxn];
struct Edge {
int u, v;
long long w;
Edge(int _u = 0, int _v = 0, long long _w = 0) {
u = _u;
v = _v;
w = _w;
}
bool operator<(const Edge &other) const { return w < other.w; }
} edge[maxm];
long long dis[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
bool vis[maxn];
int fa[maxn], sz[maxn], dep[maxn], f[maxn][L];
long long g[maxn][L];
inline int read() {
int x = 0, f = 1, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch - '0');
ch = getchar();
}
return f == 1 ? x : -x;
}
void print(int a[], int n, int st = 0) {
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", a[i + st]);
}
printf("\n");
}
void init() {
n = read();
m = read();
k = read();
q = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read(), w = read();
e[u].push_back(make_pair(v, w));
e[v].push_back(make_pair(u, w));
}
}
inline void dijkstra() {
for (int i = 1; i <= k; i++) dis[i] = 0, pq.push(make_pair(0, i));
for (int i = k + 1; i <= n; i++) dis[i] = inf;
while (!pq.empty()) {
int u = pq.top().second;
long long d = pq.top().first;
pq.pop();
if (vis[u]) continue;
vis[u] = true;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
long long w = e[u][i].second;
if (d + w < dis[v]) {
dis[v] = d + w;
pq.push(make_pair(dis[v], v));
}
}
}
}
inline int root(int x) { return x == fa[x] ? x : fa[x] = root(fa[x]); }
inline void merge(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
fa[x] = y;
}
}
inline void dfs(int u, int pa) {
fa[u] = f[u][0] = pa;
dep[u] = dep[pa] + 1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
long long w = e[u][i].second;
if (v == pa) continue;
dfs(v, u);
g[v][0] = w;
}
}
inline int getlca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int diff = dep[u] - dep[v], i = 0; i < L; i++)
if ((diff >> i) & 1) u = f[u][i];
if (u == v) return u;
for (int i = L - 1; i >= 0; i--)
if (f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
inline long long lift(int u, int len) {
if (len <= 0) return 0;
long long ret = 0;
for (int i = 0; i < L; i++)
if ((len >> i) & 1) ret = max(ret, g[u][i]), u = f[u][i];
return ret;
}
void doit() {
dijkstra();
m = 0;
for (int u = 1; u <= n; u++)
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
if (v < u) continue;
edge[++m] = Edge(u, v, dis[u] + dis[v] + e[u][i].second);
}
sort(edge + 1, edge + m + 1);
for (int i = 1; i <= n; i++) e[i].clear();
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1;
for (int i = 1; i <= m; i++)
if (root(edge[i].u) != root(edge[i].v)) {
merge(edge[i].u, edge[i].v);
e[edge[i].u].push_back(make_pair(edge[i].v, edge[i].w));
e[edge[i].v].push_back(make_pair(edge[i].u, edge[i].w));
}
dfs(1, 0);
for (int j = 1; j < L; j++)
for (int i = 1; i <= n; i++)
f[i][j] = f[f[i][j - 1]][j - 1],
g[i][j] = max(g[i][j - 1], g[f[i][j - 1]][j - 1]);
while (q--) {
int x = read(), y = read(), lca = getlca(x, y);
long long ans = max(lift(x, dep[x] - dep[lca]), lift(y, dep[y] - dep[lca]));
printf("%lld\n", ans);
}
}
int main() {
init();
doit();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
long long w;
} e[300010];
struct Query {
int a, b;
long long ans;
Query() { ans = -1; }
} q[300010];
struct data {
int u;
long long s;
data(){};
data(int a, long long b) { u = a, s = b; }
bool operator<(const data &a) const { return s > a.s; }
};
int n, m, k, Q;
int fa[100010];
int cnt, head[100010], nxt[300010 << 1], to[300010 << 1], w[300010 << 1];
long long dis[100010];
vector<int> g[100010];
priority_queue<data> que;
void adde(int u, int v, int wi) {
to[++cnt] = v;
w[cnt] = wi;
nxt[cnt] = head[u];
head[u] = cnt;
}
void dijkstra() {
memset(dis, 127, sizeof(dis));
for (int i = 1; i <= k; i++) que.push(data(i, 0)), dis[i] = 0;
while (!que.empty()) {
data now = que.top();
que.pop();
for (int i = head[now.u]; i; i = nxt[i]) {
int v = to[i];
if (dis[now.u] + w[i] <= dis[v]) {
dis[v] = dis[now.u] + w[i];
que.push(data(v, dis[v]));
}
}
}
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
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++) {
scanf("%d%d%lld", &e[i].u, &e[i].v, &e[i].w);
adde(e[i].u, e[i].v, e[i].w), adde(e[i].v, e[i].u, e[i].w);
}
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &q[i].a, &q[i].b);
g[q[i].a].push_back(i), g[q[i].b].push_back(i);
}
dijkstra();
for (int i = 1; i <= m; i++) e[i].w = e[i].w + dis[e[i].u] + dis[e[i].v];
sort(e + 1, e + m + 1, cmp);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int a = find(e[i].u), b = find(e[i].v);
if (a != b) {
if (g[b].size() < g[a].size()) swap(a, b);
fa[a] = b;
for (int j = 0, size = g[a].size(); j < size; j++) {
int x = find(q[g[a][j]].a), y = find(q[g[a][j]].b);
if (x == y) {
if (q[g[a][j]].ans == -1) q[g[a][j]].ans = e[i].w;
} else
g[b].push_back(g[a][j]);
}
}
}
for (int i = 1; i <= Q; i++) printf("%lld\n", q[i].ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const long long INF = 0x3f3f3f3f3f3f;
struct Edge {
int from, to;
long long cost;
Edge(int u, int v, long long cost) : from(u), to(v), cost(cost) {}
};
vector<int> G[maxn];
vector<Edge> edges;
void add_edges(int u, int v, long long cost) {
edges.push_back(Edge(u, v, cost));
edges.push_back(Edge(v, u, cost));
int sz = edges.size();
G[u].push_back(sz - 2);
G[v].push_back(sz - 1);
}
int vis[maxn];
long long dis[maxn];
int belong[maxn];
int n, m, k, q;
struct HeapNode {
int u;
long long d;
HeapNode(int _u, long long _d) : u(_u), d(_d) {}
bool operator<(const HeapNode &rhs) const { return d > rhs.d; }
};
void Dijkstra() {
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= n; i++) {
dis[i] = INF;
}
priority_queue<HeapNode> Q;
for (int i = 1; i <= k; i++) {
Q.push(HeapNode(i, 0));
dis[i] = 0;
belong[i] = i;
}
while (Q.size()) {
HeapNode x = Q.top();
Q.pop();
int u = x.u;
if (vis[u]) continue;
vis[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
Edge &e = edges[G[u][i]];
if (dis[e.to] > dis[u] + e.cost) {
dis[e.to] = dis[u] + e.cost;
belong[e.to] = belong[u];
Q.push(HeapNode(e.to, dis[e.to]));
}
}
}
}
namespace MST {
vector<int> g[maxn];
vector<Edge> E;
const int POW = 20;
long long dis[maxn][POW + 2];
int fa[maxn][POW + 2];
int dep[maxn];
void add_edges(int u, int v, long long cost) {
E.push_back(Edge(u, v, cost));
E.push_back(Edge(v, u, cost));
int sz = E.size();
g[u].push_back(sz - 2);
g[v].push_back(sz - 1);
}
void dfs(int u, int f) {
for (int i = 0; i < g[u].size(); i++) {
Edge &e = E[g[u][i]];
int v = e.to;
if (v == f) continue;
dep[v] = dep[u] + 1;
fa[v][0] = u;
dis[v][0] = e.cost;
dfs(v, u);
}
}
void initLCA() {
fa[1][0] = -1;
dep[1] = 0;
dfs(1, -1);
for (int k = 0; k < POW; k++) {
for (int v = 1; v <= n; v++) {
if (fa[v][k] < 0)
fa[v][k + 1] = -1;
else
fa[v][k + 1] = fa[fa[v][k]][k],
dis[v][k + 1] = max(dis[v][k], dis[fa[v][k]][k]);
}
}
}
long long query(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
long long re = -1;
for (int k = 0; k < POW; k++) {
if ((dep[v] - dep[u]) >> k & 1) re = max(re, dis[v][k]), v = fa[v][k];
}
if (u == v) return re;
for (int k = POW - 1; k >= 0; k--) {
if (fa[u][k] != fa[v][k]) {
re = max(re, dis[v][k]), re = max(re, dis[u][k]);
u = fa[u][k], v = fa[v][k];
}
}
re = max(re, dis[u][0]);
re = max(re, dis[v][0]);
return re;
}
} // namespace MST
namespace Graph {
int tot;
struct EEdge {
int from, to;
long long cost;
} edges[(signed)6e5 + 10];
int fa[maxn];
int find_set(int x) { return fa[x] == x ? fa[x] : fa[x] = find_set(fa[x]); }
void add_edges(int u, int v, long long cost) {
edges[tot].from = u;
edges[tot].to = v;
edges[tot].cost = cost;
tot++;
}
int cmp(const EEdge a, const EEdge b) { return a.cost < b.cost; }
void kruskal() {
sort(edges, edges + tot, cmp);
for (int i = 0; i < tot; i++) {
EEdge &e = edges[i];
int fx = find_set(e.from), fy = find_set(e.to);
if (fx != fy) {
if (fx > fy) {
fa[fy] = fx;
} else {
fa[fx] = fy;
}
MST::add_edges(e.from, e.to, e.cost);
}
}
}
} // namespace Graph
signed main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= m; i++) {
int u, v;
long long cost;
scanf("%d%d%I64d", &u, &v, &cost);
add_edges(u, v, cost);
}
Dijkstra();
for (int u = 1; u <= n; u++) {
for (int i = 0; i < G[u].size(); i++) {
Edge &e = edges[G[u][i]];
if (belong[u] != belong[e.to]) {
Graph::add_edges(belong[u], belong[e.to], dis[u] + dis[e.to] + e.cost);
}
}
}
for (int i = 1; i <= n; i++) Graph::fa[i] = i;
Graph::kruskal();
MST::initLCA();
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%I64d\n", MST::query(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 300005;
const long long INF = 0x3f3f3f3f3f3f3f3f;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
template <typename T>
inline void cmax(T &x, T y) {
if (x < y) x = y;
}
int n, m, k, Q;
int vis[MAXN], from[MAXN], fa[MAXN], siz[MAXN];
long long dis[MAXN], fw[MAXN];
priority_queue<pair<long long, int> > q;
struct Edge {
int v, w, nxt;
} g[MAXM << 1];
int first[MAXN], eCnt;
inline void AddEdge(int u, int v, int w) {
g[++eCnt].v = v;
g[eCnt].w = w;
g[eCnt].nxt = first[u];
first[u] = eCnt;
}
struct Edge2 {
int u, v;
long long w;
bool operator<(const Edge2 &rhs) const { return w < rhs.w; }
} e[MAXM];
void Dijkstra() {
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= k; ++i) {
dis[i] = 0;
from[i] = i;
q.push(make_pair(0, i));
}
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = first[u]; i; i = g[i].nxt) {
int v = g[i].v;
if (dis[v] > dis[u] + g[i].w) {
dis[v] = dis[u] + g[i].w;
from[v] = from[u];
q.push(make_pair(-dis[v], v));
}
}
}
}
int getf(int u) {
while (fa[u] != u) u = fa[u];
return u;
}
void Build() {
for (int i = 2; i <= eCnt; i += 2) {
e[i >> 1].u = from[g[i].v];
e[i >> 1].v = from[g[i - 1].v];
e[i >> 1].w = dis[g[i].v] + dis[g[i - 1].v] + g[i].w;
}
sort(e + 1, e + m + 1);
for (int i = 1; i <= n; ++i) {
fa[i] = i;
siz[i] = 1;
}
for (int i = 1; i <= m; ++i) {
int u = getf(e[i].u), v = getf(e[i].v);
if (u == v) continue;
if (siz[u] > siz[v]) swap(u, v);
siz[v] += siz[u];
fa[u] = v;
fw[u] = e[i].w;
}
}
long long Query(int u, int v) {
long long ret = 0;
while (u ^ v) {
if (siz[u] > siz[v]) swap(u, v);
cmax(ret, fw[u]);
u = fa[u];
}
return ret;
}
void init() {
read(n);
read(m);
read(k);
read(Q);
for (int i = 1; i <= m; ++i) {
int u, v, w;
read(u);
read(v);
read(w);
AddEdge(u, v, w);
AddEdge(v, u, w);
}
}
void solve() {
Dijkstra();
Build();
while (Q--) {
int x, y;
read(x);
read(y);
printf("%lld\n", Query(x, y));
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int maxn = 1e6 + 10;
int n, m, k, qnum, st[maxn], to[maxn], nt[maxn], topt, fa[maxn];
int ffa[21][100010], lg[maxn], dep[maxn];
long long dis[maxn], w[maxn], ma[21][100010];
bool f[maxn];
struct da {
int first, to;
long long v;
} a[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
inline void add(int x, int y, long long z) {
to[++topt] = y;
nt[topt] = st[x];
st[x] = topt;
w[topt] = z;
}
void dij() {
for (int i = 1; i <= n; i++) dis[i] = inf;
for (int i = 1; i <= k; i++) dis[i] = 0, q.push(make_pair(0, i));
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (f[x])
continue;
else
f[x] = 1;
int p = st[x];
while (p) {
if (dis[to[p]] > dis[x] + w[p]) {
dis[to[p]] = dis[x] + w[p];
q.push(make_pair(dis[to[p]], to[p]));
}
p = nt[p];
}
}
}
inline bool cmp(da aa, da bb) { return aa.v < bb.v; }
int getf(int x) {
if (fa[x] == x) return x;
fa[x] = getf(fa[x]);
return fa[x];
}
void dfs(int x, int d, long long vv) {
f[x] = 1;
dep[x] = d;
ma[0][x] = vv;
int p = st[x];
while (p) {
if (!f[to[p]]) dfs(to[p], d + 1, w[p]), ffa[0][to[p]] = x;
p = nt[p];
}
}
inline void init() {
for (int i = 1; i <= n; i++)
lg[i] = lg[i - 1] + ((1 << (lg[i - 1] + 1)) == i);
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i <= n; i++) ffa[j][i] = ffa[j - 1][ffa[j - 1][i]];
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i <= n; i++)
ma[j][i] = max(ma[j - 1][i], ma[j - 1][ffa[j - 1][i]]);
}
long long solve(int x, int y) {
long long ans = 0;
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y]) {
ans = max(ans, ma[lg[dep[x] - dep[y]]][x]);
x = ffa[lg[dep[x] - dep[y]]][x];
}
if (x == y) return ans;
for (register int i = lg[dep[x]]; i >= 0; i--)
if (ffa[i][x] != ffa[i][y]) {
ans = max(ans, ma[i][x]);
ans = max(ans, ma[i][y]);
x = ffa[i][x];
y = ffa[i][y];
}
ans = max(ans, ma[0][x]);
ans = max(ans, ma[0][y]);
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &qnum);
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &a[i].first, &a[i].to, &a[i].v);
add(a[i].first, a[i].to, a[i].v);
add(a[i].to, a[i].first, a[i].v);
}
dij();
for (int i = 1; i <= m; i++) a[i].v = a[i].v + dis[a[i].first] + dis[a[i].to];
sort(a + 1, a + m + 1, cmp);
topt = 0;
for (int i = 1; i <= n; i++) st[i] = 0, fa[i] = i;
for (int i = 1; i <= m; i++) {
if (getf(a[i].first) == getf(a[i].to)) continue;
fa[getf(a[i].first)] = getf(a[i].to);
add(a[i].first, a[i].to, a[i].v);
add(a[i].to, a[i].first, a[i].v);
}
for (int i = 1; i <= n; i++) f[i] = 0;
dfs(1, 1, 0);
init();
for (int i = 1; i <= qnum; i++) {
int xx, yy;
scanf("%d%d", &xx, &yy);
printf("%lld\n", solve(xx, yy));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int maxn = 1e5 + 10;
const long long inf = (long long)1e15;
int n, m, k, q;
struct enode {
int v, nxt;
long long w;
} edge[maxn * 6];
struct dnode {
int u, v;
long long w;
} a[maxn * 3];
bool cmp(dnode& a, dnode& b) { return a.w < b.w; }
int head[maxn], tot;
void add(int u, int v, long long w) {
edge[++tot].v = v;
edge[tot].w = w;
edge[tot].nxt = head[u];
head[u] = tot;
}
long long dis[maxn];
int fro[maxn];
bool vis[maxn];
void dijkstra() {
priority_queue<pair<long long, int> > pq;
for (int i = 1; i <= k; ++i) {
dis[i] = 0;
fro[i] = i;
pq.push(make_pair(0, i));
}
for (int i = k + 1; i <= n; ++i) dis[i] = inf;
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = true;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].v, w = edge[i].w;
if (dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
fro[v] = fro[u];
pq.push(make_pair(-dis[v], v));
}
}
}
}
int fa[maxn];
int sz[maxn];
long long val[maxn];
int find(int x) {
if (x == fa[x]) return x;
return find(fa[x]);
}
long long query(int u, int v) {
long long ans = 0;
while (u != v) {
if (sz[u] > sz[v]) swap(u, v);
ans = max(ans, val[u]);
u = fa[u];
}
return ans;
}
int main() {
n = read(), m = read(), k = read(), q = read();
for (int i = 0; i < m; ++i) {
int u = read(), v = read();
long long w;
scanf("%lld", &w);
add(u, v, w);
add(v, u, w);
}
dijkstra();
for (int i = 1; i <= m; ++i) {
a[i].u = fro[edge[i * 2 - 1].v];
a[i].v = fro[edge[i * 2].v];
a[i].w = dis[edge[i * 2 - 1].v] + dis[edge[i * 2].v] + edge[i * 2].w;
}
sort(a + 1, a + 1 + m, cmp);
for (int i = 1; i <= n; ++i) {
sz[i] = 1;
fa[i] = i;
}
for (int i = 1; i <= m; ++i) {
int u = find(a[i].u), v = find(a[i].v);
if (u == v) continue;
if (sz[u] > sz[v]) swap(u, v);
fa[u] = fa[v];
sz[v] += sz[u];
val[u] = a[i].w;
}
while (q--) {
int u = read(), v = read();
printf("%lld\n", query(u, v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
struct edge {
int node = -1;
long long weight = LL_INF;
edge() {}
edge(int _node, long long _weight) : node(_node), weight(_weight) {}
};
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 ab_edge {
int a, b;
long long weight;
bool operator<(const ab_edge &other) const { return weight < other.weight; }
};
vector<ab_edge> edges;
void compute_real_weights() {
for (int i = 0; i < N; i++)
for (edge &e : adj[i]) {
e.weight += dist[i] + dist[e.node];
edges.push_back({i, e.node, e.weight});
}
}
vector<vector<pair<int, int>>> queries;
vector<long long> answers;
vector<vector<int>> groups;
vector<int> owner;
void merge_and_solve(int a, int b, long long weight) {
a = owner[a];
b = owner[b];
if (a == b) return;
if (groups[a].size() > groups[b].size()) swap(a, b);
for (int x : groups[a])
for (pair<int, int> &query : queries[x])
if (owner[query.first] == b) {
assert(answers[query.second] < 0);
answers[query.second] = weight;
}
for (int x : groups[a]) {
owner[x] = b;
groups[b].push_back(x);
}
groups[a].clear();
}
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();
compute_real_weights();
queries.assign(N, {});
answers.assign(Q, -1);
for (int q = 0; q < Q; q++) {
int a, b;
cin >> a >> b;
a--;
b--;
queries[a].emplace_back(b, q);
queries[b].emplace_back(a, q);
}
groups.assign(N, {});
owner.resize(N);
for (int i = 0; i < N; i++) {
owner[i] = i;
groups[i] = {i};
}
sort(edges.begin(), edges.end());
for (ab_edge &e : edges) merge_and_solve(e.a, e.b, e.weight);
for (int q = 0; q < Q; q++) cout << answers[q] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> edge[300001];
vector<pair<long long, pair<int, int>>> ne;
vector<pair<int, int>> e[100001];
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
long long dis[100001];
int color[100001];
bool v[100001];
int fa[100001], tf[100001][17], depth[100001];
long long val[100001];
vector<int> ned[100001];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void dfs(int x) {
for (int i = 1; i < 17; i++) tf[x][i] = tf[tf[x][i - 1]][i - 1];
for (int nex : ned[x]) depth[nex] = depth[x] + 1, dfs(nex);
}
long long get(int x, int y) {
if (depth[x] > depth[y]) swap(x, y);
int delta = depth[y] - depth[x];
if (delta) {
delta--;
for (int i = 0; i < 17; i++)
if (delta & (1 << i)) y = tf[y][i];
if (tf[y][0] == x) return val[y];
y = tf[y][0];
}
for (int i = 16; i >= 0; i--)
if (tf[x][i] != tf[y][i]) x = tf[x][i], y = tf[y][i];
return max(val[x], val[y]);
}
int main() {
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
edge[i] = make_pair(make_pair(u, v), w);
e[u].emplace_back(v, w);
e[v].emplace_back(u, w);
}
for (int i = 1; i <= k; i++) color[i] = i, pq.emplace(0, i);
for (int i = k + 1; i <= n; i++) dis[i] = LLONG_MAX;
while (!pq.empty()) {
long long d = pq.top().first;
int x = pq.top().second;
pq.pop();
if (v[x]) continue;
v[x] = 1;
for (auto p : e[x]) {
int nex = p.first, w = p.second;
if (dis[nex] > d + w) {
dis[nex] = d + w;
color[nex] = color[x];
pq.emplace(dis[nex], nex);
}
}
}
for (int i = 1; i <= k; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u = edge[i].first.first, v = edge[i].first.second, w = edge[i].second;
if (color[u] != color[v])
ne.push_back(
make_pair(dis[u] + dis[v] + w, make_pair(color[u], color[v])));
}
sort(ne.begin(), ne.end());
for (auto p : ne) {
int u = find(p.second.first), v = find(p.second.second);
long long w = p.first;
if (u == v) continue;
fa[u] = tf[u][0] = v;
val[u] = w;
ned[v].emplace_back(u);
}
int rt = 1;
for (; rt <= k; rt++)
if (!tf[rt][0]) break;
dfs(rt);
if (n == 500) {
for (int i = 1; i <= n; i++)
if (dis[i] < 0) printf("culprit:%d\n", i);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%lld\n", get(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, oo = 1e18, LG = 22;
long long n, m, k, q, P[N][LG], dep[N], mx[N][LG];
vector<array<long long, 2>> adj[N], tree[N];
array<long long, 2> dist[N];
vector<array<long long, 3>> Edges;
void dfs(long long u, long long pre) {
for (auto D : tree[u]) {
long long v = D[0], w = D[1];
if (v == pre) continue;
P[v][0] = u;
mx[v][0] = w;
dep[v] = dep[u] + 1;
dfs(v, u);
}
}
long long query(long long u, long long v) {
long long ret = 0;
if (dep[u] < dep[v]) swap(u, v);
for (long long i = LG - 1; i >= 0; --i)
if ((1 << i) <= dep[u] - dep[v]) {
ret = max(ret, mx[u][i]);
u = P[u][i];
}
if (u == v) return ret;
for (long long i = LG - 1; i >= 0; --i)
if ((1 << i) <= dep[u] && P[u][i] != P[v][i]) {
ret = max(ret, mx[u][i]);
ret = max(ret, mx[v][i]);
u = P[u][i];
v = P[v][i];
}
ret = max(ret, mx[u][0]);
ret = max(ret, mx[v][0]);
return ret;
}
struct dsu_t {
long long n;
vector<long long> lab, Rank;
dsu_t() {}
dsu_t(long long _n) {
this->n = _n;
lab.assign(n + 5, -1);
Rank.assign(n + 5, 1);
}
long long root(long long x) {
return lab[x] == -1 ? x : lab[x] = root(lab[x]);
}
bool merge(long long u, long long v) {
long long x = root(u), y = root(v);
if (x == y) return false;
if (Rank[x] < Rank[y]) swap(x, y);
lab[y] = x;
Rank[x] += Rank[y];
return true;
}
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> q;
for (long long i = 1; i <= m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
priority_queue<array<long long, 3>, vector<array<long long, 3>>,
greater<array<long long, 3>>>
pq;
while (!pq.empty()) pq.pop();
for (long long i = 1; i <= k; ++i) {
pq.push({0, i, i});
dist[i] = {0, i};
}
for (long long i = k + 1; i <= n; ++i) {
dist[i] = {oo, -1};
}
while (!pq.empty()) {
array<long long, 3> cur = pq.top();
pq.pop();
long long D = cur[0], u = cur[1], beg = cur[2];
if (D > dist[u][0]) continue;
for (auto vv : adj[u]) {
long long v = vv[0], w = vv[1];
if (D + w < dist[v][0]) {
dist[v][0] = D + w;
dist[v][1] = beg;
pq.push({D + w, v, beg});
}
}
}
for (long long u = 1; u <= n; ++u) {
for (auto vv : adj[u]) {
long long v = vv[0];
if (dist[v][1] == dist[u][1] || u > v) continue;
Edges.push_back(
{dist[v][0] + dist[u][0] + vv[1], dist[v][1], dist[u][1]});
}
}
sort(Edges.begin(), Edges.end());
dsu_t dsu = dsu_t(k);
for (auto D : Edges) {
long long u = D[1], v = D[2], w = D[0];
if (dsu.merge(u, v)) {
tree[u].push_back({v, w});
tree[v].push_back({u, w});
}
}
dfs(1, -1);
for (long long i = 1; i < LG; ++i) {
for (long long u = 1; u <= n; ++u) {
P[u][i] = P[P[u][i - 1]][i - 1];
mx[u][i] = max(mx[u][i - 1], mx[P[u][i - 1]][i - 1]);
}
}
for (long long i = 1; i <= q; ++i) {
long long u, v;
cin >> u >> v;
cout << query(u, v) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f3f3f3f3fll;
class DSU {
std::vector<int> fa;
public:
DSU(int n) : fa(n) {
for (int i = 0; i < n; ++i) {
fa[i] = i;
}
}
int find(int x) { return fa[x] == x ? x : (fa[x] = find(fa[x])); }
bool merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) {
return false;
}
fa[y] = x;
return true;
}
};
int get_log2(int n) {
int res = 1;
while ((1 << res) < n) {
++res;
}
return res;
}
class tree {
const int n, LG;
std::vector<std::vector<std::pair<int, long long>>> E;
std::vector<int> dep;
std::vector<std::vector<int>> fa;
std::vector<std::vector<long long>> mx;
void dfs(int u) {
for (int i = 1; i < LG; ++i) {
fa[u][i] = fa[u][i - 1] == -1 ? -1 : fa[fa[u][i - 1]][i - 1];
mx[u][i] = fa[u][i - 1] == -1
? mx[u][i - 1]
: std::max(mx[u][i - 1], mx[fa[u][i - 1]][i - 1]);
}
for (auto [v, w] : E[u]) {
if (v != fa[u][0]) {
dep[v] = dep[u] + 1;
fa[v][0] = u;
mx[v][0] = w;
dfs(v);
}
}
}
public:
tree(int _n)
: n(_n),
LG(get_log2(n)),
E(n),
dep(n),
fa(n, std::vector<int>(LG, -1)),
mx(n, std::vector<long long>(LG, n)) {}
void add_edge(int u, int v, long long w) {
E[u].emplace_back(v, w);
E[v].emplace_back(u, w);
}
void build() {
dep[0] = 0;
fa[0][0] = -1;
mx[0][0] = 0;
dfs(0);
}
long long query(int u, int v) {
if (dep[u] < dep[v]) {
std::swap(u, v);
}
long long ans = 0;
for (int i = LG - 1; i >= 0; --i) {
if (fa[u][i] != -1 && dep[fa[u][i]] >= dep[v]) {
ans = std::max(ans, mx[u][i]);
u = fa[u][i];
}
}
if (u == v) {
return ans;
}
for (int i = LG - 1; i >= 0; --i) {
if (fa[u][i] != fa[v][i]) {
ans = std::max(ans, std::max(mx[u][i], mx[v][i]));
u = fa[u][i], v = fa[v][i];
}
}
ans = std::max(ans, std::max(mx[u][0], mx[v][0]));
return ans;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, m, k, q;
std::cin >> n >> m >> k >> q;
std::vector<std::vector<std::pair<int, int>>> E(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
std::cin >> u >> v >> w;
--u, --v;
E[u].emplace_back(v, w);
E[v].emplace_back(u, w);
}
std::vector<long long> dis(n, INF);
std::vector<bool> vis(n, false);
std::priority_queue<std::pair<long long, int>> Q;
for (int i = 0; i < k; ++i) {
dis[i] = 0;
Q.emplace(0, i);
}
while (!Q.empty()) {
int u = Q.top().second;
Q.pop();
if (vis[u]) {
continue;
}
vis[u] = true;
for (auto [v, w] : E[u]) {
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
Q.emplace(-dis[v], v);
}
}
}
std::vector<std::tuple<long long, int, int>> edge;
for (int u = 0; u < n; ++u) {
for (auto [v, w] : E[u]) {
if (u < v) {
edge.emplace_back(dis[u] + dis[v] + w, u, v);
}
}
}
std::sort(edge.begin(), edge.end());
tree T(n);
DSU D(n);
for (auto [w, u, v] : edge) {
if (D.merge(u, v)) {
T.add_edge(u, v, w);
}
}
T.build();
while (q--) {
int u, v;
std::cin >> u >> v;
--u, --v;
std::cout << T.query(u, v) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, q, vis[100005], cd[100005], etot, fa[100005];
int ffa[100005][24], dep[100005], lg[100005];
long long dis[100005], mma[100005][24];
struct edge {
int to;
long long w;
edge() {}
edge(int to, long long w) : to(to), w(w) {}
};
struct node {
int x, y;
long long w;
node() {}
node(int x, int y, long long w) : x(x), y(y), w(w) {}
} ee[1000005];
vector<edge> e[100005], e2[100005];
bool cmp(node a, node b) { return a.w < b.w; }
int _find(int x) { return fa[x] == x ? x : fa[x] = _find(fa[x]); }
void _merge(int x, int y) {
x = _find(x), y = _find(y);
fa[x] = y;
}
void dij() {
for (int i = 1; i <= n + 1; i++) dis[i] = 0x3f3f3f3f3f3f3f3fll;
dis[n + 1] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.emplace(0, n + 1);
while (!q.empty()) {
int now = q.top().second;
q.pop();
if (vis[now]) continue;
vis[now] = 1;
for (auto it : e[now])
if (dis[it.to] > dis[now] + it.w) {
dis[it.to] = dis[now] + it.w;
if (now != n + 1) cd[it.to] = cd[now];
q.emplace(dis[it.to], it.to);
}
}
}
void mst() {
for (int i = 1; i <= n; i++) fa[i] = i;
sort(ee, ee + etot, cmp);
for (int i = 0; i < etot; i++)
if (_find(ee[i].x) != _find(ee[i].y)) {
_merge(ee[i].x, ee[i].y);
e2[ee[i].x].emplace_back(ee[i].y, ee[i].w);
e2[ee[i].y].emplace_back(ee[i].x, ee[i].w);
}
}
void dfs(int now, int pa, long long dd) {
dep[now] = dep[pa] + 1;
ffa[now][0] = pa;
mma[now][0] = dd;
for (int i = 1; (1 << i) <= dep[now]; i++) {
ffa[now][i] = ffa[ffa[now][i - 1]][i - 1];
mma[now][i] = max(mma[now][i - 1], mma[ffa[now][i - 1]][i - 1]);
}
for (auto it : e2[now])
if (it.to != pa) dfs(it.to, now, it.w);
}
long long lca(int x, int y) {
long long ret = 0;
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y]) {
ret = max(ret, mma[x][lg[dep[x] - dep[y]] - 1]);
x = ffa[x][lg[dep[x] - dep[y]] - 1];
}
if (x == y) return ret;
for (int i = lg[dep[x]] - 1; i >= 0; i--)
if (ffa[x][i] != ffa[y][i]) {
ret = max(ret, mma[x][i]);
ret = max(ret, mma[y][i]);
x = ffa[x][i], y = ffa[y][i];
}
return max(ret, max(mma[y][0], mma[x][0]));
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= n + 1; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
for (int i = 1, x, y, w; i <= m; i++) {
scanf("%d%d%d", &x, &y, &w);
e[x].emplace_back(y, w);
e[y].emplace_back(x, w);
}
for (int i = 1; i <= k; i++) e[n + 1].emplace_back(i, 0), cd[i] = i;
dij();
for (int i = 1; i <= n; i++)
for (auto it : e[i]) {
if (cd[i] != cd[it.to])
ee[etot++] = node(cd[i], cd[it.to], dis[i] + it.w + dis[it.to]);
else
ee[etot++] = node(i, it.to, it.w);
}
mst();
dfs(1, 0, 0);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%lld\n", lca(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 4e5;
vector<tuple<long long, long long, long long> > edge;
priority_queue<long long> q;
long long d[N];
set<long long> se[N];
long long pa[N];
vector<long long> qr[N];
vector<pair<long long, long long> > ke[N];
long long Res[N];
long long anc(long long u) {
if (pa[u] > 0) {
pa[u] = anc(pa[u]);
return pa[u];
} else
return u;
}
void join(long long u, long long v, long long z) {
u = anc(u);
v = anc(v);
if (u == v) {
return;
}
if (pa[u] > pa[v]) swap(u, v);
pa[u] += pa[v];
pa[v] = u;
for (auto& vse : se[v]) {
if (se[u].size())
if (se[u].find(vse) != se[u].end()) {
Res[vse] = z;
}
}
for (auto& vse : se[v]) se[u].insert(vse);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, k, Q;
cin >> n >> m >> k >> Q;
for (long long i = 1; i <= m; i++) {
long long first, second, z;
cin >> first >> second >> z;
ke[first].push_back(pair<long long, long long>(second, z));
ke[second].push_back(pair<long long, long long>(first, z));
edge.push_back(tuple<long long, long long, long long>(first, second, z));
}
priority_queue<pair<long long, long long> > q;
for (long long i = 1; i <= k; i++) {
q.push(pair<long long, long long>(0, i));
d[i] = 0;
}
for (long long i = k + 1; i <= n; i++) d[i] = 1e18;
while (q.size()) {
long long u;
u = q.top().second;
q.pop();
for (auto& v : ke[u]) {
long long first, second;
tie(second, first) = v;
if (d[second] > d[u] + first) {
d[second] = d[u] + first;
q.push(pair<long long, long long>(-d[second], second));
}
}
}
for (auto& i : edge) {
long long first, second, z;
tie(first, second, z) = i;
get<2>(i) = d[first] + d[second] + z;
}
sort(edge.begin(), edge.end(),
[](const tuple<long long, long long, long long>& a,
const tuple<long long, long long, long long>& b) -> bool {
return get<2>(a) < get<2>(b);
});
for (long long i = 1; i <= Q; i++) {
long long first, second;
cin >> first >> second;
se[first].insert(i);
se[second].insert(i);
}
for (long long i = 1; i <= n; i++) pa[i] = -1;
for (auto& i : edge) {
long long first, second, z;
tie(first, second, z) = i;
join(first, second, z);
}
for (long long i = 1; i <= Q; i++) {
cout << Res[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
const long long M = 1;
const long long K = 1;
const long long mod = 1e9 + 7;
const long long inf = 2e9;
const long long Inf = 2e18;
long long n, m, k, q;
vector<pair<long long, long long> > adj[N];
vector<pair<long long, pair<long long, long long> > > ed;
long long d[N];
void dick() {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
memset(d, 0x3f, sizeof d);
for (long long i = 1; i <= k; ++i) {
d[i] = 0;
q.push({0, i});
}
while (q.size()) {
pair<long long, long long> top = q.top();
q.pop();
long long pd = top.first;
long long p = top.second;
if (pd != d[p]) continue;
for (pair<long long, long long> u : adj[p])
if (pd + u.second < d[u.first]) {
d[u.first] = pd + u.second;
q.push({d[u.first], u.first});
}
}
}
vector<pair<long long, long long> > re[N];
long long par[N], res[N];
vector<long long> con[N];
void init() {
for (long long i = 1; i <= n; ++i) {
par[i] = i;
con[i].push_back(i);
}
}
long long get(long long x) {
if (x == par[x]) return x;
return par[x] = get(par[x]);
}
void mix(long long x, long long y, long long w) {
long long u = get(x);
long long v = get(y);
if (u == v) return;
if (con[u].size() > con[v].size()) swap(u, v);
for (long long x : con[u]) {
for (pair<long long, long long> i : re[x]) {
long long id = i.second;
long long j = i.first;
if (get(j) == v) res[id] = w;
}
con[v].push_back(x);
}
par[u] = v;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
for (long long i = 1; i <= m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
dick();
for (long long i = 1; i <= n; ++i)
for (pair<long long, long long> x : adj[i]) {
long long dis = x.second + d[i] + d[x.first];
ed.push_back({dis, {i, x.first}});
}
for (long long i = 1; i <= q; ++i) {
long long u, v;
cin >> u >> v;
re[u].push_back({v, i});
re[v].push_back({u, i});
}
init();
sort(ed.begin(), ed.end());
for (auto x : ed) mix(x.second.first, x.second.second, x.first);
for (long long i = 1; i <= q; ++i) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const long long mod = 1e9 + 7;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, k, q;
int inde[100005], tot;
long long dis[100005];
struct p {
int u, v, w, nxt;
} e[600005 * 4];
void add(int u, int v, int w) { e[++tot] = {u, v, w, inde[u]}, inde[u] = tot; }
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
Q;
bool vis[100005];
void bfs() {
int i, v, u;
Q.push({0, 0});
while (!Q.empty()) {
pair<long long, int> tp = Q.top();
Q.pop();
u = tp.second;
if (dis[u] != tp.first) continue;
for (i = inde[u]; i; i = e[i].nxt) {
v = e[i].v;
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
Q.push({dis[v], v});
}
}
}
}
int f[100005];
struct q {
int u, v;
long long w;
bool operator<(const q &a) const {
return dis[u] + dis[v] + w < dis[a.u] + dis[a.v] + a.w;
}
} edge[600005];
int getf(int x) { return x == f[x] ? x : f[x] = getf(f[x]); }
struct pp {
int u, v, id;
} qe[600005];
long long ans[600005];
vector<int> g[100005];
int main() {
int i, j, u, v, w;
n = read(), m = read(), k = read(), q = read();
for (i = 1; i <= m; i++) {
u = read(), v = read(), w = read();
edge[i] = {u, v, w};
add(u, v, w);
add(v, u, w);
}
for (i = 1; i <= n; i++) dis[i] = 0x3f3f3f3f3f3f3f3f;
for (i = 1; i <= k; i++) add(0, i, 0);
bfs();
tot = 0;
for (i = 1; i <= n; i++) f[i] = i;
for (i = 1; i <= q; i++) {
u = read(), v = read();
qe[i] = pp{u, v, i};
g[u].push_back(i);
g[v].push_back(i);
}
sort(edge + 1, edge + m + 1);
for (i = 1; i <= m; i++) {
u = edge[i].u, v = edge[i].v, w = edge[i].w;
int f1 = getf(u), f2 = getf(v);
if (f1 == f2) continue;
if (g[f1].size() < g[f2].size()) swap(f1, f2);
f[f2] = f1;
for (j = 0; j < g[f2].size(); j++) {
int x = qe[g[f2][j]].u, y = qe[g[f2][j]].v;
if (getf(x) == getf(y)) {
if (!ans[g[f2][j]]) ans[g[f2][j]] = edge[i].w + dis[u] + dis[v];
} else
g[f1].push_back(g[f2][j]);
}
}
for (i = 1; i <= q; i++) printf("%lld\n", ans[i]);
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)2e18;
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> > 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;
Q.pop();
for (auto [v, w] : g[u])
if (dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
Q.push({-dis[v], v});
}
}
}
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});
}
for (int i = 1; i <= n; i++) {
fa[i] = i;
ele[i].insert(i);
}
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;
int n, m, k, q;
vector<pair<int, int> > gr[100007];
int LCA[100007][19];
long long mx[100007][19];
int lvl[100007];
vector<pair<int, long long> > v[100007];
long long opt[100007];
int ori[100007];
struct tuhla {
int vertex;
long long dist;
int origin;
tuhla() { vertex = dist = origin = 0; }
tuhla(int _vertex, long long _dist, int _origin) {
vertex = _vertex;
dist = _dist;
origin = _origin;
}
bool operator<(tuhla other) const { return (dist > other.dist); }
};
priority_queue<struct tuhla> pq;
struct edge {
int x, y;
long long cost;
edge() { x = y = cost = 0; }
edge(int _x, int _y, long long _cost) {
x = _x;
y = _y;
cost = _cost;
}
bool operator<(edge other) const { return (cost < other.cost); }
};
vector<struct edge> srt;
void dijkstra() {
for (int i = 1; i <= k; ++i) {
pq.push(tuhla(i, 0, i));
opt[i] = 0;
ori[i] = i;
}
for (int i = k + 1; i <= n; ++i) {
opt[i] = -1;
}
while (pq.empty() == false) {
tuhla aux = pq.top();
pq.pop();
if (opt[aux.vertex] != aux.dist) {
continue;
}
if (ori[aux.vertex] != aux.origin) {
continue;
}
int sz = gr[aux.vertex].size();
for (int i = 0; i < sz; ++i) {
int h = gr[aux.vertex][i].first;
int c = gr[aux.vertex][i].second;
if (opt[h] == -1 || opt[h] > aux.dist + c) {
opt[h] = aux.dist + c;
ori[h] = aux.origin;
pq.push(tuhla(h, opt[h], ori[h]));
}
}
}
}
int prv[100007];
int rnk[100007];
int find(int x) {
if (prv[x] == -1) {
return x;
}
int y = find(prv[x]);
prv[x] = y;
return y;
}
void unite(edge aux) {
int k1 = find(aux.x);
int k2 = find(aux.y);
if (k1 != k2) {
v[aux.x].push_back({aux.y, aux.cost});
v[aux.y].push_back({aux.x, aux.cost});
if (rnk[k1] >= rnk[k2]) {
if (rnk[k1] == rnk[k2]) {
++rnk[k1];
}
prv[k2] = k1;
} else {
prv[k1] = k2;
}
}
}
void dfs(int vertex, int lst) {
for (int i = 1; i < 19; ++i) {
LCA[vertex][i] = LCA[LCA[vertex][i - 1]][i - 1];
mx[vertex][i] = max(mx[vertex][i - 1], mx[LCA[vertex][i - 1]][i - 1]);
}
int sz = v[vertex].size();
for (int i = 0; i < sz; ++i) {
if (v[vertex][i].first == lst) {
continue;
}
LCA[v[vertex][i].first][0] = vertex;
mx[v[vertex][i].first][0] = v[vertex][i].second;
lvl[v[vertex][i].first] = lvl[vertex] + 1;
dfs(v[vertex][i].first, vertex);
}
}
long long f(int x, int y) {
long long ret = 0;
for (int i = 19 - 1; i >= 0; --i) {
if (lvl[x] - (1 << i) >= lvl[y]) {
ret = max(ret, mx[x][i]);
x = LCA[x][i];
}
if (lvl[y] - (1 << i) >= lvl[x]) {
ret = max(ret, mx[y][i]);
y = LCA[y][i];
}
}
for (int i = 19 - 1; i >= 0; --i) {
if (LCA[x][i] != LCA[y][i]) {
ret = max(ret, mx[x][i]);
x = LCA[x][i];
ret = max(ret, mx[y][i]);
y = LCA[y][i];
}
}
if (x != y) {
ret = max(ret, mx[x][0]);
ret = max(ret, mx[y][0]);
}
return ret;
}
void input() {
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; ++i) {
int x, y, z;
cin >> x >> y >> z;
gr[x].push_back({y, z});
gr[y].push_back({x, z});
}
}
void solve() {
dijkstra();
for (int i = 1; i <= n; ++i) {
int sz = gr[i].size();
for (int j = 0; j < sz; ++j) {
int h = gr[i][j].first;
int c = gr[i][j].second;
if (ori[h] != ori[i] && ori[h] < ori[i]) {
srt.push_back(edge(ori[h], ori[i], opt[i] + opt[h] + c));
}
}
}
sort(srt.begin(), srt.end());
for (int i = 1; i <= n; ++i) {
prv[i] = -1;
}
int sz = srt.size();
for (int i = 0; i < sz; ++i) {
unite(srt[i]);
}
dfs(1, -1);
while (q--) {
int x, y;
cin >> x >> y;
cout << f(x, y) << "\n";
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
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 long long MAXN = 3e5 + 5;
long long k, n, m, q, ta, tb, tc;
long long dis[MAXN];
long long dkt[MAXN];
long long dep[MAXN];
long long ma[22][MAXN];
long long p[22][MAXN];
vector<long long> v0[MAXN];
vector<long long> w0[MAXN];
vector<long long> v[MAXN];
vector<long long> w[MAXN];
vector<pair<long long, pair<long long, long long> > > isi;
long long P[MAXN];
void djik() {
priority_queue<pair<long long, pair<long long, long long> > > pq;
for (long long i = 1; i <= n; i++) {
dis[i] = 1e18;
if (i <= k) {
dis[i] = 0;
dkt[i] = i;
pq.push(make_pair(0, make_pair(i, i)));
}
}
while (!pq.empty()) {
long long jar = -pq.top().first;
long long u = pq.top().second.first;
long long dk = pq.top().second.second;
pq.pop();
for (long long i = 0; i < v0[u].size(); i++) {
long long nx = v0[u][i];
long long wx = jar + w0[u][i];
if (dis[nx] > wx) {
dis[nx] = wx;
dkt[nx] = dk;
pq.push(make_pair(-wx, make_pair(nx, dk)));
} else if (dkt[nx] != dk) {
isi.push_back(make_pair(dis[nx] + wx, make_pair(dkt[nx], dk)));
}
}
}
}
void dfs(long long pos, long long par, long long dlm) {
dep[pos] = dlm;
p[0][pos] = par;
for (long long i = 1; i <= 20; i++) {
p[i][pos] = p[i - 1][p[i - 1][pos]];
ma[i][pos] = max(ma[i - 1][pos], ma[i - 1][p[i - 1][pos]]);
}
for (long long i = 0; i < v[pos].size(); i++) {
long long nx = v[pos][i];
if (nx == par) continue;
ma[0][nx] = w[pos][i];
dfs(nx, pos, dlm + 1);
}
}
long long LCA(long long A, long long B) {
long long H = 0;
if (dep[A] < dep[B]) swap(A, B);
for (long long i = 20; i >= 0; i--)
if (dep[A] - (1 << i) >= dep[B]) {
H = max(H, ma[i][A]);
A = p[i][A];
}
if (A == B) return H;
for (long long i = 20; i >= 0; i--)
if (p[i][A] != p[i][B]) {
H = max(H, ma[i][A]);
H = max(H, ma[i][B]);
A = p[i][A];
B = p[i][B];
}
H = max(H, ma[0][A]);
H = max(H, ma[0][B]);
return H;
}
long long car(long long A) {
if (P[A] == A)
return A;
else
return P[A] = car(P[A]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
for (long long i = 1; i <= m; i++) {
P[i] = i;
cin >> ta >> tb >> tc;
v0[ta].push_back(tb);
w0[ta].push_back(tc);
v0[tb].push_back(ta);
w0[tb].push_back(tc);
}
djik();
sort(isi.begin(), isi.end());
for (long long i = 0; i < isi.size(); i++) {
if (car(isi[i].second.first) != car(isi[i].second.second)) {
v[isi[i].second.first].push_back(isi[i].second.second);
w[isi[i].second.first].push_back(isi[i].first);
v[isi[i].second.second].push_back(isi[i].second.first);
w[isi[i].second.second].push_back(isi[i].first);
P[car(isi[i].second.first)] = car(isi[i].second.second);
}
}
dfs(1, 1, 0);
while (q--) {
cin >> ta >> tb;
cout << LCA(ta, tb) << "\n";
}
}
|
#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];
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];
tmp.clear();
for (int j = 0; j < (int)qr[u].size(); j++) {
if (fnd(qr[u][j].first) == x)
rs[qr[u][j].second] = w;
else
tmp.push_back(qr[u][j]);
}
qr[u] = tmp;
v[x].push_back(u);
}
v[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);
}
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>
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 = 0x3f3f3f3f3f3f3f3f;
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;
vector<P> ee[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;
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 (auto xx : ee[u]) {
int v = xx.first;
LL w = xx.second;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
que.push(P(dis[v], v));
}
}
}
for (int u = 1; u <= n; ++u) {
for (auto xx : ee[u]) {
int v = xx.first;
LL w = xx.second;
addedge(u, v, w + dis[v] + dis[u]);
}
}
}
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() {
ios::sync_with_stdio(false);
init();
cin >> n >> m >> k >> q;
int u, v;
LL w;
for (int i = 0; i < m; ++i) {
cin >> u >> v >> w;
ee[u].push_back(P(v, w));
ee[v].push_back(P(u, w));
}
dijkstra();
Kruskal();
preLCA();
int x, y;
int lca;
while (q--) {
cin >> x >> y;
lca = LCA(x, y);
cout << max(getMax(x, dep[x] - dep[lca]), getMax(y, dep[y] - dep[lca]))
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "03"
using namespace std;
const long long int N = 1e5 + 5;
const long long int mod = 1e9 + 7;
const long long int inf = 1e18 + 9;
long long int dis[N], par[N], dep[N], p[N][18], dp[N][18];
vector<pair<long long int, long long int> > g[N], h[N];
vector<pair<pair<long long int, long long int>, long long int> > ed;
vector<pair<long long int, pair<long long int, long long int> > > mst;
long long int root(long long int x) {
return (par[x] == x) ? x : par[x] = root(par[x]);
}
void merge(long long int x, long long int y) {
x = root(x);
y = root(y);
par[x] = y;
}
void dfs(long long int u, long long int pp) {
dep[u] = dep[pp] + 1;
for (auto i : h[u]) {
if (i.first == pp) continue;
p[i.first][0] = u;
dp[i.first][0] = i.second;
dfs(i.first, u);
}
}
long long int query(long long int a, long long int b) {
if (dep[a] <= dep[b]) swap(a, b);
long long int ans = 0;
for (long long int i = 17; i >= 0; i--) {
if (dep[p[a][i]] >= dep[b]) ans = max(ans, dp[a][i]), a = p[a][i];
}
if (a == b) return ans;
for (long long int i = 17; i >= 0; i--) {
if (p[a][i] == p[b][i]) continue;
ans = max(ans, dp[a][i]);
ans = max(ans, dp[b][i]);
a = p[a][i];
b = p[b][i];
}
ans = max(ans, dp[a][0]);
ans = max(ans, dp[b][0]);
return ans;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, mm, k, q;
cin >> n >> mm >> k >> q;
for (long long int i = 1; i <= mm; i++) {
long long int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
ed.push_back({{u, v}, w});
}
multiset<pair<long long int, pair<long long int, long long int> > > m;
for (long long int i = 1; i <= n; i++) {
if (i <= k)
m.insert({0, {i, i}}), dis[i] = 0;
else
dis[i] = inf;
}
while (!m.empty()) {
auto x = *m.begin();
m.erase(m.begin());
if (dis[x.second.first] != x.first) continue;
par[x.second.first] = x.second.second;
for (auto i : g[x.second.first]) {
if (dis[i.first] > dis[x.second.first] + i.second) {
dis[i.first] = dis[x.second.first] + i.second;
m.insert({dis[i.first], {i.first, x.second.second}});
}
}
}
for (auto i : ed) {
if (par[i.first.first] == par[i.first.second]) continue;
mst.push_back({dis[i.first.first] + dis[i.first.second] + i.second,
{par[i.first.first], par[i.first.second]}});
}
for (long long int i = 1; i <= k; i++) par[i] = i;
sort(mst.begin(), mst.end());
for (auto i : mst) {
if (root(i.second.first) == root(i.second.second)) continue;
merge(i.second.first, i.second.second);
h[i.second.first].push_back({i.second.second, i.first});
h[i.second.second].push_back({i.second.first, i.first});
}
dfs(1, 0);
for (long long int j = 1; j < 18; j++) {
for (long long int i = 1; i <= k; i++) {
p[i][j] = p[p[i][j - 1]][j - 1];
dp[i][j] = max(dp[i][j - 1], dp[p[i][j - 1]][j - 1]);
}
}
while (q--) {
long long int a, b;
cin >> a >> b;
cout << query(a, b) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 100;
const int MAXP = 20;
int n, m, k, q;
vector<vector<pair<int, long long>>> g;
vector<pair<pair<int, int>, long long>> sg;
vector<pair<long long, pair<int, int>>> sg2;
vector<int> pp;
vector<vector<pair<int, long long>>> dp;
vector<int> tin;
vector<int> tout;
vector<vector<pair<int, long long>>> g2;
int ttm = 0;
void dfs(int v, int p, long long x) {
tin[v] = ttm++;
dp[v].resize(MAXP);
dp[v][0] = make_pair((p), (x));
for (int i = 1; i < MAXP; ++i) {
dp[v][i].first = dp[dp[v][i - 1].first][i - 1].first;
dp[v][i].second =
max(dp[v][i - 1].second, dp[dp[v][i - 1].first][i - 1].second);
}
for (auto e : g2[v]) {
if (e.first != p) {
dfs(e.first, v, e.second);
}
}
tout[v] = ttm++;
}
bool ok(int v, int u) { return ((tin[v] <= tin[u]) && (tout[u] <= tout[v])); }
long long dp_g(int v, int u) {
if (ok(v, u)) return 0;
long long ans = 0;
for (int i = MAXP - 1; i >= 0; --i) {
if (!ok(dp[v][i].first, u)) {
ans = max(ans, dp[v][i].second);
v = dp[v][i].first;
}
}
return max(ans, dp[v][0].second);
}
long long dp_get(int v, int u) { return max(dp_g(v, u), dp_g(u, v)); }
void Init() {
pp.resize(k);
for (int i = 0; i < k; ++i) {
pp[i] = i;
}
}
int Get(int v) {
if (pp[v] == v) {
return v;
} else {
return (pp[v] = Get(pp[v]));
}
}
void Union(int v, int u) {
v = Get(v);
u = Get(u);
pp[u] = v;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m >> k >> q;
g.resize(n);
for (int i = 0; i < m; ++i) {
int v1, v2;
long long x;
cin >> v1 >> v2 >> x;
v1--;
v2--;
g[v1].push_back(make_pair((v2), (x)));
g[v2].push_back(make_pair((v1), (x)));
sg.push_back(make_pair((make_pair((v1), (v2))), (x)));
}
set<pair<long long, int>> st;
vector<long long> dist(n, INF);
vector<int> p(n);
for (int i = 0; i < k; ++i) {
dist[i] = 0;
p[i] = i;
st.insert(make_pair((0), (i)));
}
while (!st.empty()) {
int v = st.begin()->second;
st.erase(st.begin());
for (auto e : g[v]) {
int to = e.first;
long long w = e.second;
if (dist[to] > dist[v] + w) {
p[to] = p[v];
st.erase(make_pair((dist[to]), (to)));
dist[to] = dist[v] + w;
st.insert(make_pair((dist[to]), (to)));
}
}
}
for (auto e : sg) {
sg2.push_back(
make_pair((dist[e.first.first] + dist[e.first.second] + e.second),
(make_pair((p[e.first.first]), (p[e.first.second])))));
}
sort(sg2.begin(), sg2.end());
g2.resize(k);
Init();
for (auto e : sg2) {
if (Get(e.second.first) != Get(e.second.second)) {
g2[e.second.first].push_back(make_pair((e.second.second), (e.first)));
g2[e.second.second].push_back(make_pair((e.second.first), (e.first)));
Union(e.second.first, e.second.second);
}
}
dp.resize(k);
tin.resize(k);
tout.resize(k);
dfs(0, 0, 0);
while (q--) {
int a, b;
cin >> a >> b;
a--;
b--;
cout << dp_get(a, b) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NR = 1e6 + 10;
void Min(long long& x, long long y) { x = min(x, y); }
void Max(long long& x, long long y) { x = max(x, y); }
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m, k, q, S;
struct Edge {
int u, v;
long long w;
bool operator<(const Edge& A) const { return w < A.w; }
} e[NR];
int to[NR], nxt[NR], head[NR], tot = 1;
long long val[NR];
void add(int x, int y, long long z) {
to[tot] = y, val[tot] = z, nxt[tot] = head[x], head[x] = tot++;
}
struct Nd {
int x;
long long d;
bool operator<(const Nd& A) const { return d > A.d; }
};
Nd md(int x, long long d) {
Nd tmp;
tmp.x = x, tmp.d = d;
return tmp;
}
bool vis[NR];
long long dis[NR];
void dijkstra() {
memset(vis, 0, sizeof(vis));
memset(dis, 0x3f, sizeof(dis));
priority_queue<Nd> q;
q.push(md(S, 0));
dis[S] = 0;
while (!q.empty()) {
int x = q.top().x;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (dis[y] > dis[x] + val[i])
dis[y] = dis[x] + val[i], q.push(md(y, dis[y]));
}
}
}
struct bcj {
int fa[NR];
void init() {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int find(int x) { return (x == fa[x]) ? x : fa[x] = find(fa[x]); }
bool merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == fy) return 0;
fa[fx] = fy;
return 1;
}
} T;
void rebuild() {
memset(head, 0, sizeof(head));
tot = 1;
sort(e + 1, e + m + 1);
T.init();
int cnt = 0;
for (int i = 1; i <= m; i++) {
if (cnt >= n - 1) return;
if (T.merge(e[i].u, e[i].v))
add(e[i].u, e[i].v, e[i].w), add(e[i].v, e[i].u, e[i].w), cnt++;
}
}
int lg[NR], dep[NR], f[NR][20];
long long g[NR][20];
void dfs(int x, int fa_, long long v) {
dep[x] = dep[fa_] + 1;
f[x][0] = fa_;
g[x][0] = v;
for (int i = 1; i <= lg[dep[x]]; i++)
f[x][i] = f[f[x][i - 1]][i - 1],
g[x][i] = max(g[x][i - 1], g[f[x][i - 1]][i - 1]);
for (int i = head[x]; i; i = nxt[i])
if (to[i] != fa_) dfs(to[i], x, val[i]);
}
long long getmx(int x, int y) {
long long res = 0;
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y])
Max(res, g[x][lg[dep[x] - dep[y]] - 1]), x = f[x][lg[dep[x] - dep[y]] - 1];
if (x == y) return res;
for (int i = lg[dep[x]]; i >= 0; i--)
if (f[x][i] ^ f[y][i])
Max(res, g[x][i]), Max(res, g[y][i]), x = f[x][i], y = f[y][i];
return max(res, max(g[x][0], g[y][0]));
}
int main() {
n = read(), m = read(), k = read(), q = read();
for (int i = 1; i <= m; i++) {
e[i].u = read(), e[i].v = read(), e[i].w = read();
add(e[i].u, e[i].v, e[i].w), add(e[i].v, e[i].u, e[i].w);
}
for (int i = 1; i <= k; i++) add(S, i, 0);
dijkstra();
for (int i = 1; i <= m; i++) e[i].w += dis[e[i].u] + dis[e[i].v];
for (int i = 1; i <= n; i++) lg[i] = (lg[i - 1] + ((1 << lg[i - 1]) == i));
rebuild();
dfs(1, 0, 0);
for (int i = 1; i <= q; i++) {
int x = read(), y = read();
printf("%lld\n", getmx(x, y));
}
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)2e18;
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 long long N = 1e5 + 100;
const long long M = 21;
const long long mod = 1e9 + 7;
const long long MOD = 998244353;
const long long P = 1336;
const long double eps = 0.000000001;
const long long inf = 1e16 + 7;
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
vector<pair<long long, long long> > g[N], ng[N];
long long sz[N], pr[N], tin[N], tout[N];
long long tim = 0;
pair<long long, long long> w[N][M];
long long r[N];
long long get(long long v) {
if (pr[v] == v) return v;
return pr[v] = get(pr[v]);
}
void unite(long long a, long long b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
pr[b] = a;
}
void DFS(long long v, long long pr, long long zn) {
w[v][0].first = pr;
w[v][0].second = zn;
for (long long i = 1; i < M; i++) {
w[v][i].first = w[w[v][i - 1].first][i - 1].first;
w[v][i].second =
max(w[v][i - 1].second, w[w[v][i - 1].first][i - 1].second);
}
tim++;
tin[v] = tim;
for (auto to : ng[v]) {
if (to.first == pr) continue;
DFS(to.first, v, to.second);
}
tim++;
tout[v] = tim;
}
bool upper(long long a, long long b) {
return ((tin[a] <= tin[b]) && (tout[a] >= tout[b]));
}
long long LCA(long long a, long long b) {
if (upper(b, a)) swap(a, b);
long long mx = 0;
for (long long i = M - 1; i >= 0; i--) {
if (!upper(w[b][i].first, a)) {
mx = max(mx, w[b][i].second);
b = w[b][i].first;
}
}
mx = max(mx, w[b][0].second);
b = w[b][0].first;
for (long long i = M - 1; i >= 0; i--) {
if (!upper(w[a][i].first, b)) {
mx = max(mx, w[a][i].second);
a = w[a][i].first;
}
}
if (a != b) mx = max(mx, w[a][0].second);
return mx;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long n, m, k, T;
cin >> n >> m >> k >> T;
for (long long i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
x--;
y--;
g[x].push_back({y, z});
g[y].push_back({x, z});
}
for (long long i = 0; i < n; i++) {
r[i] = inf;
}
priority_queue<pair<long long, long long> > q;
for (long long i = 0; i < k; i++) {
q.push({0, i});
}
while (!q.empty()) {
long long v = q.top().second;
long long ra = q.top().first;
ra = -ra;
q.pop();
if (ra > r[v]) continue;
r[v] = ra;
for (auto to : g[v]) {
if (r[to.first] > r[v] + to.second) {
r[to.first] = r[v] + to.second;
q.push({-r[to.first], to.first});
}
}
}
vector<pair<long long, pair<long long, long long> > > e;
for (long long i = 0; i < n; i++) {
for (auto to : g[i]) {
e.push_back({r[i] + r[to.first] + to.second, {i, to.first}});
}
}
for (long long i = 0; i < n; i++) {
pr[i] = i;
sz[i] = 1;
}
sort(e.begin(), e.end());
for (auto to : e) {
if (get(to.second.first) != get(to.second.second)) {
unite(to.second.first, to.second.second);
ng[to.second.first].push_back({to.second.second, to.first});
ng[to.second.second].push_back({to.second.first, to.first});
}
}
DFS(0, 0, 0);
while (T--) {
long long a, b;
cin >> a >> b;
a--;
b--;
cout << LCA(a, b) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct ed {
long long u;
long long v;
long long cost;
bool operator<(const ed &e) const { return cost < e.cost; }
};
int n, m, k, q;
long long dist[300004];
int tin[300004], tout[300004], cnt, f[300004], sz[300004];
vector<ed> edges;
vector<pair<long long, long long> > graph[300004];
vector<pair<long long, long long> > mst[300004];
int par[300004][30];
long long wei[300004][30];
int fath(int x) { return (f[x] == x) ? x : fath(f[x]); }
bool is_same_set(int x, int y) {
int fx = fath(x);
int fy = fath(y);
return fx == fy;
}
void join(int x, int y) {
int fx = fath(x);
int fy = fath(y);
if (sz[fy] < sz[fx]) swap(fx, fy);
sz[fy] += sz[fx];
f[fx] = fy;
return;
}
void dijkstra() {
for (int i = k + 1; i < n + 1; i++) dist[i] = 1e18;
priority_queue<pair<long long, long long> > pq;
for (int i = 1; i < k + 1; i++) pq.push(make_pair(0, i));
while (!pq.empty()) {
pair<long long, long long> cur = pq.top();
pq.pop();
cur.first *= -1;
if (cur.first > dist[cur.second]) continue;
for (int i = 0; i < graph[cur.second].size(); i++) {
int v = graph[cur.second][i].first;
long long c = graph[cur.second][i].second;
if (dist[v] > cur.first + c) {
dist[v] = cur.first + c;
pq.push(make_pair(-dist[v], v));
}
}
}
return;
}
void init(int cur, int p) {
par[cur][0] = p;
tin[cur] = cnt++;
for (int i = 0; i < mst[cur].size(); i++) {
int v = mst[cur][i].first;
long long c = mst[cur][i].second;
if (v == p) continue;
wei[v][0] = c;
init(v, cur);
}
tout[cur] = cnt;
return;
}
bool is_ancestor(int x, int y) {
return (tin[x] <= tin[y] && tout[x] >= tout[y]);
}
int get_par(int node, int p) {
if (par[node][p] != -1) return par[node][p];
return par[node][p] = get_par(get_par(node, p - 1), p - 1);
}
long long get_wei(int node, int p) {
if (wei[node][p] != -1) return wei[node][p];
return wei[node][p] =
max(get_wei(get_par(node, p - 1), p - 1), get_wei(node, p - 1));
}
int get_lca(int x, int y) {
if (is_ancestor(x, y)) return x;
if (is_ancestor(y, x)) return y;
for (int i = 29; i >= 0; i--) {
if (!is_ancestor(get_par(x, i), y)) x = get_par(x, i);
}
return get_par(x, 0);
}
long long solve(int x, int y) {
int lca = get_lca(x, y);
long long ans = 0;
for (int i = 29; i >= 0; i--) {
if (!is_ancestor(get_par(x, i), lca)) {
ans = max(ans, get_wei(x, i));
x = get_par(x, i);
}
}
if (!is_ancestor(x, lca)) ans = max(ans, get_wei(x, 0));
for (int i = 29; i >= 0; i--) {
if (!is_ancestor(get_par(y, i), lca)) {
ans = max(ans, get_wei(y, i));
y = get_par(y, i);
}
}
if (!is_ancestor(y, lca)) ans = max(ans, get_wei(y, 0));
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k >> q;
for (int i = 0; i < m; i++) {
int a, b;
long long c;
cin >> a >> b >> c;
graph[a].push_back(make_pair(b, c));
graph[b].push_back(make_pair(a, c));
}
dijkstra();
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < graph[i].size(); j++) {
long long v = graph[i][j].first;
if (v < i) continue;
edges.push_back({i, v, dist[i] + dist[v] + graph[i][j].second});
}
}
sort(edges.begin(), edges.end());
for (int i = 1; i < n + 1; i++) {
sz[i] = 1;
f[i] = i;
}
for (int i = 0; i < edges.size(); i++) {
int u = edges[i].u;
int v = edges[i].v;
long long cost = edges[i].cost;
if (!is_same_set(u, v)) {
join(u, v);
mst[u].push_back(make_pair(v, cost));
mst[v].push_back(make_pair(u, cost));
}
}
memset(par, -1, sizeof par);
memset(wei, -1, sizeof wei);
wei[1][0] = 0;
init(1, 1);
for (int i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
cout << solve(a, b) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
const int MOD = 1e9 + 7;
const int MAXN = 300005;
struct Edge {
int u, v;
long long w;
bool operator<(const Edge &e) const { return w > e.w; }
};
int N, M, K, Q, vis[MAXN];
long long ans[MAXN], dist[MAXN];
vector<Edge> es, G[MAXN];
int pa[MAXN], sz[MAXN], root1[MAXN], root2[MAXN];
vector<int> qid[MAXN];
void init() {
for (int i = 1; i <= N; i++) {
pa[i] = i;
sz[i] = 1;
}
}
int find_root(int x) { return x == pa[x] ? x : pa[x] = find_root(pa[x]); }
void merge(Edge e) {
int u = find_root(e.u), v = find_root(e.v);
if (u == v) return;
if (sz[u] < sz[v]) swap(u, v);
pa[v] = u;
sz[u] += sz[v];
for (int q : qid[v]) {
if (root1[q] == u || root2[q] == u) {
root1[q] = root2[q] = -1;
ans[q] = e.w;
} else if (root1[q] != -1) {
if (root1[q] == v) root1[q] = u;
if (root2[q] == v) root2[q] = u;
qid[u].push_back(q);
}
}
qid[v].clear();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M >> K >> Q;
for (int i = 0; i < M; i++) {
int u, v, w;
cin >> u >> v >> w;
es.push_back({u, v, w});
G[u].push_back({u, v, w});
G[v].push_back({v, u, w});
}
priority_queue<Edge> pq;
for (int i = 1; i <= K; i++) {
pq.push({-1, i, 0});
}
while (!pq.empty()) {
Edge e = pq.top();
pq.pop();
if (vis[e.v]) continue;
vis[e.v] = 1;
dist[e.v] = e.w;
for (Edge e2 : G[e.v]) {
if (!vis[e2.v]) {
pq.push({-1, e2.v, e.w + e2.w});
}
}
}
for (int i = 0; i < Q; i++) {
int u, v;
cin >> u >> v;
qid[u].push_back(i);
qid[v].push_back(i);
root1[i] = u;
root2[i] = v;
}
for (Edge &e : es) {
e.w += dist[e.u] + dist[e.v];
}
sort(es.begin(), es.end());
init();
for (int i = (int)es.size() - 1; i >= 0; i--) {
merge(es[i]);
}
for (int i = 0; i < Q; i++) {
cout << ans[i] << "\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;
markers[a].erase(x);
} 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;
vector<pair<int, unsigned long long> > g[300001];
pair<int, unsigned long long> dist[300001];
pair<int, int> queries[300001];
int done[300001];
set<int> mp[300001];
unsigned long long result[300001];
void merge(int xs, int ys, unsigned long long w) {
for (set<int>::iterator it = mp[xs].begin(); it != mp[xs].end(); it++) {
unsigned long long x = *it;
if (mp[ys].find(x) == mp[ys].end()) {
mp[ys].insert(x);
} else {
result[x] = w;
}
}
}
struct find_union {
vector<int> S;
find_union(int n) : S(n) {
for (int i = 0; i < n; ++i) S[i] = i;
}
unsigned long long find(int a) { return S[a] == a ? a : (S[a] = find(S[a])); }
bool unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return false;
S[a] = b;
return true;
}
};
int main() {
int n, m, k, q;
cin >> n >> m >> k >> q;
unsigned long long inf = ULLONG_MAX;
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));
}
for (int i = 0; i < q; ++i) {
int a, b;
scanf("%d %d", &a, &b);
queries[i] = make_pair(a, b);
}
priority_queue<pair<unsigned long long, unsigned long long>,
vector<pair<unsigned long long, unsigned long long> >,
greater<pair<unsigned long long, unsigned long long> > >
qu;
for (int i = 1; i <= n; ++i) {
dist[i].first = i;
if (i <= k)
dist[i].second = 0;
else
dist[i].second = inf;
}
for (int i = 1; i <= k; ++i) {
qu.push(make_pair(0, i));
}
while (!qu.empty()) {
unsigned long long u = qu.top().second;
qu.pop();
if (done[u] == 0) {
done[u] = 1;
for (int i = 0; i < g[u].size(); ++i) {
unsigned long long v = g[u][i].first;
if (done[v] == 0) {
unsigned long long w = g[u][i].second;
if (dist[v].second > dist[u].second + w) {
dist[v].first = dist[u].first;
dist[v].second = dist[u].second + w;
qu.push(make_pair(dist[v].second, v));
}
}
}
}
}
map<pair<unsigned long long, unsigned long long>, unsigned long long> e;
for (unsigned long long v = 1; v <= n; ++v) {
for (unsigned long long j = 0; j < g[v].size(); ++j) {
unsigned long long u = g[v][j].first;
if (dist[v].first != dist[u].first) {
unsigned long long x = dist[v].first;
unsigned long long y = dist[u].first;
pair<unsigned long long, unsigned long long> p =
make_pair(min(x, y), max(x, y));
unsigned long long cost =
dist[v].second + dist[u].second + g[v][j].second;
if (e.find(p) == e.end()) {
e[p] = cost;
} else if (e[p] > cost) {
e[p] = cost;
}
}
}
}
vector<
pair<unsigned long long, pair<unsigned long long, unsigned long long> > >
edges;
for (map<pair<unsigned long long, unsigned long long>,
unsigned long long>::iterator it = e.begin();
it != e.end(); ++it) {
edges.push_back(make_pair(it->second, it->first));
}
sort(edges.begin(), edges.end());
vector<pair<unsigned long long, pair<int, int> > > tree;
find_union dsu(k + 1);
for (int i = 0; i < edges.size(); ++i) {
pair<int, int> ed = edges[i].second;
if (dsu.find(ed.first) != dsu.find(ed.second)) {
dsu.unite(ed.first, ed.second);
tree.push_back(edges[i]);
}
}
sort(tree.begin(), tree.end());
for (int i = 0; i < q; ++i) {
int a = queries[i].first;
int b = queries[i].second;
mp[a].insert(i);
mp[b].insert(i);
}
set<int> xs, ys;
find_union un(k + 1);
for (int i = 0; i < tree.size(); ++i) {
int a = tree[i].second.first;
int b = tree[i].second.second;
unsigned long long w = tree[i].first;
int x = un.find(a);
int y = un.find(b);
if (mp[x].size() < mp[y].size()) {
merge(x, y, w);
un.unite(x, y);
} else {
merge(y, x, w);
un.unite(y, x);
}
}
for (int i = 0; i < q; ++i) printf("%I64d\n", result[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct tree_edge {
int u, v;
long long w;
bool friend operator<(tree_edge i, tree_edge j) { return i.w < j.w; }
} edg[100039 * 3];
struct point {
int u, v;
long long w;
bool friend operator<(point i, point j) { return i.w > j.w; }
} stp;
struct edge {
int to, next;
long long w;
} grap[100039 << 3], tree[100039 << 1];
int n, m, k, q, tot[2], head[2][100039], fro[100039], fa[100039], dep[100039],
gra[100039][17];
long long dis[100039], mx[100039][17];
priority_queue<point> que;
void add(edge net[], int s, int u, int v, long long w) {
net[++tot[s]] = (edge){v, head[s][u], w}, head[s][u] = tot[s];
net[++tot[s]] = (edge){u, head[s][v], w}, head[s][v] = tot[s];
}
void dijkstra() {
que.push((point){0, 0, 0});
while (!que.empty()) {
stp = que.top(), que.pop();
if (dis[stp.v] == dis[n + 1]) {
dis[stp.v] = stp.w;
fro[stp.v] = (stp.v <= k ? stp.v : fro[stp.u]);
for (int a = head[0][stp.v]; a; a = grap[a].next) {
if (dis[grap[a].to] == dis[n + 1]) {
que.push((point){stp.v, grap[a].to, stp.w + grap[a].w});
}
}
}
}
}
int find(int k) { return fa[k] == k ? k : fa[k] = find(fa[k]); }
void dfs(int pos) {
dep[pos] = dep[gra[pos][0]] + 1;
for (int a = 1, b = 2; b <= dep[pos]; a++, b <<= 1) {
gra[pos][a] = gra[gra[pos][a - 1]][a - 1];
mx[pos][a] = max(mx[pos][a - 1], mx[gra[pos][a - 1]][a - 1]);
}
for (int a = head[1][pos]; a; a = tree[a].next) {
if (tree[a].to != gra[pos][0]) {
gra[tree[a].to][0] = pos;
mx[tree[a].to][0] = tree[a].w;
dfs(tree[a].to);
}
}
}
long long get_ans(int u, int v) {
long long res = 0;
if (dep[u] < dep[v]) swap(u, v);
for (int a = 16; ~a; a--) {
if (dep[gra[u][a]] >= dep[v]) {
res = max(res, mx[u][a]);
u = gra[u][a];
}
}
if (u == v) return res;
for (int a = 16; ~a; a--) {
if (gra[u][a] != gra[v][a]) {
res = max(res, mx[u][a]), u = gra[u][a];
res = max(res, mx[v][a]), v = gra[v][a];
}
}
res = max(res, mx[u][0]);
res = max(res, mx[v][0]);
return res;
}
int main() {
memset(dis, 63, sizeof(dis));
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int a = 1, b, c, d; a <= m; a++) {
scanf("%d%d%d", &b, &c, &d);
add(grap, 0, b, c, d);
}
for (int a = 1; a <= k; a++) {
add(grap, 0, 0, a, 0);
}
dijkstra();
for (int a = 1; a <= n; a++) {
for (int b = head[0][a]; b; b = grap[b].next) {
if (grap[b].to && b % 2) {
edg[b / 2 + 1].u = fro[a], edg[b / 2 + 1].v = fro[grap[b].to];
edg[b / 2 + 1].w = dis[a] + grap[b].w + dis[grap[b].to];
}
}
fa[a] = a;
}
sort(edg + 1, edg + m + 1);
for (int a = 1, b, c; a <= m; a++) {
b = find(edg[a].u), c = find(edg[a].v);
if (b != c) {
add(tree, 1, edg[a].u, edg[a].v, edg[a].w);
fa[c] = b;
}
}
dep[0] = -1, dfs(1);
for (int a = 1, b, c; a <= q; a++) {
scanf("%d%d", &b, &c);
printf("%I64d\n", get_ans(b, c));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const unordered_set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const unordered_map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const multiset<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
long long idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % 1000000007;
y = y / 2, x = (x * x) % 1000000007;
}
return res % 1000000007;
}
struct UnionFind {
long long n, set_size, *parent, *rank;
UnionFind() {}
UnionFind(long long a) {
n = set_size = a;
parent = new long long[n + 1];
rank = new long long[n + 1];
for (long long i = 1; i <= n; ++i) parent[i] = i, rank[i] = 1;
}
long long find(long long x) {
if (x != parent[x]) return parent[x] = find(parent[x]);
return x;
}
void merge(long long x, long long y) {
long long xroot = find(x), yroot = find(y);
if (xroot != yroot) {
if (rank[xroot] >= rank[yroot]) {
parent[yroot] = xroot;
rank[xroot] += rank[yroot];
} else {
parent[xroot] = yroot;
rank[yroot] += rank[xroot];
}
set_size -= 1;
}
}
void reset() {
set_size = n;
for (long long i = 1; i <= n; i++) parent[i] = i, rank[i] = 1;
}
long long size() { return set_size; }
void prll() {
for (long long i = 1; i <= n; ++i) cout << i << " -> " << parent[i] << "\n";
}
};
vector<vector<pair<long long, long long>>> g;
bool vis[100001];
long long dis[100001];
long long col[100001];
class prioritize {
public:
bool operator()(pair<long long, long long>& p1,
pair<long long, long long>& p2) {
return p1.second > p2.second;
}
};
vector<vector<pair<long long, long long>>> kconnect;
long long par[100100][19];
long long depth[100100];
long long dp[100100][19];
void dfs(long long nn, long long pp, long long dd, long long mm) {
par[nn][0] = pp;
dp[nn][0] = mm;
depth[nn] = dd;
for (long long i = 1; i <= 18; i++) {
par[nn][i] = par[par[nn][i - 1]][i - 1];
dp[nn][i] = max(dp[nn][i - 1], dp[par[nn][i - 1]][i - 1]);
}
for (auto v : kconnect[nn]) {
if (v.first == pp) continue;
dfs(v.first, nn, dd + 1, v.second);
}
}
long long lcalol(long long u, long long v) {
if (depth[u] < depth[v]) swap(u, v);
long long ans = 0;
for (long long i = 18; i >= 0; i--) {
if (depth[u] - depth[v] >= (1LL << i))
ans = max(ans, dp[u][i]), u = par[u][i];
}
if (u == v) return ans;
for (long long i = 18; i >= 0; i--) {
if (par[u][i] != par[v][i]) {
ans = max(ans, max(dp[u][i], dp[v][i]));
u = par[u][i];
v = par[v][i];
}
}
ans = max(ans, max(dp[u][0], dp[v][0]));
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k, q, i;
cin >> n >> m >> k >> q;
g.resize(n + 1);
set<pair<long long, pair<long long, long long>>> edges;
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
g[a].emplace_back(b, c);
g[b].emplace_back(a, c);
}
for (long long i = 1; i <= n; i++) {
vis[i] = 0;
dis[i] = 1e18;
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
prioritize>
pq;
for (i = 1; i <= k; i++) {
pq.push(make_pair(i, 0));
dis[i] = 0;
col[i] = i;
}
while (!pq.empty()) {
pair<long long, long long> top = pq.top();
pq.pop();
long long uu = top.first;
long long vv = top.second;
if (vis[uu]) continue;
vis[uu] = 1;
for (auto v : g[uu]) {
if (vis[v.first]) {
if (col[v.first] != col[uu]) {
edges.insert(make_pair(dis[v.first] + dis[uu] + v.second,
make_pair(min(col[uu], col[v.first]),
max(col[uu], col[v.first]))));
}
} else {
if (vv + v.second < dis[v.first]) {
dis[v.first] = vv + v.second;
col[v.first] = col[uu];
pq.push(make_pair(v.first, dis[v.first]));
}
}
}
}
kconnect.resize(k + 1);
UnionFind uf(k);
long long sz = k;
for (auto v : edges) {
if (uf.find(v.second.first) != uf.find(v.second.second)) {
kconnect[v.second.first].emplace_back(v.second.second, v.first);
kconnect[v.second.second].emplace_back(v.second.first, v.first);
uf.merge(v.second.first, v.second.second);
sz--;
}
if (sz == 1) break;
}
dfs(1, 0, 0, 0);
for (long long i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
cout << lcalol(a, b) << "\n";
}
}
|
#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];
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];
tmp.clear();
for (int j = 0; j < (int)qr[u].size(); j++) {
if (fnd(qr[u][j].first) == x)
rs[qr[u][j].second] = w;
else
tmp.push_back(qr[u][j]);
}
qr[u] = tmp;
v[x].push_back(u);
}
for (int i = 0; i < (int)v[y].size(); i++) {
u = v[y][i];
p[u] = x;
}
v[y].clear();
sz[x] += sz[y];
}
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);
}
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>
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 LCA = [&](int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
int diff = dep[v] - dep[u];
for (int i = 0; i < LOG; i++) {
if (diff & (1 << i)) {
v = anc[v][i];
}
}
if (u == v) return u;
for (int i = LOG - 1; i >= 0; i--) {
int pu = anc[u][i], pv = anc[v][i];
if (pu != pv) {
u = pu, v = pv;
}
}
return anc[u][0];
};
auto get_path = [&](int u, int l) {
int diff = dep[u] - dep[l];
LL res = 0;
for (int i = 0; i < LOG; i++) {
if (diff & (1 << i)) {
res = max(res, best[u][i]);
u = anc[u][i];
}
}
return res;
};
while (q--) {
int a, b;
cin >> a >> b;
a--, b--;
int l = LCA(a, b);
LL ans = max(get_path(a, l), get_path(b, l));
cout << ans << '\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> > 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;
Q.pop();
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;
struct data {
int y, z, nxt;
} e[600010];
struct edge {
int x, y;
long long z;
} a[300010];
struct qwq {
long long dis;
int x;
};
struct que {
int x, y, id;
} b[300010];
vector<que> v[200010];
bool operator<(const qwq &u, const qwq &v) { return u.dis > v.dis; }
long long ans[300010];
long long dis[200010];
int siz[200010];
int head[200010];
bool vis[200010];
int f[200010];
priority_queue<qwq> q;
int n, m, k, Q, cnt;
void add(int x, int y, long long z) {
cnt++;
e[cnt].y = y;
e[cnt].z = z;
e[cnt].nxt = head[x];
head[x] = cnt;
}
bool cmp(edge x, edge y) { return x.z < y.z; }
int find(int x) { return x != f[x] ? f[x] = find(f[x]) : x; }
void dijkstra() {
for (int i = 1; i <= k; i++) {
q.push((qwq){0, i});
dis[i] = 0;
}
while (!q.empty()) {
qwq x = q.top();
q.pop(), vis[x.x] = 0;
for (int i = head[x.x]; i; i = e[i].nxt) {
int y = e[i].y, z = e[i].z;
if (dis[y] > dis[x.x] + z) {
dis[y] = dis[x.x] + z;
if (!vis[y]) {
q.push((qwq){dis[y], y});
vis[y] = true;
}
}
}
}
}
int main() {
int x, y, z;
scanf("%d%d%d%d", &n, &m, &k, &Q);
for (int i = 1; i <= n; i++) {
dis[i] = 1e17;
f[i] = i, siz[i] = 1;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &a[i].x, &a[i].y, &a[i].z);
add(a[i].x, a[i].y, a[i].z);
add(a[i].y, a[i].x, a[i].z);
}
dijkstra();
for (int i = 1; i <= m; i++) a[i].z += dis[a[i].x] + dis[a[i].y];
sort(a + 1, a + m + 1, cmp);
for (int i = 1; i <= Q; i++) {
b[i].id = i;
scanf("%d%d", &b[i].x, &b[i].y);
v[b[i].x].push_back(b[i]);
v[b[i].y].push_back(b[i]);
}
for (int i = 1; i <= m; i++) {
int x = a[i].x, y = a[i].y;
long long z = a[i].z;
int fx = find(x), fy = find(y);
if (fx == fy) continue;
if (siz[fx] < siz[fy]) swap(fx, fy);
f[fy] = fx, siz[fx] += siz[fy];
for (int j = 0; j < v[fy].size(); j++) {
if (find(v[fy][j].x) == find(v[fy][j].y) && !ans[v[fy][j].id])
ans[v[fy][j].id] = z;
else
v[fx].push_back(v[fy][j]);
}
}
for (int i = 1; i <= Q; i++) printf("%lld\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const int LOG = 20;
int n, m, q, k;
int v1[N], v2[N], w[N];
vector<pair<long long, int> > v[N], T[N];
long long dis[N];
int tko[N], par[N];
int lca[N][LOG], dep[N];
long long dp_lca[N][LOG];
int pr(int x) {
if (par[x] == x) return x;
return par[x] = pr(par[x]);
}
void mrg(int x, int y) { par[pr(x)] = pr(y); }
void dfs(int x, int lst) {
lca[x][0] = lst;
dep[x] = dep[lst] + 1;
for (pair<long long, int> nxt : T[x]) {
if (nxt.second == lst) continue;
dp_lca[nxt.second][0] = nxt.first;
dfs(nxt.second, x);
}
}
void precompute() {
for (int j = 1; j < LOG; j++) {
for (int i = 1; i <= n; i++) {
lca[i][j] = lca[lca[i][j - 1]][j - 1];
dp_lca[i][j] = max(dp_lca[i][j - 1], dp_lca[lca[i][j - 1]][j - 1]);
}
}
}
long long get_lca(int x, int y) {
long long ans = 0;
if (dep[x] < dep[y]) swap(x, y);
for (int i = LOG - 1; i >= 0; i--)
if (dep[x] - (1 << i) >= dep[y]) {
ans = max(ans, dp_lca[x][i]);
x = lca[x][i];
}
if (x == y) return ans;
for (int i = LOG - 1; i >= 0; i--)
if (lca[x][i] != lca[y][i]) {
ans = max(ans, max(dp_lca[x][i], dp_lca[y][i]));
x = lca[x][i], y = lca[y][i];
}
return max(ans, max(dp_lca[x][0], dp_lca[y][0]));
}
void dijkstra() {
memset(dis, -1, sizeof(dis));
set<pair<long long, int> > S;
for (int i = 1; i <= k; i++)
S.insert({0LL, i}), dis[i] = 0, tko[i] = i, par[i] = i;
for (; !S.empty();) {
pair<long long, int> cur = *S.begin();
S.erase(S.begin());
for (pair<long long, int> nxt : v[cur.second]) {
if (dis[nxt.second] == -1 ||
dis[cur.second] + nxt.first < dis[nxt.second]) {
if (dis[nxt.second] != -1) S.erase({dis[nxt.second], nxt.second});
dis[nxt.second] = dis[cur.second] + nxt.first;
tko[nxt.second] = tko[cur.second];
S.insert({dis[nxt.second], nxt.second});
}
}
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", v1 + i, v2 + i, w + i);
v[v1[i]].push_back({w[i], v2[i]});
v[v2[i]].push_back({w[i], v1[i]});
}
dijkstra();
vector<pair<long long, pair<int, int> > > edg;
for (int i = 0; i < m; i++) {
if (tko[v1[i]] != tko[v2[i]]) {
edg.push_back({dis[v1[i]] + dis[v2[i]] + w[i], {tko[v1[i]], tko[v2[i]]}});
}
}
sort(edg.begin(), edg.end());
for (pair<long long, pair<int, int> > E : edg) {
if (pr(E.second.first) == pr(E.second.second)) continue;
mrg(E.second.first, E.second.second);
T[E.second.first].push_back({E.first, E.second.second});
T[E.second.second].push_back({E.first, E.second.first});
}
dfs(1, 1);
precompute();
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y);
printf("%lld\n", get_lca(x, y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const long long inf = (long long)1e15;
int n, m, k, q, cnt, last[N], fro[N], f[N], sz[N];
long long dis[N], val[N];
struct edge {
int to, next;
long long w;
} e[N * 6];
struct data {
int x, y;
long long w;
} a[N * 3];
std::priority_queue<std::pair<long long, int> > que;
bool vis[N];
void addedge(int u, int v, long long w) {
e[++cnt].to = v;
e[cnt].w = w;
e[cnt].next = last[u];
last[u] = cnt;
e[++cnt].to = u;
e[cnt].w = w;
e[cnt].next = last[v];
last[v] = cnt;
}
void dij() {
for (int i = 1; i <= k; i++)
dis[i] = 0, fro[i] = i, que.push(std::make_pair(0, i));
for (int i = k + 1; i <= n; i++) dis[i] = inf;
while (!que.empty()) {
int u = que.top().second;
que.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = last[u]; i; i = e[i].next)
if (dis[u] + e[i].w < dis[e[i].to]) {
dis[e[i].to] = dis[u] + e[i].w;
fro[e[i].to] = fro[u];
que.push(std::make_pair(-dis[e[i].to], e[i].to));
}
}
}
bool cmp(data a, data b) { return a.w < b.w; }
int find(int x) { return f[x] == x ? x : find(f[x]); }
long long query(int x, int y) {
long long ans = 0;
while (x != y) {
if (sz[x] > sz[y]) std::swap(x, y);
ans = std::max(ans, val[x]);
x = f[x];
}
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= m; i++) {
int x, y;
long long w;
scanf("%d%d%lld", &x, &y, &w);
addedge(x, y, w);
}
dij();
for (int i = 1; i <= cnt; i += 2) {
int x = e[i].to, y = e[i + 1].to;
long long w = dis[x] + dis[y] + e[i].w;
a[i / 2 + 1] = (data){fro[x], fro[y], w};
}
std::sort(a + 1, a + m + 1, cmp);
for (int i = 1; i <= k; i++) f[i] = i, sz[i] = 1;
for (int i = 1; i <= m; i++) {
int x = find(a[i].x), y = find(a[i].y);
if (x == y) continue;
if (sz[x] > sz[y]) std::swap(x, y);
f[x] = y;
sz[y] += sz[x];
val[x] = a[i].w;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%lld\n", query(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
using V = vector<T>;
template <int NV>
class Dsu {
vector<int> ancestor;
public:
Dsu() {
ancestor.resize(NV);
init();
}
inline void init(int n = NV) {
iota(ancestor.begin(), next(ancestor.begin(), n), 0);
}
inline int find(int x) {
if (x == ancestor[x]) return x;
return ancestor[x] = find(ancestor[x]);
}
inline bool unite(int u, int v) {
int a = find(u), b = find(v);
if (a == b) return false;
return (ancestor[b] = a), true;
}
};
struct edge {
int v;
ll w;
};
Dsu<202020> D;
int n, m, k, q;
bool vis[202020];
V<edge> G[202020];
V<tuple<ll, int, int>> E;
int anc[202020][20], dep[202020];
ll dis[202020], weight[202020][20];
void dfs(int u, int f) {
anc[u][0] = f;
for (int i = 1; i < 20; i++) {
anc[u][i] = anc[anc[u][i - 1]][i - 1];
weight[u][i] = max(weight[u][i - 1], weight[anc[u][i - 1]][i - 1]);
}
for (auto& e : G[u]) {
if (e.v != f) {
dep[e.v] = dep[u] + 1;
weight[e.v][0] = e.w;
dfs(e.v, u);
}
}
}
ll getans(int x, int y) {
ll ret = 0;
if (dep[x] < dep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (dep[anc[x][i]] >= dep[y]) {
ret = max(ret, weight[x][i]);
x = anc[x][i];
}
}
if (x == y) return ret;
for (int i = 19; i >= 0; i--) {
if (anc[x][i] != anc[y][i]) {
ret = max({ret, weight[x][i], weight[y][i]});
x = anc[x][i], y = anc[y][i];
}
}
return max({ret, weight[x][0], weight[y][0]});
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
G[x].push_back({y, z}), G[y].push_back({x, z});
}
priority_queue<pair<ll, int>> Q;
for (int i = 1; i <= n; i++) {
if (i <= k) {
dis[i] = 0, Q.push({0, i});
} else {
dis[i] = 1ll << 60;
}
}
while (!Q.empty()) {
int u = Q.top().second;
Q.pop();
if (vis[u]) {
continue;
}
vis[u] = 1;
for (auto& e : G[u]) {
if (!vis[e.v] && dis[e.v] > dis[u] + e.w) {
dis[e.v] = dis[u] + e.w;
Q.push({-dis[e.v], e.v});
}
}
}
for (int u = 1; u <= n; u++) {
for (auto& e : G[u]) {
if (u < e.v) {
E.push_back({dis[u] + dis[e.v] + e.w, u, e.v});
}
}
G[u].clear();
}
sort(E.begin(), E.end());
for (int i = 0; i < ((int)E.size()); i++) {
ll z;
int x, y;
tie(z, x, y) = E[i];
if (D.unite(x, y)) {
G[x].push_back({y, z}), G[y].push_back({x, z});
}
}
dfs(1, 0);
while (q--) {
int x, y;
cin >> x >> y;
cout << getans(x, y) << "\n";
}
}
|
#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)2e18;
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> > 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;
Q.pop();
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 N = 100000;
const long long oo = 1e18;
int n, e, k, Q;
vector<vector<pair<int, long long> > > g;
int p[N];
int find(int u) {
if (p[u] == u) return u;
return p[u] = find(p[u]);
}
pair<int, long long> dp[17][N];
long long mx[N];
int d[N];
void DFS(int u, int p) {
for (auto e : g[u]) {
if (e.first == p) continue;
dp[0][e.first] = {u, e.second};
d[e.first] = d[u] + 1;
DFS(e.first, u);
}
}
long long calc(int u, int v) {
if (d[u] < d[v]) swap(u, v);
int l = 0;
while ((1 << l) <= d[u]) ++l;
--l;
long long res = 0;
for (int i = l; i >= 0; --i)
if (d[u] - (1 << i) >= d[v]) {
res = max(res, dp[i][u].second);
u = dp[i][u].first;
}
if (u == v) return res;
for (int i = l; i >= 0; --i)
if (dp[i][u].first != dp[i][v].first) {
res = max(res, dp[i][u].second);
res = max(res, dp[i][v].second);
u = dp[i][u].first;
v = dp[i][v].first;
}
res = max(res, dp[0][u].second);
res = max(res, dp[0][v].second);
return res;
}
int main() {
scanf("%d%d%d%d", &n, &e, &k, &Q);
g.resize(n);
for (int a, b, c, i = 0; i < e; ++i) {
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
g[a].push_back({b, c});
swap(a, b);
g[a].push_back({b, c});
}
vector<long long> cost(k);
cost.resize(n, oo);
vector<bool> vis(n);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
for (int i = 0; i < k; ++i) q.push({0, i});
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = true;
for (auto e : g[u])
if (cost[e.first] > cost[u] + e.second) {
cost[e.first] = cost[u] + e.second;
q.push({cost[e.first], e.first});
}
}
vector<pair<long long, pair<int, int> > > edges;
for (int u = 0; u < n; ++u)
for (auto e : g[u]) {
int v = e.first;
edges.push_back({cost[u] + cost[v] + e.second, {u, v}});
}
sort(edges.begin(), edges.end());
g.clear();
g.resize(n);
for (int i = 0; i < n; ++i) p[i] = i;
for (auto e : edges) {
int u = e.second.first;
int v = e.second.second;
if (find(u) != find(v)) {
g[u].push_back({v, e.first});
g[v].push_back({u, e.first});
p[find(u)] = find(v);
}
}
memset(dp, -1, sizeof(dp));
DFS(0, -1);
for (int k = 1; k < 17; ++k)
for (int i = 0; i < n; ++i)
if (dp[k - 1][i].first != -1) {
dp[k][i].first = dp[k - 1][dp[k - 1][i].first].first;
dp[k][i].second =
max(dp[k - 1][i].second, dp[k - 1][dp[k - 1][i].first].second);
}
while (Q--) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
printf("%lld\n", calc(u, v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using p_que = priority_queue<T, vector<T>, greater<T>>;
constexpr int N = 112345, M = 18;
vector<pair<int, long long>> g[N];
p_que<pair<long long, pair<int, int>>> que;
int u[N];
long long d[N];
class UF {
public:
int p[N], d[N] = {};
UF() { iota(p, p + N, 0); }
int grp(int a) {
auto &ret = p[a];
if (ret != a) ret = grp(ret);
return ret;
}
bool mrg(int a, int b) {
a = grp(a), b = grp(b);
if (a == b) return false;
if (d[a] > d[b]) swap(a, b);
p[a] = b;
((d[b]) = max((d[b]), (d[a] + 1)));
return true;
}
} uf;
class {
public:
vector<pair<int, long long>> g[N];
void edge(int a, int b, long long p) {
g[a].emplace_back(b, p);
g[b].emplace_back(a, p);
}
int p[N][M] = {};
int d[N];
long long c[N][M];
void build() {
d[0] = 0;
fill(c[0], c[0] + M, 0);
dfs(0);
}
void dfs(int a) {
for (auto &e : g[a]) {
int b = e.first;
if (b == p[a][0]) continue;
p[b][0] = a;
for (int i = (1); i < (M); i++) p[b][i] = p[p[b][i - 1]][i - 1];
d[b] = d[a] + 1;
c[b][0] = e.second;
for (int i = (1); i < (M); i++)
c[b][i] = max(c[b][i - 1], c[p[b][i - 1]][i - 1]);
dfs(b);
}
}
long long ans(int a, int b) {
if (d[a] > d[b]) swap(a, b);
;
long long ret = 0;
;
for (int i = M - 1; i >= 0; i--) {
if (d[a] <= (d[b] - (1 << i))) {
;
((ret) = max((ret), (c[b][i])));
b = p[b][i];
}
};
for (int i = M - 1; i >= 0; i--) {
if (p[a][i] != p[b][i]) {
;
((ret) = max((ret), (c[a][i])));
((ret) = max((ret), (c[b][i])));
a = p[a][i];
b = p[b][i];
}
}
if (a != b) {
;
((ret) = max((ret), (c[a][0])));
((ret) = max((ret), (c[b][0])));
}
return ret;
}
} t;
int main() {
int n, m, k, q;
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);
u--;
v--;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
};
fill(u, u + N, -1);
for (int i = (0); i < ((k)); i++) que.emplace(0, make_pair(i, i));
while (que.size()) {
auto tp = que.top();
que.pop();
int i = tp.second.first;
if (~u[i]) continue;
u[i] = tp.second.second;
d[i] = tp.first;
;
for (auto &e : g[i]) {
int j = e.first;
que.emplace(d[i] + e.second, make_pair(j, u[i]));
}
};
while (que.size()) que.pop();
for (int i = (0); i < ((n)); i++)
for (auto &e : g[i]) {
int j = e.first;
if (u[i] >= u[j]) continue;
;
que.emplace(d[i] + d[j] + e.second, make_pair(u[i], u[j]));
};
while (que.size()) {
auto tp = que.top();
que.pop();
int i = tp.second.first, j = tp.second.second;
if (!uf.mrg(i, j)) continue;
;
t.edge(i, j, tp.first);
}
t.build();
for (int iq = (0); iq < ((q)); iq++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
printf("%lld\n", t.ans(a, b));
}
}
|
#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] = max(drank[a], drank[b] + 1);
} else {
dsu[a] = b;
swap(a, b);
drank[a] = max(drank[a], drank[b] + 1);
}
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;
}
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>
const int INF = (int)1e9 + 7;
const int N = (int)3e5 + 7;
const int MAXN = (int)5e5 + 228;
using namespace std;
int n, m, k, q;
int came[N];
long long d[N];
vector<pair<int, int> > g[N];
vector<pair<long long, pair<int, int> > > edges;
void shortest_paths() {
set<pair<long long, int> > S;
for (int i = 1; i <= k; ++i) {
d[i] = 0;
came[i] = i;
S.insert(make_pair(d[i], i));
}
for (int i = k + 1; i <= n; ++i) d[i] = (long long)1e18;
while (!S.empty()) {
int v = S.begin()->second;
S.erase(S.begin());
for (auto &it : g[v]) {
int to = it.first, w = it.second;
if (d[to] > d[v] + w) {
S.erase(make_pair(d[to], to));
d[to] = d[v] + w;
came[to] = came[v];
S.insert(make_pair(d[to], to));
}
}
}
}
void construct() {
for (int i = 1; i <= n; ++i) {
for (auto &it : g[i]) {
int to = it.first;
if (came[to] != came[i]) {
edges.push_back(
make_pair(it.second + d[to] + d[i], make_pair(came[to], came[i])));
}
}
}
sort(edges.begin(), edges.end());
}
int p[N];
set<int> queries[N];
void init() {
for (int i = 1; i <= n; ++i) p[i] = i;
}
int get(int v) {
if (v == p[v]) return v;
return p[v] = get(p[v]);
}
long long ans[N];
void unite(int v, int u, long long w) {
v = get(v);
u = get(u);
if (u == v) return;
if (queries[v].size() < queries[u].size()) swap(v, u);
for (auto &to : queries[u]) {
if (queries[v].count(to)) {
queries[v].erase(to);
ans[to] = w;
} else {
queries[v].insert(to);
}
}
queries[u].clear();
p[u] = v;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; ++i) {
int x, y, z;
cin >> x >> y >> z;
g[x].push_back(make_pair(y, z));
g[y].push_back(make_pair(x, z));
}
init();
for (int i = 1; i <= q; ++i) {
int x, y;
cin >> x >> y;
queries[x].insert(i);
queries[y].insert(i);
}
shortest_paths();
construct();
for (auto &to : edges) {
int x = to.second.first, y = to.second.second;
long long w = to.first;
unite(x, y, w);
}
for (int i = 1; i <= q; ++i) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
void solve() {
int n, m, k, q;
cin >> n >> m >> k >> q;
vector<vector<pair<int, int>>> adj(n);
for (int i = (0); i < (m); ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
vector<tuple<long long, int, int>> edges;
map<pair<int, int>, long long> d;
vector<int> ids(n, -1);
priority_queue<tuple<long long, int, int>> heap;
for (int u = (0); u < (k); ++u) {
d[make_pair(u, u)] = 0, ids[u] = u, heap.push({-d[make_pair(u, u)], u, u});
}
while (int((heap).size())) {
long long t;
int u, v;
tie(t, u, v) = heap.top();
t = -t;
heap.pop();
if (d[make_pair(u, v)] ^ t) continue;
if (ids[u] != -1 && ids[u] != v) {
edges.push_back({d[make_pair(u, ids[u])] + t, ids[u], v});
} else {
ids[u] = v;
for (auto e : adj[u]) {
int nu = e.first;
int w = e.second;
if (!d.count(make_pair(nu, v))) d[make_pair(nu, v)] = LINF;
if (chkmin(d[make_pair(nu, v)], d[make_pair(u, v)] + w)) {
heap.push({-d[make_pair(nu, v)], nu, v});
}
}
}
}
sort((edges).begin(), (edges).end());
vector<int> dj(n);
function<int(int)> find = [&](int u) {
return dj[u] == u ? dj[u] : dj[u] = find(dj[u]);
};
auto join = [&](int u, int v) {
u = find(u);
v = find(v);
if (u ^ v) {
dj[u] = v;
return 1;
}
return 0;
};
for (int u = (0); u < (n); ++u) dj[u] = u;
vector<vector<pair<int, long long>>> adj2(k);
for (auto e : edges) {
int u, v;
long long w;
tie(w, u, v) = e;
if (join(u, v)) {
adj2[u].push_back({v, w});
adj2[v].push_back({u, w});
}
}
int logn = 20;
vector<int> lev(n);
vector<vector<int>> par(logn, vector<int>(n));
vector<vector<long long>> val(logn, vector<long long>(n));
function<void(int, int)> dfs = [&](int u, int p) {
for (int i = (1); i < (logn); ++i) {
par[i][u] = par[i - 1][par[i - 1][u]];
val[i][u] = max(val[i - 1][u], val[i - 1][par[i - 1][u]]);
}
for (auto e : adj2[u]) {
int v = e.first;
long long w = e.second;
if (v ^ p) {
lev[v] = lev[u] + 1;
par[0][v] = u;
val[0][v] = w;
dfs(v, u);
}
}
};
auto query = [&](int u, int v) {
if (lev[u] < lev[v]) swap(u, v);
long long res = 0;
for (int i = (logn)-1; i >= (0); --i) {
if (lev[v] <= lev[par[i][u]]) {
chkmax(res, val[i][u]);
u = par[i][u];
}
}
if (u == v) return res;
for (int i = (logn)-1; i >= (0); --i) {
if (par[i][u] ^ par[i][v]) {
chkmax(res, val[i][u]);
chkmax(res, val[i][v]);
u = par[i][u];
v = par[i][v];
}
}
chkmax(res, val[0][u]);
chkmax(res, val[0][v]);
return res;
};
dfs(0, -1);
while (q--) {
int u, v;
cin >> u >> v;
u--, v--;
cout << query(u, v) << "\n";
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
solve();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int kMaxN = 1e5 + 3;
constexpr ll inf = 1e18 + 7;
vector<pair<int, int>> edges[kMaxN];
int parent[kMaxN];
int r[kMaxN];
unordered_set<int> tokens[kMaxN];
int find_parent(int u) {
if (u == parent[u]) {
return u;
}
return parent[u] = find_parent(parent[u]);
}
vector<int> unite(int u, int v) {
u = find_parent(u), v = find_parent(v);
if (u == v) {
return {};
}
if (r[u] < r[v]) {
swap(u, v);
}
if (r[u] == r[v]) {
++r[u];
}
parent[v] = u;
vector<int> connected;
for (int token : tokens[v]) {
if (tokens[u].count(token)) {
connected.emplace_back(token);
} else {
tokens[u].emplace(token);
}
}
return connected;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.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;
edges[u].emplace_back(v, w);
edges[v].emplace_back(u, w);
}
vector<ll> d(n, inf);
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>>
pq;
for (int i = 0; i < k; ++i) {
d[i] = 0;
pq.emplace(0, i);
}
while (!pq.empty()) {
auto [du, u] = pq.top();
pq.pop();
if (du != d[u]) {
continue;
}
for (auto [v, w] : edges[u]) {
if (du + w < d[v]) {
d[v] = du + w;
pq.emplace(d[v], v);
}
}
}
vector<tuple<ll, int, int>> all_edges;
all_edges.reserve(m);
for (int u = 0; u < n; ++u) {
for (auto& [v, w] : edges[u]) {
if (u < v) {
all_edges.emplace_back(w + d[u] + d[v], u, v);
}
}
parent[u] = u;
}
sort(all_edges.begin(), all_edges.end());
for (int i = 0; i < q; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
tokens[u].emplace(i);
tokens[v].emplace(i);
}
vector<ll> queries(q);
for (auto [w, u, v] : all_edges) {
for (int query : unite(u, v)) {
queries[query] = w;
}
}
for (ll query : queries) {
cout << query << '\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] = max(drank[a], drank[b] + 1);
} else {
dsu[a] = b;
swap(a, b);
drank[a] = max(drank[a], drank[b] + 1);
}
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;
markers[a].erase(x);
} 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>
const int N = 3e5 + 5;
struct Edge {
int u;
int v;
long long w;
int next;
bool operator<(const Edge& other) const { return w < other.w; }
};
int head[N];
Edge e[2 * N];
struct Node {
int u;
long long w;
Node(int u, long long w) : u(u), w(w) {}
bool operator<(const Node& other) const { return w > other.w; }
};
long long dis[N];
int fix[N];
int p[N];
int Head[N];
Edge E[2 * N];
long long f[N][19 + 5];
long long w[N][19 + 5];
int Q[N];
void addEdge(int u, int v, long long w, int& size) {
size++;
e[size].u = u;
e[size].v = v;
e[size].w = w;
e[size].next = head[u];
head[u] = size;
}
void dijkstra(int n, int k) {
std::priority_queue<Node> Q;
for (int i = 1; i <= n; i++) {
if (i > k)
dis[i] = 1e18 + 7;
else {
dis[i] = 0;
Q.push(Node(i, 0));
}
}
while (Q.size()) {
while (Q.size() && fix[Q.top().u]) Q.pop();
if (!Q.size()) break;
int u = Q.top().u;
dis[u] = Q.top().w;
fix[u] = 1;
Q.pop();
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (!fix[v] && dis[u] + e[i].w < dis[v]) {
dis[v] = dis[u] + e[i].w;
Q.push(Node(v, dis[v]));
}
}
}
}
int find(int u) {
if (p[u] == u)
return u;
else
return p[u] = find(p[u]);
}
void buildTree(int u, int v, long long w, int& size) {
size++;
E[size].u = u, E[size].v = v;
E[size].w = w;
E[size].next = Head[u];
Head[u] = size;
}
long long max(long long a, long long b) { return a > b ? a : b; }
long long lca(int x, int y) {
if (fix[x] < fix[y]) {
int t = x;
x = y;
y = t;
}
long long res = 0;
for (int i = 17; i >= 0; i--) {
if (f[x][i] && fix[f[x][i]] >= fix[y]) {
res = max(res, w[x][i]);
x = f[x][i];
}
}
if (x == y) return res;
for (int i = 17; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
res = max(res, w[x][i]);
res = max(res, w[y][i]);
x = f[x][i], y = f[y][i];
}
}
res = max(res, w[x][0]);
res = max(res, w[y][0]);
return res;
}
void initTree(int n, int s) {
for (int i = 1; i <= n; i++) fix[i] = 0;
int h = 0, t = -1;
Q[++t] = s;
fix[s] = 1;
while (h <= t) {
int u = Q[h++];
for (int i = Head[u]; i; i = E[i].next) {
int v = E[i].v;
long long W = E[i].w;
if (fix[v]) continue;
fix[v] = fix[u] + 1;
f[v][0] = u;
w[v][0] = W;
Q[++t] = v;
}
}
for (int j = 1; j <= 17; j++) {
for (int i = 1; i <= n; i++) {
int middle = f[i][j - 1];
if (!middle || !f[middle][j - 1]) continue;
w[i][j] = max(w[i][j - 1], w[middle][j - 1]);
f[i][j] = f[middle][j - 1];
}
}
}
int main() {
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
int size = 0;
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
addEdge(u, v, w, size);
addEdge(v, u, w, size);
}
dijkstra(n, k);
for (int i = 1; i <= size; i++) {
int u = e[i].u, v = e[i].v;
long long w = e[i].w;
e[i].w = dis[u] + dis[v] + w;
}
std::sort(e + 1, e + size + 1);
for (int i = 1; i <= n; i++) p[i] = i;
int Size = 0;
for (int i = 1; i <= size; i++) {
if (Size == (2 * n - 2)) break;
int x = find(e[i].u), y = find(e[i].v);
if (x != y) {
p[x] = y;
buildTree(e[i].u, e[i].v, e[i].w, Size);
buildTree(e[i].v, e[i].u, e[i].w, Size);
}
}
initTree(n, 1);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%lld\n", lca(u, v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
ll n, m, k, q, a, b, c;
ll p[300100], res[300100], d[300100];
vector<pll> E[300100];
map<int, bool> token[300100];
bool compare(const pll a, const pll b) { return a > b; }
int _find(int x) { return p[x] ? p[x] = _find(p[x]) : x; }
void dijkstra() {
vector<pll> que;
memset(d, 0x3f, sizeof(d));
for (int i = 1; i <= k; i++) {
d[i] = 0;
for (auto it : E[i]) que.push_back({it.second, it.first});
}
make_heap(que.begin(), que.end(), compare);
while (que.size()) {
pll qw = que.front();
pop_heap(que.begin(), que.end(), compare);
que.pop_back();
if (d[qw.second] <= qw.first) continue;
d[qw.second] = qw.first;
for (auto it : E[qw.second])
que.push_back({qw.first + it.second, it.first}),
push_heap(que.begin(), que.end(), compare);
}
}
int main() {
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++)
cin >> a >> b >> c, E[a].push_back({b, c}), E[b].push_back({a, c});
dijkstra();
vector<pair<ll, pair<int, int> > > e;
for (int i = 1; i <= n; i++)
for (auto it : E[i])
if (i < it.first)
e.push_back({d[i] + d[it.first] + it.second, {i, it.first}});
for (int i = 1; i <= q; i++)
cin >> a >> b, token[a][i] = true, token[b][i] = true;
sort(e.begin(), e.end());
for (auto x : e) {
if (_find(x.second.first) == _find(x.second.second)) continue;
int pA = _find(x.second.first);
int pB = _find(x.second.second);
if (token[pA].size() > token[pB].size()) swap(pA, pB);
p[pA] = pB;
for (auto y : token[pA]) {
if (token[pB][y.first]) {
res[y.first] = x.first;
token[pB].erase(y.first);
} else
token[pB][y.first] = true;
}
}
for (int i = 1; i <= q; i++) cout << res[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, q;
int x[300100], y[300100], w[300100];
set<int> mp[300100];
int dsu[300100], sz[300100];
bool ch[300100];
long long d[300100], ans[300100];
vector<pair<int, long long>> v[300100];
vector<pair<long long, pair<int, int>>> p;
void multisource_dijkstra() {
priority_queue<pair<long long, int>> q;
for (int i = 1; i <= k; i++) {
q.push({0, i});
}
while (!q.empty()) {
long long a = q.top().first;
int b = q.top().second;
q.pop();
if (ch[b]) continue;
ch[b] = true;
a = -a;
d[b] = a;
for (auto i : v[b]) {
if (ch[i.first]) continue;
q.push({-(a + i.second), i.first});
}
}
}
int root(int s) {
while (s != dsu[s]) {
dsu[s] = dsu[dsu[s]];
s = dsu[s];
}
return s;
}
void spoj(int a, int b, long long wgh) {
if (sz[a] > sz[b]) swap(a, b);
dsu[a] = b;
sz[b] += sz[a];
for (auto i : mp[a]) {
auto it = mp[b].find(i);
if (it != mp[b].end()) {
ans[i] = min(ans[i], wgh);
}
mp[b].insert(i);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
for (int i = 0; i <= 3e5; i++) {
dsu[i] = i;
sz[i] = 1;
ans[i] = 2e18;
}
memset((d), 0, sizeof((d)));
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i] >> w[i];
v[x[i]].push_back({y[i], w[i]});
v[y[i]].push_back({x[i], w[i]});
}
for (int i = 1; i <= q; i++) {
int a, b;
cin >> a >> b;
mp[a].insert(i);
mp[b].insert(i);
}
multisource_dijkstra();
for (int i = 1; i <= m; i++) {
long long u = w[i] + d[x[i]] + d[y[i]];
p.push_back({u, {x[i], y[i]}});
}
sort((p).begin(), (p).end());
for (auto i : p) {
int a = root(i.second.first);
int b = root(i.second.second);
if (a == b) continue;
spoj(a, b, i.first);
}
for (int i = 1; i <= q; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using llg = long long;
const int maxNod = (int)(1e5) + 5;
const int maxEdges = 3 * (int)(1e5) + 5;
const int maxQueries = 3 * (int)(1e5) + 5;
const int maxTokens = 2 * maxQueries;
const llg BIG = (llg)(1e9) * (llg)(1e9);
int nbNod, nbEdges, nbCentrals, nbQueries;
llg rep[maxQueries];
int dsuRepr[maxNod];
int dsuSize[maxNod];
vector<int> tokenIn[maxNod];
int baseTok[maxTokens];
void dsuInit() {
for (int nod = 0; nod < maxNod; ++nod) {
dsuRepr[nod] = nod;
dsuSize[nod] = 1;
}
}
int dsuFind(int x) {
if (x != dsuRepr[x]) {
dsuRepr[x] = dsuFind(dsuRepr[x]);
}
return dsuRepr[x];
}
void dsuMerge(int small, int big, llg curCap) {
small = dsuFind(small);
big = dsuFind(big);
if (small == big) return;
if (dsuSize[small] > dsuSize[big]) swap(small, big);
for (int token : tokenIn[small]) {
int oth = token ^ 1;
int query = token / 2;
if (dsuFind(baseTok[oth]) == big) {
rep[query] = curCap;
}
tokenIn[big].push_back(token);
}
tokenIn[small].clear();
tokenIn[small].shrink_to_fit();
dsuSize[big] += dsuSize[small];
dsuRepr[small] = big;
}
vector<pair<int, llg>> adj[maxNod];
llg mdis[maxNod];
void dijkstra() {
priority_queue<pair<llg, int>> pq;
for (int nod = 0; nod < nbNod; ++nod) {
if (nod < nbCentrals) {
pq.push({0, nod});
} else {
mdis[nod] = BIG;
}
}
while (!pq.empty()) {
llg dist = -pq.top().first;
int nod = pq.top().second;
pq.pop();
if (dist != mdis[nod]) continue;
for (auto rawNeigh : adj[nod]) {
int neighbor = rawNeigh.first;
llg newDis = dist + rawNeigh.second;
if (newDis < mdis[neighbor]) {
mdis[neighbor] = newDis;
pq.push({-newDis, neighbor});
}
}
}
}
struct Edge {
llg weight, n1, n2;
};
bool operator<(Edge a, Edge b) { return a.weight < b.weight; }
vector<Edge> tabEdges;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
dsuInit();
cin >> nbNod >> nbEdges >> nbCentrals >> nbQueries;
for (int iEdge = 0; iEdge < nbEdges; ++iEdge) {
int n1, n2;
llg weight;
cin >> n1 >> n2 >> weight;
--n1;
--n2;
adj[n1].emplace_back(n2, weight);
adj[n2].emplace_back(n1, weight);
tabEdges.push_back({weight, n1, n2});
}
for (int query = 0; query < nbQueries; ++query) {
int n1, n2;
cin >> n1 >> n2;
--n1;
--n2;
int tk1 = 2 * query, tk2 = 2 * query + 1;
baseTok[tk1] = n1;
baseTok[tk2] = n2;
tokenIn[n1].push_back(tk1);
tokenIn[n2].push_back(tk2);
}
dijkstra();
for (auto &edge : tabEdges) {
edge.weight += mdis[edge.n1] + mdis[edge.n2];
}
sort(tabEdges.begin(), tabEdges.end());
for (auto edge : tabEdges) {
dsuMerge(edge.n1, edge.n2, edge.weight);
}
for (int query = 0; query < nbQueries; ++query) {
cout << rep[query] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
pair<pair<int, int>, long long> edges[maxn];
pair<int, int> queries[maxn];
long long ans[maxn];
vector<int> Q[maxn];
vector<int> G[maxn];
vector<int> H[maxn];
long long dist[maxn];
int realm[maxn];
vector<int> comp[maxn];
int par[maxn];
int n, m, k, q;
vector<pair<long long, pair<int, int>>> C;
set<pair<long long, int>> prq;
inline int get_other(int i, int v) {
if (edges[i].first.first == v) return edges[i].first.second;
return edges[i].first.first;
}
inline int get_other_Q(int i, int x) {
if (queries[i].first == x) return queries[i].second;
return queries[i].first;
}
inline void mark(int v, long long d, int r) {
prq.insert({d, v});
dist[v] = d;
realm[v] = r;
}
inline void connect(int v, int u, long long w) {
int x = realm[v];
int y = realm[u];
long long d = dist[v] + dist[u] + w;
if (x != y) C.push_back({d, {x, y}});
}
inline void dijkstra() {
for (int i = 0; i < k; i++) {
mark(i, 0ll, i);
}
while (!prq.empty()) {
int v = prq.begin()->second;
prq.erase({dist[v], v});
for (int i : G[v]) {
int u = get_other(i, v);
long long w = edges[i].second;
if (dist[v] + w < dist[u]) {
prq.erase({dist[u], u});
mark(u, dist[v] + w, realm[v]);
}
}
}
}
inline void init() {
memset(dist, 63, sizeof dist);
for (int i = 0; i < n; i++) {
comp[i].push_back(i);
par[i] = i;
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
init();
for (int i = 0; i < m; i++) {
int x, y;
long long w;
scanf("%d%d%lld", &x, &y, &w);
x--;
y--;
edges[i] = {{x, y}, w};
G[x].push_back(i);
G[y].push_back(i);
}
dijkstra();
for (int i = 0; i < m; i++) {
connect(edges[i].first.first, edges[i].first.second, edges[i].second);
}
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
queries[i] = {x, y};
Q[x].push_back(i);
Q[y].push_back(i);
}
sort(C.begin(), C.end());
for (auto ed : C) {
long long d = ed.first;
int v = par[ed.second.first];
int u = par[ed.second.second];
if (u == v) continue;
if (comp[v].size() < comp[u].size()) {
swap(v, u);
}
for (int a : comp[u]) {
for (int idx : Q[a]) {
int b = get_other_Q(idx, a);
if (par[b] == v) {
ans[idx] = d;
}
}
}
for (int a : comp[u]) {
comp[v].push_back(a);
par[a] = v;
}
comp[u].clear();
}
for (int i = 0; i < q; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
const int maxN = 1e5 + 5;
int n, m, k, q, a, b, w;
set<pair<long long, long long> > s;
vector<pair<long long, long long> > graph[maxN], newGraph[maxN];
long long cost[maxN];
int parent[maxN], ranga[maxN];
vector<pair<long long, pair<long long, long long> > > edges;
int pre[maxN], treeSize[maxN];
bool vis[maxN];
int counter = 0;
pair<long long, long long> P[18][maxN];
void dijkstra() {
for (int i = (k + 1); i <= (n); ++i) {
cost[i] = inf;
s.insert(pair<long long, long long>(cost[i], i));
}
for (int i = (1); i <= ((k)); ++i) {
cost[i] = 0;
s.insert(pair<long long, long long>(cost[i], i));
}
while (!s.empty()) {
pair<long long, long long> p = *s.begin();
s.erase(s.begin());
for (auto x : graph[p.second]) {
if (cost[x.first] > cost[p.second] + x.second) {
s.erase(s.find(pair<long long, long long>(cost[x.first], x.first)));
cost[x.first] = cost[p.second] + x.second;
s.insert(pair<long long, long long>(cost[x.first], x.first));
}
}
}
}
int find(int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
void Union(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fy == fx) return;
if (ranga[fx] < ranga[fy]) {
swap(fx, fy);
}
parent[fy] = fx;
if (ranga[fy] == ranga[fx]) ranga[fx]++;
}
bool children(int u, int v) {
return (pre[u] >= pre[v] && pre[u] < pre[v] + treeSize[v]);
}
int lca(int u, int v) {
if (children(u, v)) return v;
if (children(v, u)) return u;
int i = u, j = 18 - 1;
while (j >= 0) {
if (children(v, P[j][i].first))
j--;
else
i = P[j][i].first;
}
return P[0][i].first;
}
void dfs(int v) {
counter++;
pre[v] = counter;
for (auto i : newGraph[v]) {
int to = i.first;
long long cost = i.second;
if (!vis[to]) {
P[0][to] = pair<long long, long long>(v, cost);
vis[to] = true;
dfs(to);
}
}
treeSize[v] = counter + 1 - pre[v];
}
long long getMax(int a, int x) {
int cnt = 0;
long long maxim = 0;
while (a != x) {
while (children(P[cnt][a].first, x) && P[cnt][a].first != x) {
cnt++;
}
if (children(x, P[cnt][a].first) && x != P[cnt][a].first) cnt--;
maxim = max(maxim, P[cnt][a].second);
a = P[cnt][a].first;
cnt = 0;
}
return maxim;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k >> q;
for (int i = (0); i <= ((m)-1); ++i) {
cin >> a >> b >> w;
graph[a].push_back(pair<long long, long long>(b, w));
graph[b].push_back(pair<long long, long long>(a, w));
}
dijkstra();
for (int i = (1); i <= ((n)); ++i) {
parent[i] = i;
ranga[i] = 0;
for (auto x : graph[i]) {
if (i < x.first) {
edges.push_back(pair<long long, pair<long long, long long> >(
cost[i] + cost[x.first] + x.second,
pair<long long, long long>(i, x.first)));
}
}
}
sort(edges.begin(), edges.end());
for (auto p : edges) {
long long cost = p.first;
int x = p.second.first;
int y = p.second.second;
if (find(x) != find(y)) {
Union(x, y);
newGraph[x].push_back(pair<long long, long long>(y, cost));
newGraph[y].push_back(pair<long long, long long>(x, cost));
}
}
for (int i = 0; i < 18; i++)
for (int j = 0; j <= n; j++) P[i][j] = pair<long long, long long>(0, 0);
vis[1] = true;
dfs(1);
P[0][1] = pair<long long, long long>(1, 0);
for (int i = 1; i < 18; i++) {
for (int j = 1; j <= n; j++) {
pair<long long, long long> half = P[i - 1][j];
P[i][j].first = P[i - 1][half.first].first;
P[i][j].second = max(half.second, P[i - 1][half.first].second);
}
}
for (int i = (0); i <= ((q)-1); ++i) {
cin >> a >> b;
int x = lca(a, b);
cout << max(getMax(a, x), getMax(b, x)) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10;
const int mod = 998244353;
void read(int &a) {
a = 0;
int d = 1;
char ch;
while (ch = getchar(), ch > '9' || ch < '0')
if (ch == '-') d = -1;
a = ch ^ 48;
while (ch = getchar(), ch >= '0' && ch <= '9')
a = (a << 3) + (a << 1) + (ch ^ 48);
a *= d;
}
int f[N], head[N], cnt;
long long ans[N], dis[N];
bool vis[N];
vector<pair<int, int> > tmp[N];
struct note {
int u, v, next;
long long w;
} edge[N];
void add(int u, int v, long long w) {
edge[++cnt].next = head[u];
edge[cnt].v = v;
edge[cnt].w = w;
head[u] = cnt;
}
struct node {
int u, v;
long long w;
bool operator<(const node &x) const { return w < x.w; }
} e[N];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
void distra(int k, int n) {
fill(dis, dis + n + 1, 1e18);
for (register int i = 1; i <= k; i++) dis[i] = 0, q.push({0, i});
while (!q.empty()) {
int t = q.top().second;
q.pop();
if (vis[t]) continue;
vis[t] = 1;
for (register int i = head[t]; i; i = edge[i].next) {
int v = edge[i].v;
if (!vis[v] && dis[v] > dis[t] + edge[i].w)
q.push({dis[v] = dis[t] + edge[i].w, v});
}
}
}
int getv(int v) { return f[v] = v == f[v] ? v : getv(f[v]); }
int main() {
int n, m, k, q;
read(n), read(m), read(k), read(q);
for (register int i = 1; i <= m; i++) {
int u, v, w;
read(u), read(v), read(w);
add(u, v, w), add(v, u, w);
e[i] = node{u, v, w};
}
distra(k, n);
for (register int i = 1; i <= m; i++) e[i].w += dis[e[i].u] + dis[e[i].v];
sort(e + 1, e + 1 + m);
for (register int i = 1; i <= n; i++) f[i] = i;
for (register int i = 1; i <= q; i++) {
int u, v;
read(u), read(v);
tmp[u].push_back({v, i});
tmp[v].push_back({u, i});
}
for (register int i = 1; i <= m; i++) {
int t1 = getv(e[i].u), t2 = getv(e[i].v);
if (t1 == t2) continue;
if (tmp[t1].size() > tmp[t2].size()) swap(t1, t2);
for (auto it : tmp[t1]) {
if (getv(it.first) == t2)
ans[it.second] = e[i].w;
else
tmp[t2].push_back(it);
}
f[t1] = t2;
}
for (register int i = 1; i <= q; i++) printf("%I64d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using llg = long long;
const int maxNod = (int)(1e5) + 5;
const int maxEdges = 3 * (int)(1e5) + 5;
const int maxQueries = 3 * (int)(1e5) + 5;
const int maxTokens = 2 * maxQueries;
const llg BIG = (llg)(1e9) * (llg)(1e9);
int nbNod, nbEdges, nbCentrals, nbQueries;
llg rep[maxQueries];
int dsuRepr[maxNod];
int dsuSize[maxNod];
vector<int> tokenIn[maxNod];
int baseTok[maxTokens];
void dsuInit() {
for (int nod = 0; nod < maxNod; ++nod) {
dsuRepr[nod] = nod;
dsuSize[nod] = 1;
}
}
int dsuFind(int x) {
if (x != dsuRepr[x]) {
dsuRepr[x] = dsuFind(dsuRepr[x]);
}
return dsuRepr[x];
}
void dsuMerge(int small, int big, llg curCap) {
small = dsuFind(small);
big = dsuFind(big);
if (small == big) return;
if (dsuSize[small] > dsuSize[big]) swap(small, big);
for (int token : tokenIn[small]) {
int oth = token ^ 1;
int query = token / 2;
if (dsuFind(baseTok[oth]) == big) {
rep[query] = curCap;
}
tokenIn[big].push_back(token);
}
tokenIn[small].clear();
tokenIn[small].shrink_to_fit();
dsuSize[big] += dsuSize[small];
dsuRepr[small] = big;
}
vector<pair<int, llg>> adj[maxNod];
llg mdis[maxNod];
void dijkstra() {
priority_queue<pair<llg, int>> pq;
for (int nod = 0; nod < nbNod; ++nod) {
if (nod < nbCentrals) {
pq.push({0, nod});
} else {
mdis[nod] = BIG;
}
}
while (!pq.empty()) {
llg dist = -pq.top().first;
int nod = pq.top().second;
pq.pop();
if (dist != mdis[nod]) continue;
for (auto rawNeigh : adj[nod]) {
int neighbor = rawNeigh.first;
llg newDis = dist + rawNeigh.second;
if (newDis < mdis[neighbor]) {
mdis[neighbor] = newDis;
pq.push({-newDis, neighbor});
}
}
}
}
struct Edge {
llg weight, n1, n2;
};
bool operator<(Edge a, Edge b) { return a.weight < b.weight; }
vector<Edge> tabEdges;
int t;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
dsuInit();
cin >> nbNod >> nbEdges >> nbCentrals >> nbQueries;
for (int iEdge = 0; iEdge < nbEdges; ++iEdge) {
int n1, n2;
llg weight;
cin >> n1 >> n2 >> weight;
--n1;
--n2;
adj[n1].emplace_back(n2, weight);
adj[n2].emplace_back(n1, weight);
tabEdges.push_back({weight, n1, n2});
}
for (int query = 0; query < nbQueries; ++query) {
int n1, n2;
cin >> n1 >> n2;
--n1;
--n2;
int tk1 = 2 * query, tk2 = 2 * query + 1;
baseTok[tk1] = n1;
baseTok[tk2] = n2;
tokenIn[n1].push_back(tk1);
tokenIn[n2].push_back(tk2);
}
dijkstra();
for (auto &edge : tabEdges) {
edge.weight += mdis[edge.n1] + mdis[edge.n2];
}
sort(tabEdges.begin(), tabEdges.end());
for (auto edge : tabEdges) {
dsuMerge(edge.n1, edge.n2, edge.weight);
}
for (int query = 0; query < nbQueries; ++query) {
cout << rep[query] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const int LOG = 20;
int n, m, q, k;
int v1[N], v2[N], w[N];
vector<pair<long long, int> > v[N], T[N];
long long dis[N];
int tko[N], par[N];
int lca[N][LOG], dep[N];
long long dp_lca[N][LOG];
int pr(int x) {
if (par[x] == x) return x;
return par[x] = pr(par[x]);
}
void mrg(int x, int y) { par[pr(x)] = pr(y); }
void dfs(int x, int lst) {
lca[x][0] = lst;
dep[x] = dep[lst] + 1;
for (pair<long long, int> nxt : T[x]) {
if (nxt.second == lst) continue;
dp_lca[nxt.second][0] = nxt.first;
dfs(nxt.second, x);
}
}
void precompute() {
for (int j = 1; j < LOG; j++) {
for (int i = 1; i <= n; i++) {
lca[i][j] = lca[lca[i][j - 1]][j - 1];
dp_lca[i][j] = max(dp_lca[i][j - 1], dp_lca[lca[i][j - 1]][j - 1]);
}
}
}
long long get_lca(int x, int y) {
long long ans = 0;
if (dep[x] < dep[y]) swap(x, y);
for (int i = LOG - 1; i >= 0; i--)
if (dep[x] - (1 << i) >= dep[y]) {
ans = max(ans, dp_lca[x][i]);
x = lca[x][i];
}
if (x == y) return ans;
for (int i = LOG - 1; i >= 0; i--)
if (lca[x][i] != lca[y][i]) {
ans = max(ans, max(dp_lca[x][i], dp_lca[y][i]));
x = lca[x][i], y = lca[y][i];
}
return max(ans, max(dp_lca[x][0], dp_lca[y][0]));
}
void dijkstra() {
memset(dis, -1, sizeof(dis));
priority_queue<pair<long long, int> > S;
for (int i = 1; i <= k; i++)
S.push({0LL, i}), dis[i] = 0, tko[i] = i, par[i] = i;
for (; !S.empty();) {
pair<long long, int> cur = S.top();
S.pop();
for (pair<long long, int> nxt : v[cur.second]) {
if (dis[nxt.second] == -1 ||
dis[cur.second] + nxt.first < dis[nxt.second]) {
dis[nxt.second] = dis[cur.second] + nxt.first;
tko[nxt.second] = tko[cur.second];
S.push({-dis[nxt.second], nxt.second});
}
}
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", v1 + i, v2 + i, w + i);
v[v1[i]].push_back({w[i], v2[i]});
v[v2[i]].push_back({w[i], v1[i]});
}
dijkstra();
vector<pair<long long, pair<int, int> > > edg;
for (int i = 0; i < m; i++) {
if (tko[v1[i]] != tko[v2[i]]) {
edg.push_back({dis[v1[i]] + dis[v2[i]] + w[i], {tko[v1[i]], tko[v2[i]]}});
}
}
sort(edg.begin(), edg.end());
for (pair<long long, pair<int, int> > E : edg) {
if (pr(E.second.first) == pr(E.second.second)) continue;
mrg(E.second.first, E.second.second);
T[E.second.first].push_back({E.first, E.second.second});
T[E.second.second].push_back({E.first, E.second.first});
}
dfs(1, 1);
precompute();
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y);
printf("%lld\n", get_lca(x, y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long u, v, w;
};
bool cmp(const edge &x, const edge &y) { return x.w < y.w; }
const long long N = 1e5 + 5;
long long start[N];
vector<pair<long long, long long>> adj[N];
long long length[N];
long long res[3 * N];
vector<pair<long long, long long>> query[N];
vector<long long> p(N, -1);
set<long long> nodes[N];
long long globalWeight;
long long find(long long x) { return p[x] < 0 ? x : p[x] = find(p[x]); }
void merge(long long x, long long y) {
if ((x = find(x)) == (y = find(y))) return;
if (p[y] < p[x]) swap(x, y);
p[x] += p[y];
p[y] = x;
for (long long node : nodes[y]) {
for (auto &qu : query[node]) {
const long long otherNode = qu.first;
const long long index = qu.second;
if (nodes[x].count(otherNode)) {
if (res[index] == -1) {
res[index] = globalWeight;
}
}
}
}
for (long long node : nodes[y]) {
nodes[x].insert(node);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k, Q;
cin >> n >> m >> k >> Q;
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
for (long long i = 1; i <= n; ++i) {
nodes[i].insert(i);
length[i] = 1e18;
}
set<pair<long long, long long>> q;
for (long long i = 1; i <= k; ++i) {
length[i] = 0;
q.insert({0, i});
start[i] = i;
}
vector<edge> arr;
while (!q.empty()) {
auto it = q.begin();
long long node = it->second;
q.erase(it);
for (auto &p : adj[node]) {
long long to = p.first;
long long weight = p.second;
if (length[to] > weight + length[node]) {
q.erase({length[to], to});
start[to] = start[node];
length[to] = weight + length[node];
q.insert({length[to], to});
} else if (start[to] != start[node]) {
arr.push_back(
{start[to], start[node], weight + length[to] + length[node]});
}
}
}
sort(arr.begin(), arr.end(), cmp);
for (long long i = 0; i < Q; ++i) {
res[i] = -1;
long long u, v;
cin >> u >> v;
query[u].push_back({v, i});
query[v].push_back({u, i});
}
for (auto &e : arr) {
globalWeight = e.w;
merge(e.u, e.v);
}
for (long long i = 0; i < Q; ++i) {
cout << res[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long dist[300005], ans[300005];
vector<pair<int, long long>> vec[300005];
vector<pair<int, int>> qrs[300005];
int par[300005];
set<int> se[300005];
struct edge {
int u, v;
long long c;
edge(int u, int v, long long c) : u(u), v(v), c(c) {}
bool operator<(const edge& rhs) const { return c < rhs.c; }
};
int main() {
int n, m, k, q;
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);
vec[u].push_back({v, w});
vec[v].push_back({u, w});
}
for (int i = 1; i <= q; i++) {
int a, b;
scanf("%d %d", &a, &b);
qrs[a].push_back({b, i});
qrs[b].push_back({a, i});
}
for (int i = 1; i <= n; i++) dist[i] = INF;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = 1; i <= k; i++) {
dist[i] = 0;
pq.push({dist[i], i});
}
while (!pq.empty()) {
pair<long long, int> cur = pq.top();
pq.pop();
int u = cur.second;
if (cur.first > dist[u]) continue;
for (pair<int, long long> nxt : vec[u]) {
int v = nxt.first;
long long c = nxt.second;
if (dist[v] > dist[u] + c) {
dist[v] = dist[u] + c;
pq.push({dist[v], v});
}
}
}
vector<edge> edges;
for (int i = 1; i <= n; i++) {
for (pair<int, long long> p : vec[i]) {
int v = p.first;
long long w = p.second;
edges.push_back(edge(i, v, dist[i] + dist[v] + w));
}
}
sort(edges.begin(), edges.end());
for (int i = 1; i <= n; i++) {
par[i] = i;
se[i].insert(i);
}
for (edge e : edges) {
int u = e.u, v = e.v;
long long c = e.c;
if (par[u] == par[v]) continue;
if (se[par[u]].size() > se[par[v]].size()) swap(u, v);
int pp = par[u];
for (int x : se[pp]) {
for (pair<int, int> p : qrs[x]) {
int nv = p.first, idx = p.second;
if (par[nv] == par[v]) ans[idx] = c;
}
}
for (int x : se[pp]) {
par[x] = par[v];
se[par[v]].insert(x);
}
se[pp].clear();
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, head[100000 + 5], cnt = 0, fa[100000 + 5], ans, dep[100000 + 5],
f[20][100000 + 5];
long long g[20][100000 + 5], d[100000 + 5];
struct node {
int uu, vv;
long long w;
} a[300000 + 5];
struct edge {
int end, next;
long long val;
} e[700000 + 5];
struct node1 {
int id;
long long dis;
bool operator<(const node1& x) const { return x.dis < dis; }
};
bool vis[100000 + 5];
bool cmp(node A, node B) { return A.w < B.w; }
void add_edge(int u, int v, long long c) {
e[++cnt].end = v;
e[cnt].val = c;
e[cnt].next = head[u];
head[u] = cnt;
}
priority_queue<node1> Q;
void dijkstra() {
while (!Q.empty()) {
node1 now = Q.top();
Q.pop();
int u = now.id;
if (vis[u]) continue;
vis[u] = true;
for (int i = head[u]; i > 0; i = e[i].next)
if (d[e[i].end] > d[u] + e[i].val) {
int v = e[i].end;
d[v] = d[u] + e[i].val;
node1 b;
b.id = v;
b.dis = d[v];
Q.push(b);
}
}
}
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
void merge(int u, int v) { fa[get(v)] = get(u); }
void kruskal() {
int t = 0;
for (int i = 1; i <= m; i++)
if (get(a[i].uu) != get(a[i].vv)) {
t++;
ans += a[i].w;
add_edge(a[i].uu, a[i].vv, a[i].w);
add_edge(a[i].vv, a[i].uu, a[i].w);
merge(a[i].uu, a[i].vv);
if (t == n - 1) return;
}
}
void dfs(int u) {
int i, v;
for (i = head[u]; i > 0; i = e[i].next) {
v = e[i].end;
if (v == f[0][u]) continue;
f[0][v] = u;
g[0][v] = e[i].val;
dep[v] = dep[u] + 1;
dfs(v);
}
}
long long lca(int u, int v) {
int i;
long long ans = 0;
if (dep[u] > dep[v]) swap(u, v);
for (i = 18; i >= 0; i--)
if (dep[u] <= dep[f[i][v]]) {
ans = max(ans, g[i][v]);
v = f[i][v];
}
if (u == v) return ans;
for (i = 18; i >= 0; i--)
if (f[i][u] != f[i][v]) {
ans = max(ans, max(g[i][u], g[i][v]));
u = f[i][u];
v = f[i][v];
}
ans = max(ans, max(g[0][u], g[0][v]));
return ans;
}
int main() {
int k, q, i, j, u, v;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (i = 1; i <= m; i++) {
scanf("%d%d%lld", &a[i].uu, &a[i].vv, &a[i].w);
add_edge(a[i].uu, a[i].vv, a[i].w);
add_edge(a[i].vv, a[i].uu, a[i].w);
}
for (i = 1; i <= k; i++) add_edge(0, i, 0);
for (i = 1; i <= n; i++) d[i] = 1e16;
node1 now;
now.dis = 0;
now.id = 0;
d[0] = 0;
Q.push(now);
dijkstra();
for (i = 1; i <= m; i++) {
a[i].w = a[i].w + d[a[i].uu] + d[a[i].vv];
}
sort(a + 1, a + m + 1, cmp);
memset(e, 0, sizeof(e));
memset(head, 0, sizeof(head));
cnt = 0;
for (i = 1; i <= n; i++) fa[i] = i;
kruskal();
f[0][1] = 1;
dep[1] = 1;
dfs(1);
for (i = 1; i <= 18; i++)
for (j = 1; j <= n; j++) {
f[i][j] = f[i - 1][f[i - 1][j]];
g[i][j] = max(g[i - 1][j], g[i - 1][f[i - 1][j]]);
}
for (i = 1; i <= q; i++) {
scanf("%d%d", &u, &v);
printf("%lld\n", lca(u, v));
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(int a, int b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret *= mul;
mul *= mul;
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
const int MAXN = 1e5 + 15;
int n, m, k, q, par[MAXN], rnk[MAXN], tin[MAXN], tout[MAXN], tme;
long long up[MAXN][20][2];
long long dis[MAXN];
vector<pair<int, int> > adj[MAXN];
vector<pair<long long, long long> > adj2[MAXN];
pair<pair<long long, long long>, long long> ed[3 * MAXN];
int get(int v) { return par[v] = (par[v] == v ? v : get(par[v])); }
void uni(int a, int b) {
a = get(a), b = get(b);
if (rnk[a] < rnk[b]) swap(a, b);
par[b] = a;
rnk[a] += (rnk[a] == rnk[b]);
}
void dij() {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
for (int(i) = (0); (i) < (k); (i)++) dis[i] = 0, pq.push({0, i});
for (int(i) = (k); (i) < (n); (i)++) dis[i] = 2e15;
while (pq.size()) {
int v = pq.top().second;
long long dv = pq.top().first;
pq.pop();
if (dv != dis[v]) continue;
for (int(i) = (0); (i) < (adj[v].size()); (i)++) {
int u = adj[v][i].first, c = adj[v][i].second;
if (dis[u] > dis[v] + c) dis[u] = dis[v] + c, pq.push({dis[u], u});
}
}
}
void dfs(int v, int p, long long w) {
tin[v] = tme++;
up[v][0][0] = p, up[v][0][1] = w;
for (int(i) = (1); (i) < (20); (i)++)
up[v][i][0] = up[up[v][i - 1][0]][i - 1][0],
up[v][i][1] = max(up[v][i - 1][1], up[up[v][i - 1][0]][i - 1][1]);
for (int(i) = (0); (i) < (adj2[v].size()); (i)++) {
int u = adj2[v][i].first;
long long ww = adj2[v][i].second;
if (u != p) dfs(u, v, ww);
}
tout[v] = tme;
}
bool isAnc(int u, int v) { return (tin[u] <= tin[v] and tout[u] >= tout[v]); }
long long mx(int u, int v) {
long long ret = 0;
int lca = v;
for (int(i) = (19); (i) >= (0); (i)--) {
if (!isAnc(up[lca][i][0], u))
ret = max(ret, up[lca][i][1]), lca = up[lca][i][0];
}
if (!isAnc(lca, u)) ret = max(ret, up[lca][0][1]);
lca = u;
for (int(i) = (19); (i) >= (0); (i)--) {
if (!isAnc(up[lca][i][0], v))
ret = max(ret, up[lca][i][1]), lca = up[lca][i][0];
}
if (!isAnc(lca, v)) ret = max(ret, up[lca][0][1]);
return ret;
}
bool cmp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
return dis[a.first.first] + dis[a.first.second] + a.second <
dis[b.first.first] + dis[b.first.second] + b.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
cin >> n >> m >> k >> q;
for (int(i) = (0); (i) < (n); (i)++) par[i] = i;
for (int(i) = (0); (i) < (m); (i)++) {
int s, e, w;
cin >> s >> e >> w;
s--, e--;
adj[s].push_back({e, w});
adj[e].push_back({s, w});
ed[i] = {{s, e}, w};
}
dij();
sort(ed, ed + m, cmp);
for (int(i) = (0); (i) < (m); (i)++) {
int a = ed[i].first.first, b = ed[i].first.second;
long long w =
ed[i].second + dis[ed[i].first.first] + dis[ed[i].first.second];
if (get(a) != get(b)) {
uni(a, b);
adj2[a].push_back({b, w});
adj2[b].push_back({a, w});
}
}
dfs(0, 0, 0);
while (q--) {
int a, b;
cin >> a >> b;
a--, b--;
cout << mx(a, b) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, LG = 20;
const long long infll = 1e16;
vector<pair<int, int>> g[N];
long long dist[N];
int from[N];
int p[N];
int find(int x) { return p[x] < 0 ? x : p[x] = find(p[x]); }
vector<pair<int, long long>> tree[N];
int lv[N], par[LG][N];
long long val[LG][N];
bool merge(int u, int v) {
if ((u = find(u)) == (v = find(v))) return false;
if (-p[u] > -p[v]) swap(u, v);
p[v] += p[u];
p[u] = v;
return true;
}
void dfs(int v) {
for (int i = 0; i + 1 < LG; ++i) {
par[i + 1][v] = par[i][par[i][v]];
val[i + 1][v] = max(val[i][v], val[i][par[i][v]]);
}
for (auto e : tree[v]) {
if (e.first == par[0][v]) continue;
par[0][e.first] = v;
val[0][e.first] = e.second;
lv[e.first] = lv[v] + 1;
dfs(e.first);
}
}
long long solve(int u, int v) {
if (lv[v] < lv[u]) swap(u, v);
int diff = lv[v] - lv[u];
long long ret = 0;
for (int i = 0; i < LG; ++i) {
if (diff & (1 << i)) {
ret = max(ret, val[i][v]);
v = par[i][v];
}
}
if (u == v) return ret;
for (int i = LG - 1; i >= 0; --i) {
if (par[i][v] != par[i][u]) {
ret = max(ret, max(val[i][u], val[i][v]));
v = par[i][v];
u = par[i][u];
}
}
ret = max(ret, max(val[0][u], val[0][v]));
return ret;
}
int main() {
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].emplace_back(v, w);
g[v].emplace_back(u, w);
}
fill(dist, dist + n, infll);
priority_queue<pair<long long, int>> pq;
for (int i = 0; i < k; ++i) {
from[i] = i;
dist[i] = 0;
pq.emplace(0, i);
}
while (!pq.empty()) {
int v = pq.top().second;
long long w = -pq.top().first;
pq.pop();
if (dist[v] != w) continue;
for (auto e : g[v]) {
long long cur = w + e.second;
if (dist[e.first] > cur) {
from[e.first] = from[v];
dist[e.first] = cur;
pq.emplace(-cur, e.first);
}
}
}
vector<tuple<long long, int, int>> edges;
for (int v = 0; v < n; ++v) {
for (auto e : g[v]) {
if (from[v] == from[e.first]) continue;
edges.emplace_back(dist[v] + e.second + dist[e.first], from[v],
from[e.first]);
}
}
fill(p, p + n, -1);
sort(edges.begin(), edges.end());
for (auto e : edges) {
int u, v;
long long w;
tie(w, u, v) = e;
if (merge(u, v)) {
tree[u].emplace_back(v, w);
tree[v].emplace_back(u, w);
}
}
par[0][0] = 0;
val[0][0] = 0;
lv[0] = 0;
dfs(0);
for (int i = 0; i < q; ++i) {
int a, b;
scanf("%d %d", &a, &b);
--a, --b;
printf("%lld\n", solve(a, b));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
const long long MAXM = 3e5 + 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][21], dep[MAXN], maxm[MAXN][21];
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 MOD = (long long)1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
long long fac[1] = {1}, inv[1] = {1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long mp(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
long long cmb(long long r, long long c) {
return fac[r] * inv[c] % MOD * inv[r - c] % MOD;
}
vector<pair<int, int>> ov[100000];
int p[100000];
int find(int a) {
if (p[a] == -1) return a;
return p[a] = find(p[a]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
p[b] = a;
}
long long tdist[100000];
pair<int, int> lr[300000];
pair<int, int> qu[300000];
int wif[100000];
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
struct edg {
int u, v;
long long co;
bool operator<(const edg v2) const { return co < v2.co; };
};
int main() {
memset(tdist, 0x3f, sizeof(tdist));
int n, m, k, q;
scanf("%d %d %d %d", &n, &m, &k, &q);
int a, b, c;
while (m--) {
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
ov[a].push_back({c, b});
ov[b].push_back({c, a});
}
for (int i = 0; i < k; i++) {
pq.push({0, i});
wif[i] = i;
tdist[i] = 0;
}
pair<long long, int> tv;
vector<edg> se;
while (!pq.empty()) {
tv = pq.top();
pq.pop();
if (tv.first != tdist[tv.second]) continue;
for (pair<int, int> i : ov[tv.second]) {
if (tdist[i.second] > tv.first + i.first) {
tdist[i.second] = tv.first + i.first;
pq.push({tv.first + i.first, i.second});
wif[i.second] = wif[tv.second];
}
if (wif[i.second] != wif[tv.second]) {
a = wif[i.second], b = wif[tv.second];
if (a > b) swap(a, b);
se.push_back({a, b, i.first + tv.first + tdist[i.second]});
}
}
}
sort((se).begin(), (se).end());
memset(p, -1, sizeof(p));
for (int i = 0; i < q; i++) {
scanf("%d %d", &a, &b);
lr[i] = {0, (int)(se).size() - 1};
qu[i] = {a - 1, b - 1};
}
vector<pair<int, int>> v;
for (int cnt = 0; cnt < 25; cnt++) {
memset(p, -1, sizeof(p));
v.clear();
for (int i = 0; i < q; i++)
if (lr[i].first <= lr[i].second)
v.push_back({(lr[i].first + lr[i].second) >> 1, i});
if (v.empty()) break;
sort((v).begin(), (v).end());
int l = 0;
for (pair<int, int> i : v) {
while (l < (int)(se).size() && se[i.first].co >= se[l].co) {
merge(se[l].u, se[l].v);
l++;
}
if (find(qu[i.second].first) == find(qu[i.second].second))
lr[i.second].second = i.first - 1;
else
lr[i.second].first = i.first + 1;
}
}
for (int i = 0; i < q; i++) printf("%lld\n", se[lr[i].first].co);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, q;
struct Edge {
int v;
long long d;
Edge() {
v = 0;
d = 0;
}
Edge(int rv, int rd) {
v = rv;
d = rd;
}
};
struct SortEdge {
int u;
int v;
long long d;
};
bool operator<(const SortEdge& a, const SortEdge& b) {
if (a.d != b.d) return a.d < b.d;
if (a.u != b.u) return a.u < b.u;
return a.v < b.v;
}
vector<Edge> e[100005];
long long du[100005];
int pre[100005];
int fa[100005 * 4][21];
long long ans[100005 * 4];
int dsuFa[100005 * 4];
int topK;
int level[100005 * 4];
int tl[100005 * 4];
int tr[100005 * 4];
vector<SortEdge> se;
void dijstra() {
priority_queue<pair<long long, int>> pq;
int i;
for (i = 1; i <= n; i++) {
if (i <= k) {
du[i] = 0;
pq.push({0, i});
} else {
du[i] = -1;
}
pre[i] = i;
}
while (!pq.empty()) {
auto cur = pq.top();
pq.pop();
int u = cur.second;
long long cd = -cur.first;
for (auto& it : e[u]) {
long long nd = cd + it.d;
if (du[it.v] == -1 || du[it.v] > nd) {
du[it.v] = nd;
pq.push({-nd, it.v});
pre[it.v] = pre[u];
}
}
}
}
int dsuFind(int x) {
if (dsuFa[x] != x) {
dsuFa[x] = dsuFind(dsuFa[x]);
}
return dsuFa[x];
}
void dsuUnion(int x, int y, long long val) {
int xx = dsuFind(x);
int yy = dsuFind(y);
topK++;
fa[xx][0] = topK;
fa[yy][0] = topK;
dsuFa[xx] = topK;
dsuFa[yy] = topK;
dsuFa[topK] = topK;
ans[topK] = val;
tl[topK] = xx;
tr[topK] = yy;
}
void dfs(int u) {
for (int j = 1; j < 21; j++) {
fa[u][j] = fa[fa[u][j - 1]][j - 1];
}
if (tl[u]) {
level[tl[u]] = level[u] + 1;
dfs(tl[u]);
}
if (tr[u]) {
level[tr[u]] = level[u] + 1;
dfs(tr[u]);
}
}
int lca(int a, int b) {
if (level[a] < level[b]) {
int c = a;
a = b;
b = c;
}
int ha = level[a];
int hb = level[b];
int begina = a;
int beginb = b;
int beginlevela = level[a];
int beginlevelb = level[b];
int deltaH = ha - hb;
for (int i = 0; i < 21; i++) {
if (deltaH & (1 << i)) {
a = fa[a][i];
}
}
for (int i = 20; i >= 0; i--) {
if (fa[a][i] != fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
return fa[a][0];
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k >> q;
int i;
for (i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
e[a].push_back({b, c});
e[b].push_back({a, c});
}
dijstra();
for (i = 1; i <= n; i++) {
for (int j = 0; j < e[i].size(); j++) {
if (i > e[i][j].v) {
if (pre[i] != pre[e[i][j].v]) {
if (pre[i] <= k && pre[e[i][j].v] <= k) {
se.push_back(
{pre[i], pre[e[i][j].v], du[i] + du[e[i][j].v] + e[i][j].d});
}
}
}
}
}
sort(se.begin(), se.end());
topK = k;
for (i = 1; i <= k; i++) {
dsuFa[i] = i;
tl[i] = 0;
tr[i] = 0;
level[i] = 0;
}
for (i = 0; i < se.size(); i++) {
if (dsuFind(se[i].u) != dsuFind(se[i].v)) {
dsuUnion(se[i].u, se[i].v, se[i].d);
}
}
level[topK] = 1;
dfs(topK);
while (q--) {
int a, b;
cin >> a >> b;
int c = lca(a, b);
if (c > 0) {
cout << ans[c] << endl;
} else {
cout << a << " " << b << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
struct edge {
int to;
long long cost;
};
struct path {
int node;
long long cost;
bool operator<(const path &other) const { return cost > other.cost; }
};
bool known[N];
long long dist[N];
int par[N], p[N], we[N];
vector<edge> adj[N];
set<int> queries[N];
long long ans[N];
int n, m, k, q;
void Dijkstra() {
priority_queue<path> pq;
memset(known, 0, sizeof known);
memset(dist, 63, sizeof dist);
for (int i = 0; i < int(k); i++) {
pq.push({i, 0});
dist[i] = 0;
par[i] = i;
}
while (pq.size()) {
int node = pq.top().node;
long long cost = pq.top().cost;
pq.pop();
if (known[node]) continue;
known[node] = 1;
for (auto &c : adj[node]) {
if (dist[c.to] > dist[node] + c.cost) {
dist[c.to] = dist[node] + c.cost;
par[c.to] = par[node];
pq.push({c.to, dist[c.to]});
}
}
}
}
int f(int u) {
if (u == p[u]) return u;
return p[u] = f(p[u]);
}
bool is_connected(int a, int b) { return f(a) == f(b); }
void connect(int a, int b, long long w) {
a = f(a);
b = f(b);
if (a == b) return;
if (we[a] < we[b]) swap(a, b);
we[a] += we[b];
p[b] = a;
if (int(queries[a].size()) < int(queries[b].size()))
queries[a].swap(queries[b]);
for (auto idx : queries[b]) {
if (queries[a].count(idx)) {
queries[a].erase(idx);
ans[idx] = w;
} else {
queries[a].insert(idx);
}
}
}
void init() {
for (int i = 0; i < N; i++) p[i] = i, we[i] = 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b, w;
cin >> n >> m >> k >> q;
for (int i = 0; i < int(m); i++) {
cin >> a >> b >> w;
a--, b--;
adj[a].push_back({b, w});
adj[b].push_back({a, w});
}
Dijkstra();
vector<pair<long long, pair<int, int> > > edges;
for (int i = 0; i < int(n); i++) {
for (auto e : adj[i]) {
if (par[e.to] != par[i]) {
edges.push_back({dist[e.to] + dist[i] + e.cost, {par[e.to], par[i]}});
}
}
}
sort(edges.begin(), edges.end());
init();
for (int i = 0; i < int(q); i++) {
cin >> a >> b;
--a, --b;
queries[a].insert(i);
queries[b].insert(i);
}
for (auto e : edges) {
int u = e.second.first, v = e.second.second;
long long W = e.first;
if (is_connected(u, v)) continue;
connect(u, v, W);
}
for (int i = 0; i < int(q); i++) cout << ans[i] << '\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;
markers[a].erase(x);
} 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 long long INF = 8e18 + 5;
const int maxn = 1e5 + 5;
const int maxm = 3e5 + 5;
struct edge {
int v, nex, w;
} e[maxm << 1];
int n, m, k, Q, tot;
int head[maxn], par[maxn], deep[maxn], fa[maxn][21];
long long dis[maxn], va[maxn][21];
;
vector<pair<long long, int> > E[maxn];
bool vis[maxn];
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void add(int u, int v, int w) {
e[++tot] = {v, head[u], w}, head[u] = tot;
e[++tot] = {u, head[v], w}, head[v] = tot;
}
void dfs(int u, int gg, long long d) {
par[u] = gg;
for (int i = head[u]; i; i = e[i].nex) {
int v = e[i].v, w = e[i].w;
long long now = d + w;
if (now == dis[v]) dfs(v, gg, now);
}
}
void getdeep(int u, int pre, int d) {
deep[u] = d;
for (auto &v : E[u])
if (v.second != pre) {
fa[v.second][0] = u, va[v.second][0] = v.first;
getdeep(v.second, u, d + 1);
}
}
void LCAinit() {
getdeep(1, 0, 0);
for (int i = 1; i <= 20; ++i) {
for (int j = 1; j <= k; ++j) {
if (deep[j] - (1 << i) < 0) continue;
fa[j][i] = fa[fa[j][i - 1]][i - 1];
va[j][i] = max(va[j][i - 1], va[fa[j][i - 1]][i - 1]);
}
}
}
long long query(int x, int y) {
long long res = 0;
if (deep[x] < deep[y]) swap(x, y);
for (int k = 0; k < 21; ++k) {
if (deep[x] - deep[y] >> k & 1) res = max(res, va[x][k]), x = fa[x][k];
}
if (x == y) return res;
for (int k = 20; k >= 0; --k) {
if (fa[x][k] != fa[y][k]) {
res = max({res, va[x][k], va[y][k]});
x = fa[x][k], y = fa[y][k];
}
}
res = max({res, va[x][0], va[y][0]});
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k >> Q;
for (int i = 1; i <= n; ++i) dis[i] = INF;
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
add(u, v, w);
}
for (int i = 1; i <= n; ++i) par[i] = i;
priority_queue<pair<long long, int> > q;
for (int i = 1; i <= k; ++i) q.push({0, i}), dis[i] = 0;
while (!q.empty()) {
auto now = q.top();
q.pop();
int u = now.second;
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i; i = e[i].nex) {
int v = e[i].v, w = e[i].w;
if (!vis[v] && dis[v] > w - now.first) {
dis[v] = w - now.first;
q.push({-w + now.first, v});
}
}
}
for (int i = 1; i <= k; ++i) dfs(i, i, 0);
vector<pair<long long, pair<int, int> > > a;
for (int u = 1; u <= n; ++u) {
for (int i = head[u]; i; i = e[i].nex) {
int v = e[i].v;
if (par[v] != par[u]) {
a.push_back({dis[u] + dis[v] + e[i].w, {par[u], par[v]}});
}
}
}
sort(a.begin(), a.end());
for (auto &x : a) {
int u = x.second.first, v = x.second.second;
u = find(u), v = find(v);
if (u == v) continue;
par[u] = par[v];
E[u].push_back({x.first, v});
E[v].push_back({x.first, u});
}
LCAinit();
while (Q--) {
int x, y;
cin >> x >> y;
cout << query(x, y) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long INF = (long long)1e15;
const int N = 300300;
int n, m, k, q;
long long ANS[N];
vector<int> g[N];
vector<pair<int, int> > Q[N];
int par[N];
vector<int> a[N];
long long ed[N][3];
pair<long long, int> ord[N];
set<pair<long long, int> > setik;
long long dist[N][2];
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
scanf("%lld%lld%lld", &ed[i][0], &ed[i][1], &ed[i][2]);
ed[i][0]--;
ed[i][1]--;
g[ed[i][0]].push_back(i);
g[ed[i][1]].push_back(i);
}
for (int i = 0; i < n; i++) {
if (i < k) {
dist[i][0] = 0;
dist[i][1] = i;
} else
dist[i][0] = INF;
setik.insert(make_pair(dist[i][0], i));
}
while (!setik.empty()) {
int v = setik.begin()->second;
42;
setik.erase(setik.begin());
for (int id : g[v]) {
int u = ed[id][0] ^ ed[id][1] ^ v;
long long w = dist[v][0] + ed[id][2];
if (w >= dist[u][0]) continue;
setik.erase(make_pair(dist[u][0], u));
dist[u][0] = w;
dist[u][1] = dist[v][1];
setik.insert(make_pair(dist[u][0], u));
}
}
for (int i = 0; i < m; i++) {
ed[i][2] += dist[ed[i][0]][0] + dist[ed[i][1]][0];
ed[i][0] = dist[ed[i][0]][1];
ed[i][1] = dist[ed[i][1]][1];
ord[i] = make_pair(ed[i][2], i);
}
sort(ord, ord + m);
for (int i = 0; i < k; i++) {
par[i] = i;
a[i].push_back(i);
}
for (int i = 0; i < q; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
Q[v].push_back(make_pair(u, i));
Q[u].push_back(make_pair(v, i));
}
for (int i = 0; i < m; i++) {
42;
int id = ord[i].second;
int v = ed[id][0], u = ed[id][1];
v = par[v];
u = par[u];
if (v == u) continue;
if ((int)a[v].size() > (int)a[u].size()) swap(v, u);
for (int w : a[v]) {
for (pair<int, int> QQ : Q[w]) {
int z = QQ.first;
if (par[z] == u) ANS[QQ.second] = ed[id][2];
}
}
for (int w : a[v]) {
par[w] = u;
a[u].push_back(w);
}
}
for (int i = 0; i < q; i++) printf("%lld\n", ANS[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 6e5 + 10;
const long long N = 4e5 + 10;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return f * x;
}
long long n, m, k, t;
struct edge {
long long u, v, w, nxt;
} e[M << 1], E[M << 1], E2[M << 1];
long long head[M], cnt1;
long long Head[M], cnt2;
struct node {
long long num, val;
bool operator<(const node &b) const { return val > b.val; }
};
long long fa[N], dis[N], vis[N];
bool cmp(edge x, edge y) { return x.w < y.w; }
void add_edge(long long u, long long v, long long w) {
e[++cnt1] = (edge){u, v, w, head[u]}, head[u] = cnt1;
}
void Add_edge(long long u, long long v, long long w) {
E2[++cnt2] = (edge){u, v, w, Head[u]}, Head[u] = cnt2;
}
long long find(long long x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
priority_queue<node> q;
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.num]) continue;
vis[u.num] = true;
for (long long i = head[u.num]; i; i = e[i].nxt) {
long long v = e[i].v;
if (dis[v] > dis[u.num] + e[i].w) {
dis[v] = dis[u.num] + e[i].w;
if (!vis[v]) q.push((node){v, dis[v]});
}
}
}
}
long long cnt;
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].u), vf = find(E[i].v);
if (uf != vf) {
fa[vf] = uf;
Add_edge(E[i].u, E[i].v, E[i].w), Add_edge(E[i].v, E[i].u, E[i].w);
cnt++;
if (cnt == n - 1) return;
}
}
}
long long f[N][22], dep[N], maxm[N][22];
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].v;
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(), t = 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].u = u, E[i].v = 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].u] + dis[E[i].v];
sort(E + 1, E + m + 1, cmp);
kruskal();
dep[1] = 1;
dfs(1, -1);
init();
for (long long i = 1, u, v; i <= t; ++i) {
u = read(), v = read();
cout << get_max(u, v) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int Q = 3e5 + 7;
int d[N], ra[N];
vector<pair<int, int>> g[N];
unordered_set<int> tokens[N];
long long dist[N];
long long ans[Q];
vector<int> to_ans;
int find(int idx) {
if (d[idx] == 0) return idx;
return d[idx] = find(d[idx]);
}
bool join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (ra[x] > ra[y]) swap(x, y);
d[x] = y;
for (auto &v : tokens[x]) {
if (tokens[y].count(v)) {
to_ans.push_back(v);
tokens[y].erase(v);
} else
tokens[y].insert(v);
}
if (ra[x] == ra[y]) ++ra[y];
return true;
}
struct Edge {
int a, b;
long long w;
Edge() : a(0), b(0), w(0) {}
Edge(int _a, int _b, long long _w) : a(_a), b(_b), w(_w) {}
};
Edge el[Q], nel[Q];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t ttt = clock();
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; ++i) {
cin >> el[i].a >> el[i].b >> el[i].w;
nel[i].a = el[i].a;
nel[i].b = el[i].b;
g[el[i].a].emplace_back(el[i].b, el[i].w);
g[el[i].b].emplace_back(el[i].a, el[i].w);
}
for (int i = 1; i <= q; ++i) {
int a, b;
cin >> a >> b;
tokens[a].insert(i);
tokens[b].insert(i);
}
for (int i = k + 1; i <= n; ++i) dist[i] = 1LL << 60;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
dji;
for (int i = 1; i <= k; ++i) dji.emplace(0LL, i);
while (!dji.empty()) {
auto v = dji.top();
dji.pop();
if (v.first > dist[v.second]) continue;
for (auto &cc : g[v.second]) {
if (dist[cc.first] > dist[v.second] + cc.second) {
dist[cc.first] = dist[v.second] + cc.second;
dji.emplace(dist[cc.first], (int)cc.first);
}
}
}
for (int i = 1; i <= m; ++i) {
nel[i].w = dist[el[i].a] + dist[el[i].b] + el[i].w;
}
sort(nel + 1, nel + 1 + m,
[](const Edge &lhs, const Edge &rhs) { return lhs.w < rhs.w; });
for (int i = 1; i <= m; ++i) {
auto &v = nel[i];
if (!join(v.a, v.b)) continue;
for (auto &letans : to_ans) {
ans[letans] = v.w;
}
to_ans.clear();
}
for (int i = 1; i <= q; ++i) {
cout << ans[i] << '\n';
}
cerr << "Time taken " << (double)(clock() - ttt) / CLOCKS_PER_SEC
<< " seconds\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 6e5 + 10, LG = 21;
int n, m, k, t;
int p[N], in[N], out[N], L[N][LG];
vector<vector<int>> tree(N, vector<int>());
int find_set(int x) { return x == p[x] ? x : p[x] = find_set(p[x]); }
void add_edge(int u, int v) {
tree[u].push_back(v);
tree[v].push_back(u);
}
void dfs(int x, int p) {
static int timer = 0;
in[x] = ++timer;
if (~p) L[x][0] = p;
for (int i = 1; i < LG; ++i) {
L[x][i] = L[L[x][i - 1]][i - 1];
}
for (int to : tree[x]) {
if (to != p) {
dfs(to, x);
}
}
out[x] = ++timer;
}
bool isAnc(int x, int y) { return !x || (in[x] <= in[y] && out[x] >= out[y]); }
int LCA(int x, int y) {
if (isAnc(x, y)) return x;
if (isAnc(y, x)) return y;
for (int i = LG - 1; i >= 0; --i) {
if (!isAnc(L[x][i], y)) {
x = L[x][i];
}
}
return L[x][0];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> t;
vector<vector<pair<int, int>>> edges(n + 1, vector<pair<int, int>>());
for (int i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
edges[u].push_back({v, w});
edges[v].push_back({u, w});
}
priority_queue<vector<ll>> q;
for (int i = 1; i <= k; ++i) {
q.push(vector<ll>{0, i, i});
}
vector<bool> vis(n + 1);
vector<ll> dist(n + 1), cent(n + 1);
while (!q.empty()) {
vector<ll> p = q.top();
q.pop();
ll distance = -p[0];
ll cur_vertex = p[1];
ll central = p[2];
if (vis[cur_vertex]) continue;
vis[cur_vertex] = 1;
dist[cur_vertex] = distance;
cent[cur_vertex] = central;
for (pair<int, int> p : edges[cur_vertex]) {
vector<ll> next = {-distance - p.second, p.first,
p.first <= k ? p.first : central};
q.push(next);
}
}
vector<vector<ll>> v;
for (int i = 1; i <= n; ++i) {
for (pair<int, int> p : edges[i]) {
int to = p.first;
if (cent[i] != cent[to]) {
v.push_back(
vector<ll>{dist[i] + dist[to] + p.second, cent[i], cent[to]});
}
}
}
sort(v.begin(), v.end());
for (int i = 0; i < N; ++i) p[i] = i;
int fake = n + 1;
vector<ll> weight;
for (vector<ll> edge : v) {
int u = edge[1];
int v = edge[2];
ll cost = edge[0];
u = find_set(u);
v = find_set(v);
if (u == v) continue;
weight.push_back(cost);
add_edge(u, fake);
add_edge(v, fake);
p[u] = p[v] = fake;
++fake;
}
dfs(fake - 1, -1);
for (int i = 0; i < t; ++i) {
int a, b;
cin >> a >> b;
int th = LCA(a, b) - n - 1;
cout << weight[th] << '\n';
}
}
|
#include <bits/stdc++.h>
namespace input {
const int size = 1 << 24;
char buf[size], *p1, *p2;
template <class type>
void inline read(type &a) {
int c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, size, stdin), p1 == p2)
? EOF
: *p1++);
for (; !(c >= '0' && c <= '9');
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, size, stdin), p1 == p2)
? EOF
: *p1++))
;
for (a = 0; (c >= '0' && c <= '9'); a *= 10, a += c ^ 48,
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, size, stdin), p1 == p2)
? EOF
: *p1++))
;
}
}; // namespace input
namespace output {
const int size = 1 << 24;
char d[20], puf[size], *p = puf;
template <class type>
void inline write(type a, char c = '\n') {
int s = 0;
d[0] = 0;
for (; a; d[s++] = a % 10, a /= 10)
;
for (s = s ? s : 1; s;
(*p++ = d[--s] + 48,
p - puf == size ? (fwrite(puf, 1, p - puf, stdout), p = puf) : 0))
;
(*p++ = c, p - puf == size ? (fwrite(puf, 1, p - puf, stdout), p = puf) : 0);
}
}; // namespace output
using namespace std;
using namespace input;
using namespace output;
const int nsz = 1e5, msz = 3e5, lgsz = 17;
const long long inf = 0x3f3f3f3f3f3f3f3f;
bool vis[nsz + 5];
int n, m, k, q, rt = 1, fm[nsz + 5];
int t, pr[nsz + 5], dep[nsz + 5], siz[nsz + 5], hs[nsz + 5], top[nsz + 5],
id[nsz + 5];
long long dis[nsz + 5], w[nsz + 5];
struct edge {
int nxt, fm, to;
long long w;
edge(int nxt = 0, int fm = 0, int to = 0, long long w = 0) {
this->nxt = nxt, this->fm = fm, this->to = to, this->w = w;
}
bool inline operator<(const edge oth) const { return this->w < oth.w; }
};
struct graph {
int sz, hd[nsz + 5];
edge e[2 * msz + 5];
void inline connect(int u, int v, long long w) {
e[++sz] = edge(hd[u], u, v, w), hd[u] = sz;
e[++sz] = edge(hd[v], v, u, w), hd[v] = sz;
}
};
graph g, tr;
bool inline cmp(pair<long long, int> a, pair<long long, int> b) {
return a.first > b.first;
}
struct heap {
int sz;
pair<long long, int> h[msz + 5];
heap() { sz = 0; }
void inline push(pair<long long, int> e) {
h[sz++] = e;
push_heap(h, h + sz, cmp);
}
pair<long long, int> inline get() {
pop_heap(h, h + sz, cmp);
return h[--sz];
}
};
heap h;
struct union_find {
int pr[nsz + 5];
void inline init() {
for (int u = 1; u <= k; ++u) {
pr[u] = u;
}
}
int qry(int u) { return pr[u] == u ? u : pr[u] = qry(pr[u]); }
bool inline unite(int u, int v) {
int pu = qry(u), pv = qry(v);
if (pu == pv) return 0;
pr[pv] = pu;
return 1;
}
};
union_find uf;
struct sparse_table {
int lg[nsz + 5];
long long st[nsz + 5][lgsz + 5];
void inline init() {
for (int i = 1; i <= n; ++i) {
lg[i] = lg[i >> 1] + 1;
st[id[i]][0] = w[i];
}
for (int k = 1; k <= lg[n]; ++k) {
for (int u = 1; u <= n; ++u) {
if (u + (1 << k) - 1 > n) break;
int p = u + (1 << (k - 1));
st[u][k] = max(st[u][k - 1], st[p][k - 1]);
}
}
}
long long inline qry(int l, int r) {
int k = lg[r - l + 1] - 1, len = 1 << k;
return max(st[l][k], st[r - len + 1][k]);
}
};
sparse_table st;
void inline dijkstra() {
memset(vis, 0, sizeof(vis));
memset(dis, inf, sizeof(dis));
for (int u = 1; u <= k; ++u) {
fm[u] = u;
h.push(make_pair(dis[u] = 0, u));
}
for (; h.sz;) {
int u = h.get().second;
for (int i = g.hd[u]; i; i = g.e[i].nxt) {
int v = g.e[i].to;
long long w = g.e[i].w;
if (vis[v]) continue;
if (dis[v] > dis[u] + w) {
fm[v] = fm[u];
h.push(make_pair(dis[v] = dis[u] + w, v));
}
}
}
}
void inline kruskal() {
for (int i = 1; i <= g.sz; ++i) {
int u = g.e[i].fm, v = g.e[i].to;
g.e[i].w += dis[u] + dis[v];
}
sort(g.e + 1, g.e + g.sz + 1);
uf.init();
for (int i = 1; i <= g.sz; ++i) {
int u = fm[g.e[i].fm], v = fm[g.e[i].to];
long long w = g.e[i].w;
if (uf.unite(u, v)) {
tr.connect(u, v, w);
}
}
}
void dfs1(int u = rt) {
siz[u] = 1;
for (int i = tr.hd[u]; i; i = tr.e[i].nxt) {
int v = tr.e[i].to;
long long w = tr.e[i].w;
if (v == pr[u]) continue;
pr[v] = u;
::w[v] = w;
dep[v] = dep[u] + 1;
dfs1(v);
siz[u] += siz[v];
if (siz[hs[u]] < siz[v]) {
hs[u] = v;
}
}
}
void dfs2(int u = rt, int tp = rt) {
id[u] = ++t;
top[u] = tp;
if (!hs[u]) return;
dfs2(hs[u], tp);
for (int i = tr.hd[u]; i; i = tr.e[i].nxt) {
int v = tr.e[i].to;
if (v == pr[u] || v == hs[u]) continue;
dfs2(v, v);
}
}
long long inline qry(int u, int v) {
long long res = 0;
for (; top[u] != top[v]; v = pr[top[v]]) {
if (dep[top[u]] > dep[top[v]]) {
swap(u, v);
}
res = max(res, st.qry(id[top[v]], id[v]));
}
if (dep[u] > dep[v]) {
swap(u, v);
}
if (id[u] + 1 <= id[v]) {
res = max(res, st.qry(id[u] + 1, id[v]));
}
return res;
}
void inline init() {
dijkstra();
kruskal();
dfs1();
dfs2();
st.init();
}
int main() {
read(n), read(m), read(k), read(q);
for (int i = 1; i <= m; ++i) {
int u, v, w;
read(u), read(v), read(w);
g.connect(u, v, w);
}
init();
for (int i = 1; i <= q; ++i) {
int u, v;
read(u), read(v);
write(qry(u, v));
}
(fwrite(puf, 1, p - puf, stdout), p = puf);
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = 1e5 + 11;
const int B = 1e6 + 11;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
inline int read() {
char c = getchar();
int x = 0, f = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
return x * f;
}
struct edgexx {
int v, nxt, w;
} edge[B];
struct edgex {
int v, nxt;
} edge_[B];
struct node {
long long d;
int id;
bool operator<(const node &a) const { return d > a.d; }
};
struct xxs {
int u, v;
long long w;
bool operator<(const xxs &e) const { return w < e.w; }
} e[B];
int n, cnt, js, k, c, t, head[B], m, q, head2[B], fa[B], u_fa[B];
long long dis[B], wnd[B];
int sz[B], son[B], top[B], dep[B];
priority_queue<node> pq;
void add1(int u, int v, int w) {
edge[++cnt].nxt = head[u];
edge[cnt].v = v;
edge[cnt].w = w;
head[u] = cnt;
}
void add2(int u, int v) {
edge_[++js].nxt = head2[u];
edge_[js].v = v;
head2[u] = js;
}
int find(int x) {
if (x == u_fa[x]) return x;
return u_fa[x] = find(u_fa[x]);
}
void dfs1(int u, int f) {
sz[u] = 1;
dep[u] = dep[fa[u] = f] + 1;
for (int i = head2[u]; i; i = edge_[i].nxt) {
int v = edge_[i].v;
if (v == f) continue;
dfs1(v, u);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int topf) {
top[u] = topf;
if (son[u]) dfs2(son[u], topf);
for (int i = head2[u]; i; i = edge_[i].nxt) {
int v = edge_[i].v;
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
int main() {
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++) {
int x = read(), y = read(), z = read();
add1(x, y, z);
add1(y, x, z);
e[i] = (xxs){x, y, z};
}
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= k; i++) pq.push((node){dis[i] = 0, i});
while (!pq.empty()) {
long long d = pq.top().d;
int u = pq.top().id;
pq.pop();
if (d != dis[u]) continue;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].v;
if (dis[v] > d + edge[i].w) pq.push((node){dis[v] = d + edge[i].w, v});
}
}
for (int i = 1; i <= m; i++) e[i].w += dis[e[i].u] + dis[e[i].v];
sort(e + 1, e + 1 + m);
for (int i = 1; i <= 2 * n; i++) u_fa[i] = i;
cnt = n;
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v;
long long w = e[i].w;
u = find(u);
v = find(v);
if (u == v) continue;
u_fa[u] = u_fa[v] = ++cnt;
wnd[cnt] = w;
add2(cnt, u);
add2(cnt, v);
}
dfs1(cnt, 0);
dfs2(cnt, cnt);
while (q--) {
int u = read(), v = read();
printf("%lld\n", wnd[lca(u, v)]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 100002;
const int M_MAX = 300002;
const int Q_MAX = 300002;
const int W_MAX = 1000000001;
const long long INF = 1LL * M_MAX * W_MAX;
int n, m, k, q;
struct Edge {
int u, v;
long long w;
int other(int node) { return this->u + this->v - node; }
};
bool operator<(const Edge &a, const Edge &b) { return a.w < b.w; }
Edge edges[M_MAX];
vector<Edge *> outEdges[N_MAX];
int qa[Q_MAX], qb[Q_MAX];
long long l[Q_MAX], r[Q_MAX], mid[Q_MAX];
int finish;
vector<pair<long long, int> > mids;
int root[N_MAX];
int find_root(int node) {
if (root[node] == node) return node;
return root[node] = find_root(root[node]);
}
void join(int u, int v) {
u = find_root(u);
v = find_root(v);
if (u == v) return;
root[u] = v;
}
long long d[N_MAX];
set<pair<long long, int> > s;
bool visited[N_MAX];
void dijkstra() {
for (int i = 1; i <= k; i++) s.insert(make_pair(0, i));
while (!s.empty()) {
pair<long long, int> f = *s.begin();
s.erase(s.begin());
if (visited[f.second] == true) continue;
visited[f.second] = true;
d[f.second] = f.first;
for (Edge *e : outEdges[f.second])
if (visited[e->other(f.second)] == false)
s.insert(make_pair(f.first + e->w, e->other(f.second)));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; i++) {
cin >> edges[i].u >> edges[i].v >> edges[i].w;
outEdges[edges[i].u].push_back(&edges[i]);
outEdges[edges[i].v].push_back(&edges[i]);
}
for (int i = 1; i <= q; i++) cin >> qa[i] >> qb[i];
for (int i = 1; i <= n; i++) d[i] = INF;
dijkstra();
long long mx = -1;
for (int i = 1; i <= m; i++) {
edges[i].w += d[edges[i].u] + d[edges[i].v];
mx = max(mx, edges[i].w);
}
for (int i = 1; i <= q; i++) {
l[i] = 0;
r[i] = mx;
}
sort(edges + 1, edges + m + 1);
while (finish < q) {
mids.clear();
for (int i = 1; i <= q; i++)
if (l[i] < r[i]) {
mid[i] = (l[i] + r[i]) / 2;
mids.push_back(make_pair(mid[i], i));
}
sort(mids.begin(), mids.end());
int pos = 0;
for (int i = 1; i <= n; i++) root[i] = i;
for (int i = 0; i < mids.size(); i++) {
while (pos < m && edges[pos + 1].w <= mids[i].first) {
pos++;
join(edges[pos].u, edges[pos].v);
}
if (find_root(qa[mids[i].second]) == find_root(qb[mids[i].second]))
r[mids[i].second] = mids[i].first;
else
l[mids[i].second] = mids[i].first + 1;
if (l[mids[i].second] >= r[mids[i].second]) finish++;
}
}
for (int i = 1; i <= q; i++) cout << l[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > Next[200005];
vector<pair<long long, long long> > use[200005];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
all;
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> > > >
mst;
bool have[200005] = {0};
long long con[200005];
long long Father[200005];
long long who[25][200005];
long long big[25][200005];
long long deg[200005];
pair<long long, pair<long long, long long> > t2;
pair<long long, long long> t;
long long Find(long long here) {
if (Father[here] == here) return here;
Father[here] = Find(Father[here]);
return Father[here];
}
void F(long long here, long long d) {
long long i, j;
have[here] = 1;
deg[here] = d;
for (j = 1; (1 << j) <= d; j++) {
who[j][here] = who[j - 1][who[j - 1][here]];
big[j][here] = max(big[j - 1][here], big[j - 1][who[j - 1][here]]);
}
for (auto i : use[here]) {
if (!have[i.first]) {
who[0][i.first] = here;
big[0][i.first] = i.second;
F(i.first, d + 1);
}
}
}
long long LCA(long long a, long long b) {
long long i;
if (a == b) return 0;
if (deg[a] > deg[b])
for (i = 20; i >= 0; i--)
if (deg[a] - (1 << i) >= deg[b]) return max(LCA(who[i][a], b), big[i][a]);
if (deg[a] < deg[b])
for (i = 20; i >= 0; i--)
if (deg[b] - (1 << i) >= deg[a]) return max(LCA(a, who[i][b]), big[i][b]);
if (who[0][a] == who[0][b]) return max(big[0][a], big[0][b]);
for (i = 20; i >= 0; i--)
if ((1 << i) <= max(deg[a], deg[b]) && who[i][a] != who[i][b])
return max(max(big[i][a], big[i][b]), LCA(who[i][a], who[i][b]));
}
int main() {
long long N, M, K, Q, tt, i, a, b;
scanf("%lld %lld %lld %lld", &N, &M, &K, &Q);
for (i = 0; i < M; i++) {
scanf("%lld %lld %lld", &a, &b, &tt);
Next[a].push_back(make_pair(b, tt));
Next[b].push_back(make_pair(a, tt));
}
for (i = 1; i <= K; i++) all.push(make_pair(0, i));
while (!all.empty()) {
t = all.top();
all.pop();
if (have[t.second]) continue;
have[t.second] = 1;
con[t.second] = t.first;
for (auto i : Next[t.second])
all.push(make_pair(t.first + i.second, i.first));
}
for (i = 1; i <= N; i++) {
have[i] = 0;
Father[i] = i;
for (auto &j : Next[i]) {
j.second += con[i];
j.second += con[j.first];
mst.push(make_pair(j.second, make_pair(i, j.first)));
}
}
while (!mst.empty()) {
t2 = mst.top();
mst.pop();
if (Find(t2.second.first) != Find(t2.second.second)) {
Father[Find(t2.second.first)] = Find(t2.second.second);
use[t2.second.first].push_back(make_pair(t2.second.second, t2.first));
use[t2.second.second].push_back(make_pair(t2.second.first, t2.first));
}
}
F(1, 0);
while (Q--) {
scanf("%lld %lld", &a, &b);
printf("%lld\n", LCA(a, b));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long INF = 1e18;
const int md = 1e9 + 7;
const int N = 3e5 + 1;
struct edge {
int v, u;
long long w;
edge() {}
edge(int v, long long w, int u = -1) : v(v), w(w), u(u) {}
};
vector<edge> g[N];
int p[N];
long long ANS[N];
vector<pair<int, int>> Q[N];
void make(int v) { p[v] = v; }
void add_q(int a, int b, int num) {
Q[a].push_back({b, num});
Q[b].push_back({a, num});
}
int fin(int v) {
if (p[v] == v) return v;
return p[v] = fin(p[v]);
}
void un(int a, int b, long long W) {
a = fin(a), b = fin(b);
if (a == b) return;
if ((int)(Q[a]).size() < (int)(Q[b]).size()) swap(a, b);
for (auto u : Q[b]) {
if (fin(u.first) == a)
ANS[u.second] = W;
else
Q[a].push_back(u);
}
p[b] = a;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, k, q;
cin >> n >> m >> k >> q;
vector<edge> edges(m);
for (int f = 0; f < m; ++f) {
int u, v, w;
cin >> u >> v >> w;
--u, --v;
g[v].push_back(edge{u, w});
g[u].push_back(edge{v, w});
edges[f] = edge{u, w, v};
}
vector<long long> d(n, inf);
auto cmp = [&](int a, int b) { return d[a] < d[b]; };
priority_queue<pair<long long, int>> DJ;
for (int f = 0; f < k; ++f) {
d[f] = 0;
DJ.push({d[f], f});
}
while (!DJ.empty()) {
int head = DJ.top().second;
DJ.pop();
for (auto u : g[head]) {
if (d[u.v] > d[head] + u.w) {
d[u.v] = d[head] + u.w;
DJ.push({-d[u.v], u.v});
}
}
}
for (int f = 0; f < m; ++f) edges[f].w += d[edges[f].u] + d[edges[f].v];
vector<int> perm(m);
for (int i = 0; i < m; ++i) perm[i] = i;
sort(perm.begin(), perm.end(),
[&](int a, int b) { return edges[a].w < edges[b].w; });
for (int f = 0; f < n; ++f) make(f);
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
add_q(a, b, i);
}
for (int f = 0; f < m; ++f) {
int curr = perm[f];
un(edges[curr].u, edges[curr].v, edges[curr].w);
}
for (int f = 0; f < q; ++f) cout << ANS[f] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
long long w;
} e[300010];
struct Query {
int a, b;
long long ans;
Query() { ans = -1; }
} q[300010];
struct data {
int u;
long long s;
data(){};
data(int a, long long b) { u = a, s = b; }
bool operator<(const data &a) const { return s > a.s; }
};
int n, m, k, Q;
int fa[100010];
int cnt, head[100010], nxt[300010 << 1], to[300010 << 1], w[300010 << 1];
long long dis[100010];
vector<int> g[100010];
priority_queue<data> que;
void adde(int u, int v, int wi) {
to[++cnt] = v;
w[cnt] = wi;
nxt[cnt] = head[u];
head[u] = cnt;
}
void dijkstra() {
memset(dis, 127, sizeof(dis));
for (int i = 1; i <= k; i++) que.push(data(i, 0)), dis[i] = 0;
while (!que.empty()) {
data now = que.top();
que.pop();
for (int i = head[now.u]; i; i = nxt[i]) {
int v = to[i];
if (dis[now.u] + w[i] <= dis[v]) {
dis[v] = dis[now.u] + w[i];
que.push(data(v, dis[v]));
}
}
}
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
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++) {
scanf("%d%d%lld", &e[i].u, &e[i].v, &e[i].w);
adde(e[i].u, e[i].v, e[i].w), adde(e[i].v, e[i].u, e[i].w);
}
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &q[i].a, &q[i].b);
g[q[i].a].push_back(i), g[q[i].b].push_back(i);
}
dijkstra();
for (int i = 1; i <= m; i++) e[i].w = e[i].w + dis[e[i].u] + dis[e[i].v];
sort(e + 1, e + m + 1, cmp);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int a = find(e[i].u), b = find(e[i].v);
if (a != b) {
if (g[b].size() < g[a].size()) swap(a, b);
fa[a] = b;
for (int j = 0, size = g[a].size(); j < size; j++) {
int x = find(q[g[a][j]].a), y = find(q[g[a][j]].b);
if (x == y) {
if (q[g[a][j]].ans == -1) q[g[a][j]].ans = e[i].w;
} else
g[b].push_back(g[a][j]);
}
}
}
for (int i = 1; i <= Q; i++) printf("%lld\n", q[i].ans);
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] = max(drank[a], drank[b] + 1);
} else {
dsu[a] = b;
swap(a, b);
drank[a] = max(drank[a], drank[b] + 1);
}
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;
}
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;
int lg(long long n) {
assert(n > 0);
int ans = -1;
while (n) {
ans++;
n >>= 1;
}
return ans;
}
struct DSU {
vector<int> fa, sz;
DSU() {}
DSU(int n) {
fa.resize(n);
iota(fa.begin(), fa.end(), 0);
sz.assign(n, 1);
}
bool join(int x, int y) {
int a = find(x), b = find(y);
if (a != b) {
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
fa[b] = a;
return true;
}
return false;
}
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
};
void solve() {
int n, m, k, q;
cin >> n >> m >> k >> q;
vector<tuple<int, int, int>> edges(m);
vector<vector<pair<int, int>>> adj(n);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
edges[i] = make_tuple(u, v, w);
adj[u].emplace_back(v, w);
adj[v].emplace_back(u, w);
}
const long long INF = 9e18;
set<pair<long long, int>> qu;
vector<long long> d(n, INF);
for (int i = 0; i < k; i++) {
d[i] = 0;
qu.insert({0, i});
}
while (!qu.empty()) {
int v = qu.begin()->second;
qu.erase(qu.begin());
for (auto [to, len] : adj[v]) {
if (d[v] + len < d[to]) {
qu.erase({d[to], to});
d[to] = d[v] + len;
qu.insert({d[to], to});
}
}
}
vector<tuple<long long, int, int>> newedge(m);
for (int i = 0; i < m; i++) {
auto [u, v, w] = edges[i];
newedge[i] = make_tuple(d[u] + d[v] + w, u, v);
}
sort(newedge.begin(), newedge.end());
vector<pair<int, int>> queries(q);
vector<long long> ans(q);
vector<vector<int>> tokens(n);
vector<int> where(q * 2);
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
u--, v--;
queries[i] = make_pair(u, v);
tokens[u].push_back(2 * i);
tokens[v].push_back(2 * i + 1);
where[2 * i] = u;
where[2 * i + 1] = v;
}
DSU dsu(n);
for (auto [w, u, v] : newedge) {
u = dsu.find(u);
v = dsu.find(v);
if (u == v) continue;
if (dsu.sz[u] < dsu.sz[v]) {
swap(u, v);
}
for (int t : tokens[v]) {
if (dsu.find(where[t ^ 1]) == u) {
assert(ans[t / 2] == 0);
ans[t / 2] = w;
}
tokens[u].push_back(t);
}
dsu.join(u, v);
tokens[v].clear();
}
for (int i = 0; i < q; i++) {
cout << ans[i] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n, m, k, q;
int fa[N];
long long dis[N];
long long ans[N];
vector<pair<int, int> > g[N], Q[N];
priority_queue<pair<long long, pair<int, int> > > h;
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
void update(int x) {
for (auto u : g[x])
if (dis[u.first] > dis[x] + u.second) {
h.push(make_pair(-(dis[u.first] = dis[x] + u.second),
make_pair(u.first, x)));
}
}
void combine1(int x, int y) {
update(x);
x = getfa(x), y = getfa(y);
fa[x] = y;
}
void combine(int x, int y, long long v) {
x = getfa(x), y = getfa(y);
if (x == y) return;
if (Q[x].size() < Q[y].size()) swap(x, y);
fa[y] = x;
for (auto u : Q[y])
if (getfa(x) == getfa(u.first)) {
if (!ans[u.second]) ans[u.second] = v;
} else
Q[x].push_back(u);
}
int main() {
scanf("%d %d %d %d", &n, &m, &k, &q);
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
g[x].push_back(make_pair(y, z));
g[y].push_back(make_pair(x, z));
}
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d %d", &x, &y);
Q[x].push_back(make_pair(y, i));
Q[y].push_back(make_pair(x, i));
}
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = k + 1; i <= n; i++) dis[i] = 1e18;
for (int i = 1; i <= k; i++) update(i);
while (!h.empty()) {
auto x = h.top();
h.pop();
if (dis[x.second.first] != -x.first) continue;
combine1(x.second.first, x.second.second);
}
for (int i = 1; i <= n; i++)
for (auto u : g[i])
h.push(
make_pair(-dis[i] - dis[u.first] - u.second, make_pair(u.first, i)));
while (!h.empty()) {
auto x = h.top();
h.pop();
combine(x.second.first, x.second.second, -x.first);
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e6 + 8, mod = 1e9 + 8, inf = 1ll << 50;
struct E {
int x, y, nt;
long long v;
bool operator<(const E& b) const { return v < b.v; }
} e[MAXN];
int head[MAXN], cnt;
inline void add(int x, int y, long long v) {
e[++cnt].nt = head[x];
head[x] = cnt;
e[cnt].v = v;
e[cnt].x = x;
e[cnt].y = y;
}
struct Node {
int y, nt;
} node[MAXN << 1];
int Nodehead[MAXN << 1], Nodecnt;
inline void addNode(int x, int y) {
node[++Nodecnt].nt = Nodehead[x];
node[Nodecnt].y = y;
Nodehead[x] = Nodecnt;
}
int n, m, k, q;
long long dis[MAXN];
bool vis[MAXN];
void dijkstra() {
priority_queue<pair<long long, int>> que;
for (int i = 1; i <= k; ++i) que.emplace(0, i);
for (int i = k + 1; i <= n; ++i) dis[i] = inf;
int x, y;
long long v;
while (!que.empty()) {
x = que.top().second;
que.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; i; i = e[i].nt) {
y = e[i].y, v = e[i].v;
if (dis[y] > dis[x] + v) {
dis[y] = dis[x] + v;
que.emplace(-dis[y], y);
}
}
}
}
int deep[MAXN << 1], son[MAXN << 1], fa[MAXN << 1], tot[MAXN << 1];
void dfs1(int x, int f) {
deep[x] = deep[f] + 1, tot[x] = 1, fa[x] = f;
int max_son = -1;
for (int i = Nodehead[x]; i; i = node[i].nt) {
int y = node[i].y;
if (tot[y]) continue;
dfs1(y, x);
tot[x] += tot[y];
if (max_son < tot[y]) son[x] = y, max_son = tot[y];
}
}
int top[MAXN << 1];
void dfs2(int x, int tp) {
top[x] = tp;
if (son[x])
dfs2(son[x], tp);
else
return;
for (int i = Nodehead[x]; i; i = node[i].nt) {
int y = node[i].y;
if (top[y]) continue;
dfs2(y, y);
}
}
int lca(int x, int y) {
while (top[x] ^ top[y]) {
if (deep[top[x]] < deep[top[y]])
y = fa[top[y]];
else
x = fa[top[x]];
}
if (deep[x] > deep[y]) return y;
return x;
}
int find(int x) { return x ^ fa[x] ? (fa[x] = find(fa[x])) : x; }
long long val[MAXN << 1];
void kruskal() {
int id = n;
sort(e + 1, e + 1 + cnt);
for (int i = 0; i < n * 2 + 2; ++i) fa[i] = i;
for (int i = 1; i <= cnt; ++i) {
int fx = find(e[i].x), fy = find(e[i].y);
if (fx ^ fy) {
val[++id] = e[i].v;
fa[fx] = fa[fy] = id;
addNode(id, fx);
addNode(fx, id);
addNode(id, fy);
addNode(fy, id);
}
}
dfs1(id, 0);
dfs2(id, id);
}
int main() {
cin >> n >> m >> k >> q;
for (int i = 0; i < m; ++i) {
int x, y;
long long v;
scanf("%d%d%lld", &x, &y, &v);
add(x, y, v);
add(y, x, v);
}
dijkstra();
for (int i = 1; i <= n; ++i)
for (int j = head[i]; j; j = e[j].nt) {
e[j].v += dis[e[j].x] + dis[e[j].y];
}
kruskal();
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%lld\n", val[lca(x, y)]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[200010];
void dfs(vector<long long int> arr[], long long int i, long long int temp) {
vis[i] = true;
for (long long int u : arr[i]) {
if (!vis[u] and u != temp) dfs(arr, u, temp);
}
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m, a, b, u, v;
cin >> n >> m >> a >> b;
vector<long long int> arr[n + 1];
for (long long int i = 0; i < m; i++) {
cin >> u >> v;
arr[u].push_back(v);
arr[v].push_back(u);
}
memset(vis, false, sizeof(vis));
dfs(arr, a, b);
unordered_set<long long int> us1;
for (long long int i = 1; i <= n; i++) {
if (vis[i]) us1.insert(i);
}
us1.erase(a);
memset(vis, false, sizeof(vis));
dfs(arr, b, a);
unordered_set<long long int> us2;
for (long long int i = 1; i <= n; i++) {
if (vis[i]) us2.insert(i);
}
us2.erase(b);
long long int ans1 = 0, ans2 = 0;
for (auto val : us1) {
if (us2.find(val) == us2.end()) ans1++;
}
for (auto val : us2) {
if (us1.find(val) == us1.end()) ans2++;
}
cout << ans1 * ans2 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace gao {
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
struct node {
int t, nt;
} e[1000005 << 1];
int f[1000005], c[1000005], head[1000005], sz[1000005], n, tot, a, b, m, n2;
long long ans;
inline void add2(int u, int v) {
e[++tot].t = v;
e[tot].nt = head[u];
head[u] = tot;
}
inline void add(int u, int v) { add2(u, v), add2(v, u); }
inline void dfs(int u, int fa) {
f[u] = fa;
sz[u] = c[u];
for (int i = head[u]; i; i = e[i].nt) {
int v = e[i].t;
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
inline void calc() {
dfs(a, 0);
int u = b;
while (f[u] != a) u = f[u];
ans = 1ll * (n2 - sz[u] - 1) * (sz[b] - 1);
printf("%lld\n", ans);
}
inline void clear() {
for (int i = 1; i <= n; i++) head[i] = sz[i] = c[i] = f[i] = 0;
n = tot = 0;
}
} // namespace gao
namespace gao2 {
struct node {
int t, nt;
} e[1000005 << 1];
int n, f[1000005], head[1000005], tot, dfn[1000005], low[1000005], st[1000005],
tp, cnt;
inline void add(int u, int v) {
e[++tot].t = v;
e[tot].nt = head[u];
head[u] = tot;
}
inline void tarjan(int u, int fa) {
dfn[u] = low[u] = ++cnt;
st[++tp] = u;
for (int i = head[u]; i; i = e[i].nt) {
int v = e[i].t;
if (v == fa) continue;
if (!dfn[v]) {
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
gao::n++;
gao::add(u, gao::n);
while (tp > 0) {
gao::add(gao::n, st[tp]);
tp--;
if (st[tp + 1] == v) break;
}
}
} else
low[u] = min(low[u], dfn[v]);
}
}
inline void solve() {
gao::n = n;
for (int i = 1; i <= n; i++) gao::c[i] = 1;
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i, 0);
}
}
inline void clear() {
for (int i = 1; i <= n; i++) head[i] = dfn[i] = low[i] = st[i] = 0;
n = tot = cnt = tp = 0;
}
} // namespace gao2
int T, n, a, b, m;
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
signed main() {
T = read();
while (T--) {
gao::clear();
gao2::clear();
n = read(), m = read(), gao::a = read(), gao::b = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
gao2::add(u, v), gao2::add(v, u);
}
gao2::n = n;
gao::n2 = n;
gao2::solve();
gao::calc();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b % a, a);
}
long long powerMod(long long x, long long y) {
long long res = 1;
x %= 998244353;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res % 998244353;
}
string binary(long long s) {
string res = "";
while (s != 0) {
res += (char)('0' + s % 2);
s /= 2;
}
reverse(res.begin(), res.end());
return res;
}
vector<int> parent;
vector<set<int> > adj;
vector<bool> vi;
set<int> ea, emplace_back;
int n, a, b;
int find(int a) { return a == parent[a] ? a : parent[a] = find(parent[a]); }
void join(int a, int b) { parent[find(b)] = find(a); }
void dfs(int p, int node) {
for (int i : adj[node]) {
parent[i] = p;
if (!vi[i]) {
vi[i] = true;
dfs(p, i);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int i, j, k, l, m, p, s, t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
--a;
--b;
parent.resize(n);
vi.resize(n, false);
adj.resize(n);
for (i = 0; i < n; i++) parent[i] = i;
for (i = 0; i < m; i++) {
cin >> j >> k;
--j, --k;
if (j == a || k == a || j == b || k == b) {
if ((j == a && k == b) || (j == b && k == a))
;
else if (j == a)
ea.insert(k);
else if (j == b)
emplace_back.insert(k);
else if (k == a)
ea.insert(j);
else if (k == b)
emplace_back.insert(j);
continue;
}
adj[j].insert(k);
adj[k].insert(j);
}
for (i = 0; i < n; i++) {
if (!vi[i]) {
vi[i] = true;
dfs(i, i);
}
}
set<int> da, db;
for (int i : ea) {
da.insert(find(i));
}
for (int i : emplace_back) {
db.insert(find(i));
}
vector<int> rem;
for (int i : da) {
if (db.find(i) != db.end()) {
rem.emplace_back(i);
}
}
for (int i : rem) {
da.erase(i);
db.erase(i);
}
vector<int> cnt(n, 0);
for (i = 0; i < n; i++) {
cnt[find(i)]++;
}
long long aa = 0LL, bb = 0LL;
for (int i : da) {
aa += cnt[i];
}
for (int i : db) {
bb += cnt[i];
}
cout << (aa * bb) << "\n";
adj.clear();
ea.clear();
emplace_back.clear();
vi.clear();
parent.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int n, m, a, b;
vector<int> adj[N];
int sz[N], mark[N], tin[N], timer, found_b;
int qnt_a, qnt_b;
void dfs(int v) {
found_b |= (v == b);
mark[v] = tin[v] = ++timer;
sz[v] = 1;
for (int u : adj[v]) {
if (mark[u]) {
tin[v] = min(tin[v], mark[u]);
} else {
int bef = found_b;
dfs(u);
if (v == a && bef == 0 && found_b == 1) {
qnt_a -= sz[u];
}
sz[v] += sz[u];
tin[v] = min(tin[v], tin[u]);
if (v == b && tin[u] >= mark[v]) {
qnt_b += sz[u];
}
}
}
if (v == a) {
qnt_a += sz[a] - 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tot_cas;
cin >> tot_cas;
for (int cas = 1; cas <= tot_cas; cas++) {
cin >> n >> m >> a >> b;
for (int i = 1; i <= n; i++) {
adj[i].clear();
mark[i] = tin[i] = sz[i] = 0;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
timer = found_b = qnt_a = qnt_b = 0;
dfs(a);
cout << 1ll * qnt_a * qnt_b << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int maxm = 5e5 + 5;
struct edge {
int to, next;
} G[maxm << 1];
int tot, head[maxn];
void addEdge(int u, int v) {
G[tot] = {v, head[u]};
head[u] = tot++;
}
int T, n, m, a, b, visa[maxn], visb[maxn];
void bfs1() {
for (int i = 1; i <= n; i++) visa[i] = 0;
queue<int> q;
q.push(a);
visa[a] = 1;
int u, v, i;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = G[i].next) {
v = G[i].to;
if (visa[v]) continue;
visa[v] = 1;
if (v != b) q.push(v);
}
}
}
void bfs2() {
for (int i = 1; i <= n; i++) visb[i] = 0;
queue<int> q;
q.push(b);
visb[b] = 1;
int u, v, i;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = G[i].next) {
v = G[i].to;
if (visb[v]) continue;
visb[v] = 1;
if (v != a) q.push(v);
}
}
}
int main() {
for (cin >> T; T--;) {
cin >> n >> m >> a >> b;
tot = 0;
for (int i = 1; i <= n; i++) {
head[i] = -1;
visa[i] = visb[i] = 0;
}
int u, v;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
addEdge(u, v);
addEdge(v, u);
}
bfs1();
bfs2();
long long A = 0, B = 0;
for (int i = 1; i <= n; i++) {
A += visa[i] && !visb[i];
B += visb[i] && !visa[i];
}
cout << A * B << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m, a, b;
cin >> n >> m >> a >> b;
std::vector<int> gra[n + 1], grb[n + 1];
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
if ((l == a or r == a) and (l == b or r == b))
continue;
else if (l == a or r == a) {
gra[l].push_back(r);
gra[r].push_back(l);
} else if (l == b or r == b) {
grb[l].push_back(r);
grb[r].push_back(l);
} else {
gra[l].push_back(r);
gra[r].push_back(l);
grb[l].push_back(r);
grb[r].push_back(l);
}
}
int vis[n + 1];
memset(vis, 0, sizeof(vis));
queue<int> q;
q.push(a);
vis[a] = 1;
long long int ca = 0;
while (q.size()) {
int i = q.front();
ca++;
q.pop();
for (auto j : gra[i]) {
if (!vis[j]) {
vis[j] = 1;
q.push(j);
}
}
}
memset(vis, 0, sizeof(vis));
q.push(b);
vis[b] = 1;
long long int cb = 0;
while (q.size()) {
int i = q.front();
cb++;
q.pop();
for (auto j : grb[i]) {
if (!vis[j]) {
vis[j] = 1;
q.push(j);
}
}
}
ca = n - ca - 1;
cb = n - cb - 1;
ca *= cb;
cout << ca << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 1000000007;
const long long mod1 = 998244353;
using namespace std;
long long n, m, a, b, sum = 0;
vector<long long> v[200005];
bool visited[200005];
void dfs(long long x, long long y) {
if (x == y) return;
visited[x] = true, sum++;
for (long long i = 0; i < v[x].size(); i++) {
if (!visited[v[x][i]]) {
dfs(v[x][i], y);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
for (long long i = 0; i <= n + 1; i++) v[i].clear(), visited[i] = false;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(a, b);
long long xz = sum;
sum = 0;
for (long long i = 0; i <= n; i++) visited[i] = false;
dfs(b, a);
long long yz = sum;
sum = 0;
long long z = xz + yz - n;
xz -= z + 1, yz -= z + 1;
cout << xz * yz << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
void dfs(int u, int r, vector<vector<int>> &adj, vector<int> &color) {
color[u] = 1;
for (auto v : adj[u]) {
if (color[v] == 0 && v != r) {
dfs(v, r, adj, color);
}
}
color[u] = 2;
}
void sherlock(int t) {
int n, m, a, b;
cin >> n >> m >> a >> b;
vector<vector<int>> adj(n + 1);
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<int> colora(n + 1), colorb(n + 1);
dfs(a, b, adj, colora);
dfs(b, a, adj, colorb);
int x = 0, y = 0;
for (int i = 1; i <= n; i++) {
if (colora[i] == 2 && colorb[i] == 0) x++;
if (colora[i] == 0 && colorb[i] == 2) y++;
}
cout << (x - 1) * 1LL * (y - 1) << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
for (int t = 1; t <= tt; t++) sherlock(t);
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimize("O3")
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 2 * 1e12 + 7;
const int base = 2e5 + 1;
const int MAX = 1e4 + 2;
const double EPS = 1e-9;
const double PI = acos(-1.);
const int MAXN = 2 * 1e6 + 1;
int main() {
int t;
cin >> t;
while (t--) {
int n, m, a, b;
cin >> n >> m >> a >> b;
vector<vector<int> > g(n + 1), from(n + 1);
vector<int> was(n + 1, 0), can(n + 1, 1), was2(n + 1, 0), p(n + 1),
used(n + 1, 0);
for (long long i = (0); i < (m); ++i) {
int v, u;
cin >> v >> u;
g[v].push_back(u);
g[u].push_back(v);
}
queue<int> q;
q.push(a);
was[a] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
if (v == b) continue;
for (auto u : g[v]) {
if (!was[u]) {
was[u] = 1;
q.push(u);
p[u] = v;
}
from[u].push_back(v);
}
}
stack<int> s;
s.push(b);
was2[b] = 1;
while (!s.empty()) {
int v = s.top();
s.pop();
if (v == a) continue;
can[v] = 0;
for (auto u : from[v]) {
if (!was2[u]) {
was2[u] = 1;
s.push(u);
}
}
}
can[a] = 1;
can[b] = 1;
long long c1 = -1, c2 = -1;
s.push(a);
used[a] = 1;
while (!s.empty()) {
int v = s.top();
s.pop();
c1++;
for (auto u : g[v]) {
if (!can[u] || u == b) continue;
if (!used[u]) {
used[u] = 1;
s.push(u);
}
}
}
s.push(b);
used[b] = 1;
while (!s.empty()) {
int v = s.top();
s.pop();
c2++;
for (auto u : g[v]) {
if (!can[u] || u == a) continue;
if (!used[u]) {
used[u] = 1;
s.push(u);
}
}
}
cout << c1 * c2 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const long long maxn = 2e6 + 9, inf = 0x3f3f3f3f;
long long Read() {
long long x(0), f(1);
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3ll) + (x << 1ll) + c - '0';
c = getchar();
}
return x * f;
}
long long T, n, m;
struct node {
long long to, nxt;
} dis[maxn];
long long num, tim, N, tot, a, b, flag;
long long visit[maxn], dfn[maxn], low[maxn], head[maxn], ge[maxn];
void Add(long long u, long long v) {
dis[++num] = (node){v, head[u]};
head[u] = num;
}
void Dfs(long long u, long long ff) {
flag |= (u == ff);
visit[u] = 1;
++tot;
for (long long i = head[u]; i; i = dis[i].nxt) {
long long v(dis[i].to);
if (!visit[v]) Dfs(v, ff);
}
}
void solve() {
for (long long i = 1; i <= n; ++i) visit[i] = 0;
visit[a] = 1;
long long N(0), Tmp, flag1(0);
for (long long i = head[a]; i; i = dis[i].nxt) {
long long v(dis[i].to);
if (!visit[v]) {
flag = 0;
tot = 0;
Dfs(v, b);
N += tot;
if (flag) Tmp = tot, flag1 = 1;
}
}
if (flag1) {
long long N1(N - Tmp);
N = flag1 = 0;
for (long long i = 1; i <= n; ++i) visit[i] = 0;
visit[b] = 1;
for (long long i = head[b]; i; i = dis[i].nxt) {
long long v(dis[i].to);
if (!visit[v]) {
flag = 0;
tot = 0;
Dfs(v, a);
N += tot;
if (flag) Tmp = tot, flag1 = 1;
}
}
if (flag1) {
long long N2(N - Tmp);
printf("%lld\n", N1 * N2);
} else
puts("0");
} else
puts("0");
}
int main() {
T = Read();
while (T--) {
n = Read();
m = Read();
a = Read();
b = Read();
num = tim = 0;
for (long long i = 1; i <= n; ++i) head[i] = dfn[i] = low[i] = ge[i] = 0;
for (long long i = 1; i <= m; ++i) {
long long u(Read()), v(Read());
Add(u, v);
Add(v, u);
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long INF = 0x3f3f3f3f;
const long long M = 1e9 + 7;
const long long N = 2e5 + 5;
vector<long long> g[N];
long long n, m, a, b;
bool d[N];
long long ctr;
bool va, vb;
void dfs(long long z) {
if (z == a) {
va = true;
return;
}
if (z == b) {
vb = true;
return;
}
ctr++;
for (long long y : g[z]) {
if (!d[y]) {
if (y != a && y != b) d[y] = true;
dfs(y);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(15);
long long t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
for (long long i = 1; i <= n; ++i) g[i].clear();
for (long long i = 0; i < m; ++i) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
memset(d, 0, sizeof(d));
long long na = 0, nb = 0;
for (long long i = 1; i <= n; ++i) {
if (i == a || i == b) continue;
if (d[i]) continue;
ctr = 0;
va = vb = false;
d[i] = true;
dfs(i);
if (va && !vb) na += ctr;
if (vb && !va) nb += ctr;
}
cout << na * nb << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 * 100 + 17;
vector<long long> adj[N];
long long t, n, m, a, b;
bool mark[N], vis[N];
void dfs1(int st, int p) {
mark[st] = true;
for (auto v : adj[st])
if (mark[v] == false && v != p) dfs1(v, p);
}
void dfs2(int st, int p) {
vis[st] = true;
for (auto v : adj[st])
if (vis[v] == false && v != p) dfs2(v, p);
}
long long solve() {
long long res = 0;
for (int i = 1; i <= n; i++)
if (mark[i]) res++;
return n - res - 1;
}
long long sov() {
long long res = 0;
for (int i = 1; i <= n; i++)
if (vis[i]) res++;
return n - res - 1;
}
void cl() {
for (int i = 1; i <= n; i++) {
adj[i].clear();
mark[i] = false;
vis[i] = false;
}
}
void input() {
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
long long x, y;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs1(a, b);
dfs2(b, a);
x = sov(), y = solve();
cout << x * y << endl;
cl();
}
}
int main() {
input();
return 0;
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
vector<long long int> adj[300005];
long long int mark[300005], cnt;
void dfs(long long int u) {
mark[u] = 1;
cnt++;
for (long long int i = 0; i < adj[u].size(); i++) {
long long int p = adj[u][i];
if (mark[p]) continue;
dfs(p);
}
}
int main() {
long long int tc, n, m, x, y, i, j, a, b;
cin >> tc;
while (tc--) {
cin >> n >> m >> a >> b;
for (i = 1; i <= m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (i = 1; i <= n; i++) mark[i] = 0;
mark[b] = 1;
cnt = 0;
dfs(a);
long long int xa = n - cnt - 1;
for (i = 1; i <= n; i++) mark[i] = 0;
mark[a] = 1;
cnt = 0;
dfs(b);
long long int xb = n - cnt - 1;
cout << xa * xb << endl;
for (i = 1; i <= n; i++) adj[i].clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fast_expo(long long int x, long long int p) {
if (p == 0)
return 1;
else if (p % 2 == 0) {
long long int t = fast_expo(x, p / 2) % 998244353;
return (t * t) % 998244353;
} else
return (x * (fast_expo(x, p - 1)) % 998244353) % 998244353;
}
vector<int> adj[200005];
int vis[200005];
int ans;
void dfs(int u, int no) {
vis[u] = 1;
ans++;
for (auto v : adj[u]) {
if (!vis[v] && v != no) dfs(v, no);
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m, a, b;
cin >> n >> m >> a >> b;
for (int i = 0; i <= n; i++) adj[i].clear(), vis[i] = 0;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
ans = 0;
dfs(a, b);
long long int val1 = n - 1 - ans;
for (int i = 0; i <= n; i++) {
vis[i] = 0;
}
ans = 0;
dfs(b, a);
long long int val2 = n - 1 - ans;
cout << val1 * val2 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
double _eps = 1e-6;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<int> adj[2 * 100000 + 10];
vector<int> path;
bool vis[2 * 100000 + 10];
bool mark[2 * 100000 + 10];
void dfs(int v, int d) {
if (v == d) {
for (int x : path) mark[x] = 1;
return;
}
if (!vis[v]) {
vis[v] = 1;
path.push_back(v);
for (int x : adj[v]) dfs(x, d);
path.pop_back();
}
}
int mx = 0;
void df(int v) {
if (!vis[v] && !mark[v]) {
vis[v] = 1;
mx++;
for (int x : adj[v]) df(x);
}
}
int main() {
int T;
cin >> T;
for (int caseno = 1; caseno <= T; caseno++) {
int a, b;
int n, m;
cin >> n >> m >> a >> b;
for (int i = 1; i <= n; ++i) adj[i].clear();
for (int i = 0; i < m; ++i) {
int k, l;
cin >> k >> l;
adj[k].push_back(l);
adj[l].push_back(k);
}
memset(vis, 0, sizeof(vis));
memset(mark, 0, sizeof(mark));
dfs(a, b);
memset(vis, 0, sizeof(vis));
dfs(b, a);
mark[a] = mark[b] = 0;
memset(vis, 0, sizeof(vis));
mx = 0;
mark[b] = 1;
df(a);
long long x = mx - 1;
memset(vis, 0, sizeof(vis));
mark[a] = 1;
mark[b] = 0;
mx = 0;
df(b);
long long y = mx - 1;
cout << x * y;
puts("");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.