text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const nmax = 300000;
vector<int> g[1 + nmax];
int mult[1 + nmax], sz[1 + nmax], seen[1 + nmax];
int jump(int a) {
if (a != mult[a]) mult[a] = jump(mult[a]);
return mult[a];
}
void unite(int gala, int galb) {
gala = jump(gala);
galb = jump(galb);
if (gala != galb) {
mult[gala] = galb;
int newdiam =
((((((sz[gala]) < (sz[galb])) ? (sz[galb]) : (sz[gala]))) <
(sz[gala] / 2 + sz[gala] % 2 + sz[galb] / 2 + sz[galb] % 2 + 1))
? (sz[gala] / 2 + sz[gala] % 2 + sz[galb] / 2 + sz[galb] % 2 + 1)
: ((((sz[gala]) < (sz[galb])) ? (sz[galb]) : (sz[gala]))));
sz[galb] = newdiam;
}
}
int farthest = 0, dist = 0;
void dfs(int node, int parent, int acc) {
seen[node] = 1;
if (dist < acc) {
dist = acc;
farthest = node;
}
for (int h = 0; h < g[node].size(); h++) {
int to = g[node][h];
if (to != parent) dfs(to, node, acc + 1);
}
}
int getdiam(int node) {
farthest = dist = 0;
dfs(node, 0, 0);
int start = farthest;
farthest = dist = 0;
dfs(start, 0, 0);
return dist;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
mult[i] = i;
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
unite(x, y);
}
for (int i = 1; i <= n; i++) {
if (seen[i] == 0) {
sz[jump(i)] = getdiam(i);
}
}
for (int i = 1; i <= q; i++) {
int op;
cin >> op;
if (op == 1) {
int x;
cin >> x;
cout << sz[jump(x)] << '\n';
} else {
int x, y;
cin >> x >> y;
unite(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
int n, m, q, Maxx[maxn], Maxy[maxn];
int cnt[maxn], parent[maxn];
vector<int> G[maxn];
int find(int x) {
if (parent[x] >= 0) {
return parent[x] = find(parent[x]);
}
return x;
}
void dfs(int u, int fa, int p) {
int v;
for (int i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v != fa) {
dfs(v, u, p);
if (Maxy[v] + 1 > Maxy[u]) {
Maxx[u] = Maxy[u];
Maxy[u] = Maxy[v] + 1;
} else if (Maxy[v] + 1 > Maxx[u]) {
Maxx[u] = Maxy[v] + 1;
}
}
}
cnt[p] = max(cnt[p], Maxy[u] + Maxx[u]);
}
int main() {
while (scanf("%d%d%d", &n, &m, &q) != EOF) {
int i, j, type, u, v;
for (i = 1; i <= n; i++) {
G[i].clear();
parent[i] = -1;
Maxx[0] = Maxy[i] = 0;
cnt[i] = 0;
}
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
u = find(u);
v = find(v);
if (u != v) {
parent[u] = v;
}
}
for (i = 1; i <= n; i++) {
if (parent[i] == -1) {
dfs(i, -1, i);
}
}
for (i = 0; i < q; i++) {
scanf("%d", &type);
if (type == 2) {
scanf("%d%d", &u, &v);
u = find(u);
v = find(v);
if (u != v) {
parent[u] = v;
cnt[v] = max((cnt[v] + 1) / 2 + (cnt[u] + 1) / 2 + 1, cnt[v]);
cnt[v] = max(cnt[u], cnt[v]);
}
} else {
scanf("%d", &u);
u = find(u);
printf("%d\n", cnt[u]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, tata[300000 + 10], rang[300000 + 10], dist[300000 + 10];
bool viz[300000 + 10];
vector<int> nod[300000 + 10], v;
queue<int> Q;
int findDaddy(int x) {
int y = x, r = x;
while (r != tata[r]) r = tata[r];
while (x != tata[x]) {
x = tata[x];
tata[y] = r;
y = x;
}
return r;
}
void unite(int x, int y) { tata[y] = x; }
void calcDiametru(int x) {
viz[x] = 1;
v.clear();
v.push_back(x);
Q.push(x);
dist[x] = 0;
while (!Q.empty()) {
int a = Q.front();
Q.pop();
for (int i = 0; i < nod[a].size(); i++)
if (!viz[nod[a][i]]) {
viz[nod[a][i]] = 1;
dist[nod[a][i]] = dist[a] + 1;
Q.push(nod[a][i]);
v.push_back(nod[a][i]);
}
}
int maxi = 0, p = 0;
for (int i = 0; i < v.size(); i++) {
int x = v[i];
if (dist[x] > maxi) maxi = dist[x], p = x;
dist[x] = viz[x] = 0;
}
viz[p] = 1;
v.clear();
v.push_back(p);
dist[p] = 0;
Q.push(p);
while (!Q.empty()) {
int a = Q.front();
Q.pop();
for (int i = 0; i < nod[a].size(); i++)
if (!viz[nod[a][i]]) {
viz[nod[a][i]] = 1;
dist[nod[a][i]] = dist[a] + 1;
Q.push(nod[a][i]);
v.push_back(nod[a][i]);
}
}
maxi = 0;
for (int i = 0; i < v.size(); i++) {
int a = v[i];
maxi = max(maxi, dist[a]);
if (a != x) unite(x, a);
}
rang[x] = maxi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) tata[i] = i, rang[i] = 0;
for (int i = 1; i <= m; i++) {
int nod1, nod2;
cin >> nod1 >> nod2;
nod[nod1].push_back(nod2);
nod[nod2].push_back(nod1);
}
for (int i = 1; i <= n; i++)
if (!viz[i]) calcDiametru(i);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x, y;
cin >> x;
y = findDaddy(x);
cout << rang[y] << '\n';
} else {
int x, y;
cin >> x >> y;
int a = findDaddy(x), b = findDaddy(y);
if (a == b) continue;
if (rang[a] < rang[b]) swap(a, b);
rang[a] = max(rang[a], (rang[a] + 1) / 2 + (rang[b] + 1) / 2 + 1);
unite(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[300005], d[300005], dist[300005], vis[3][300005], ffff[300005];
int n, m, q, tot;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') {
x = (x << 1) + (x << 3) + c - 48;
c = getchar();
}
return x;
}
int findfa(int x) {
if (fa[x] == x) return x;
return fa[x] = findfa(fa[x]);
}
void merge(int x, int y) {
int fx = findfa(x);
int fy = findfa(y);
if (fx == fy) return;
fa[fx] = fy;
d[fy] = max(d[fx], max(d[fy], ((d[fx] + 1) >> 1) + ((d[fy] + 1) >> 1) + 1));
}
struct tree {
int v;
tree *next;
} * h[300005], pool[600010];
void addedge(int u, int v) {
tot++;
tree *p = &pool[tot];
p->v = v;
p->next = h[u];
h[u] = p;
}
void dfs(int ty, int u, int len) {
if (vis[ty][u]) return;
vis[ty][u] = 1;
int flag = 0;
for (tree *p = h[u]; p; p = p->next) {
if (vis[ty][p->v] == 0) flag = 1;
dfs(ty, p->v, len + 1);
}
if (flag) return;
if (ty == 2 && len > d[findfa(u)])
d[findfa(u)] = len;
else if (ty == 1 && len > d[findfa(u)])
d[findfa(u)] = len, ffff[findfa(u)] = u;
}
void pre() {
for (int i = 1; i <= n; i++) {
dfs(1, i, 0);
dfs(2, ffff[findfa(i)], 0);
}
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1, u, v, fu, fv; i <= m; i++) {
u = read();
v = read();
addedge(u, v);
addedge(v, u);
fu = findfa(u);
fv = findfa(v);
fa[fu] = fv;
}
pre();
for (int i = 1, u, v, w; i <= q; i++) {
u = read();
if (u == 1) {
v = read();
printf("%d\n", d[findfa(v)]);
}
if (u == 2) {
v = read();
w = read();
merge(v, w);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int A[300100];
int e[300100];
int lp[300100];
int dist[300100];
vector<int> G[300100];
vector<int> V;
inline void unionS(int x, int y) { A[y] = x; }
inline int findS(int x) { return (A[x] < 0) ? x : (A[x] = findS(A[x])); }
void elp(int u) {
int init = u;
dist[u] = 0;
V = *new vector<int>();
queue<int> Q;
Q.push(u);
while (Q.size() > 0) {
int x = Q.front();
V.push_back(x);
Q.pop();
for (int i = (0); i < (G[x].size()); i++) {
if (dist[G[x][i]] > dist[x] + 1) {
dist[G[x][i]] = dist[x] + 1;
Q.push(G[x][i]);
}
}
}
for (int i = (0); i < (V.size()); i++) {
if (dist[V[i]] < dist[u]) u = V[i];
dist[V[i]] = 10000000;
}
dist[u] = 0;
Q.push(u);
while (Q.size() > 0) {
int x = Q.front();
Q.pop();
for (int i = (0); i < (G[x].size()); i++) {
if (dist[G[x][i]] > dist[x] + 1) {
dist[G[x][i]] = dist[x] + 1;
Q.push(G[x][i]);
}
}
}
lp[init] = 0;
for (int i = (0); i < (V.size()); i++) {
lp[init] = (((lp[init]) > (dist[V[i]])) ? (lp[init]) : (dist[V[i]]));
}
e[init] = (lp[init] + 1) / 2;
}
int main() {
ios::sync_with_stdio(false);
for (int i = (1); i < (300100); i++) {
A[i] = -1;
dist[i] = 10000000;
}
cin >> n >> m >> q;
int u, v;
for (int i = (1); i <= (m); i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
if (findS(u) != findS(v)) {
unionS(findS(u), findS(v));
}
}
for (int i = (1); i <= (n); i++) {
if (A[i] < 0) {
elp(i);
}
}
int op, x, y;
for (int qq = (1); qq <= (q); qq++) {
cin >> op;
if (op == 1) {
cin >> x;
cout << lp[findS(x)] << endl;
} else {
cin >> x >> y;
if (findS(x) != findS(y)) {
x = findS(x);
y = findS(y);
lp[x] =
(((lp[x]) >
((((lp[y]) > (e[x] + e[y] + 1)) ? (lp[y]) : (e[x] + e[y] + 1))))
? (lp[x])
: ((((lp[y]) > (e[x] + e[y] + 1)) ? (lp[y])
: (e[x] + e[y] + 1))));
e[x] = (lp[x] + 1) / 2;
unionS(x, y);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, fa[300050], len[300050], vis[300050];
vector<int> adj[300050];
pair<int, int> res;
int get(int u) { return u == fa[u] ? u : fa[u] = get(fa[u]); }
void dfs(int u, int fa, int d) {
vis[u] = 1;
res = max(res, make_pair(d, u));
for (auto v : adj[u])
if (v != fa) dfs(v, u, d + 1);
}
int go(int u) {
res = make_pair(0, 0), dfs(u, 0, 0), u = res.second, res = make_pair(0, 0),
dfs(u, 0, 0);
return res.first;
}
int main() {
int opt, u, v;
scanf("%d%d%d", &n, &m, &q);
for (register int i = 1; i <= n; ++i) fa[i] = i;
for (register int i = 1; i <= m; ++i)
scanf("%d%d", &u, &v), fa[get(u)] = get(v), adj[u].push_back(v),
adj[v].push_back(u);
for (register int i = 1; i <= n; ++i)
if (!vis[i]) len[get(i)] = go(i);
while (q--) {
scanf("%d%d", &opt, &u);
if (opt == 1)
printf("%d\n", len[get(u)]);
else {
scanf("%d", &v), u = get(u), v = get(v);
if (u != v) {
fa[u] = v,
len[v] = max(max(len[u], len[v]),
len[u] / 2 + (len[u] & 1) + len[v] / 2 + (len[v] & 1) + 1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[300005];
vector<int> dt(300005, 0), vis(300005, 0), temp_vis(300005, 0);
struct subset {
int parent;
int rank;
};
void dfs(int src, int &far, int count, int &maxcount, int turn) {
if (turn == 0)
vis[src] = 1;
else
temp_vis[src] = 1;
count++;
for (auto it : vec[src]) {
if (turn == 0) {
if (vis[it] == 0) {
if (count >= maxcount) {
maxcount = count;
far = it;
}
dfs(it, far, count, maxcount, turn);
}
} else {
if (temp_vis[it] == 0) {
if (count >= maxcount) {
maxcount = count;
dfs(it, it, count, maxcount, turn);
} else
dfs(it, far, count, maxcount, turn);
}
}
}
}
int find(subset node[], int x) {
if (node[x].parent != x) node[x].parent = find(node, node[x].parent);
return node[x].parent;
}
void Union(int x, int y, subset node[]) {
int xroot = find(node, x);
int yroot = find(node, y);
if (node[xroot].rank < node[yroot].rank)
node[xroot].parent = yroot;
else if (node[xroot].rank > node[yroot].rank)
node[yroot].parent = xroot;
else {
node[yroot].parent = xroot;
node[xroot].rank++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
subset node[n + 1];
for (int i = 1; i <= n; i++) {
node[i].parent = i;
node[i].rank = 0;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
vec[u].push_back(v);
vec[v].push_back(u);
Union(u, v, node);
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
int par = find(node, i);
int far = i;
int maxcount = 0;
dfs(i, far, 0, maxcount, 0);
temp_vis.clear();
maxcount = 0;
dfs(far, far, 0, maxcount, 1);
dt[par] = maxcount;
}
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x;
cin >> x;
int par = find(node, x);
cout << dt[par] << "\n";
} else {
int u, v;
cin >> u >> v;
int xroot = find(node, u);
int yroot = find(node, v);
if (xroot != yroot) {
int val = ((dt[xroot] + 1) / 2 + (dt[yroot] + 1) / 2);
if (node[xroot].rank >= node[yroot].rank) {
dt[xroot] = max(dt[xroot], max(dt[yroot], val + 1));
Union(xroot, yroot, node);
} else {
dt[yroot] = max(dt[xroot], max(dt[yroot], val + 1));
Union(xroot, yroot, node);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int vst[301010], flag, d[301010], root[301010];
int find(int u) {
if (u == root[u]) return u;
return root[u] = find(root[u]);
}
vector<int> adj[301010];
int dfs(int u, int id, int &d) {
vst[u] = flag;
root[u] = id;
int mx[2] = {
0,
};
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (vst[v] == flag) continue;
smax(mx[1], dfs(v, id, d) + 1);
if (mx[1] > mx[0]) swap(mx[0], mx[1]);
}
smax(d, mx[0] + mx[1]);
return mx[0];
}
int main() {
int n, m, q, u, v;
gn(n, m, q);
for (int i = 0; i < m; i++) {
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vst[i]) {
++flag;
dfs(i, i, d[i]);
}
int t;
while (q--) {
gn(t);
if (t == 1) {
gn(u);
println(d[find(u)]);
} else {
gn(u, v);
u = find(u);
v = find(v);
if (u == v) continue;
d[u] = max(max(d[u], d[v]), (d[u] + 1 >> 1) + (d[v] + 1 >> 1) + 1);
root[v] = u;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x);
template <typename T>
void write(T x);
template <typename T>
void writesp(T x);
template <typename T>
void writeln(T x);
const long long N = 3e5 + 5;
long long head[N], to[N << 1], tot, MabLcdG[N << 1];
inline void add(long long x, long long y) {
to[++tot] = y;
MabLcdG[tot] = head[x];
head[x] = tot;
}
inline void Link(long long x, long long y) {
add(x, y);
add(y, x);
}
long long n, m, q;
long long l[N], r[N], d[N], dis[N];
namespace dsu {
long long f[N];
inline void init(long long lim) {
for (long long i = 1; i <= lim; i++) f[i] = i;
}
inline long long getf(long long x) { return f[x] == x ? x : f[x] = getf(f[x]); }
inline void merge(long long x, long long y) { f[getf(x)] = getf(y); }
} // namespace dsu
bool vis[N];
inline void dfs(long long x, long long fa, long long Dis, long long &L) {
vis[x] = true;
dis[x] = Dis;
if (dis[x] > dis[L]) L = x;
for (long long i = head[x], ver; i; i = MabLcdG[i]) {
ver = to[i];
if (ver == fa) continue;
dfs(ver, x, Dis + 1, L);
}
}
int main() {
read(n);
read(m);
read(q);
dsu::init(n);
for (long long i = 1, x, y; i <= m; i++) {
read(x);
read(y);
Link(x, y);
if (x > y) swap(x, y);
dsu::merge(y, x);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 0, 0, l[dsu::getf(i)]);
dfs(l[dsu::getf(i)], 0, 0, r[dsu::getf(i)]);
d[dsu::getf(i)] = dis[r[dsu::getf(i)]];
}
}
long long x, y, op;
while (q--) {
read(op);
if (op == 1) {
read(x);
writeln(d[dsu::getf(x)]);
} else {
read(x);
read(y);
x = dsu::getf(x);
y = dsu::getf(y);
if (x == y) continue;
dsu::f[y] = x;
d[x] = max((d[x] + 1) / 2 + (d[y] + 1) / 2 + 1, max(d[x], d[y]));
}
}
}
template <typename T>
void read(T &x) {
x = 0;
long long t = 1;
char wn = getchar();
while (wn < '0' || wn > '9') {
if (wn == '-') t = -1;
wn = getchar();
}
while (wn >= '0' && wn <= '9') {
x = x * 10 + wn - '0';
wn = getchar();
}
x *= t;
}
template <typename T>
void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x <= 9) {
putchar(x + '0');
return;
}
write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writesp(T x) {
write(x);
putchar(' ');
}
template <typename T>
void writeln(T x) {
write(x);
putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> parent, ranga, diam;
vector<vector<int>> graph;
vector<bool> odw;
int znajdz(int x) {
if (parent[x] == -1) return x;
parent[x] = znajdz(parent[x]);
return parent[x];
}
void join(int a, int b) {
int ap = znajdz(a), bp = znajdz(b);
if (ap == bp) return;
if (ranga[ap] > ranga[bp]) {
diam[ap] = max(max(diam[ap], diam[bp]),
(diam[ap] + 1) / 2 + (diam[bp] + 1) / 2 + 1);
parent[bp] = ap;
} else if (ranga[bp] > ranga[ap]) {
diam[bp] = max(max(diam[ap], diam[bp]),
(diam[ap] + 1) / 2 + (diam[bp] + 1) / 2 + 1);
parent[ap] = bp;
} else {
diam[ap] = max(max(diam[ap], diam[bp]),
(diam[ap] + 1) / 2 + (diam[bp] + 1) / 2 + 1);
parent[bp] = ap;
ranga[ap]++;
}
}
pair<int, int> dfs(int x) {
odw[x] = true;
int out = 0;
int m1 = -1, m2 = -1;
for (auto it : graph[x]) {
if (!odw[it]) {
pair<int, int> tmp = dfs(it);
if (tmp.first > out) out = tmp.first;
if (tmp.second > m2) {
if (tmp.second > m1) {
m2 = m1;
m1 = tmp.second;
} else
m2 = tmp.second;
}
}
}
if (m1 == -1) return make_pair(0, 0);
if (m2 == -1) return make_pair(max(out, m1 + 1), m1 + 1);
return make_pair(max(out, m1 + m2 + 2), m1 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
parent.resize(n + 1, -1);
ranga.resize(n + 1, 0);
diam.resize(n + 1, 0);
graph.resize(n + 1);
odw.resize(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
join(a, b);
}
for (int i = 0; i <= n; i++) {
diam[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (diam[znajdz(i)] == -1) {
diam[znajdz(i)] = dfs(i).first;
}
}
for (int i = 0; i < q; i++) {
int k;
cin >> k;
if (k == 1) {
int a;
cin >> a;
cout << diam[znajdz(a)] << endl;
} else {
int x, y;
cin >> x >> y;
join(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, q, f[N], head[N], cnt, dis[N], vis[N], len[N];
struct Edge {
int v, nx;
} e[N << 2];
vector<int> del;
inline int read() {
int ret = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + (ch ^ 48);
ch = getchar();
}
return ret * ff;
}
void write(int x) {
if (x < 0) {
x = -x, putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
void writeln(int x) { write(x), puts(""); }
void writesp(int x) { write(x), putchar(' '); }
void add(int x, int y) {
e[++cnt].v = y;
e[cnt].nx = head[x];
head[x] = cnt;
}
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int work(int now) {
queue<int> q;
q.push(now);
vis[now] = 1;
del.clear();
del.push_back(now);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = e[i].nx) {
int v = e[i].v;
if (vis[v]) continue;
dis[v] = dis[x] + 1;
vis[v] = 1;
del.push_back(v);
q.push(v);
}
}
int mx = 0;
for (int i = 0; i < del.size(); i++) {
if (dis[del[i]] > dis[mx]) mx = del[i];
vis[del[i]] = 0;
}
q.push(mx);
vis[mx] = 1;
dis[mx] = 0;
int ans = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = e[i].nx) {
int v = e[i].v;
if (vis[v]) continue;
dis[v] = dis[x] + 1;
ans = max(ans, dis[v]);
vis[v] = 1;
q.push(v);
}
}
return ans;
}
signed main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
add(x, y), add(y, x);
int tx = find(x), ty = find(y);
if (tx != ty) f[tx] = ty;
}
for (int i = 1; i <= n; i++)
if (find(i) == i) len[i] = work(i);
while (q--) {
int opt = read();
if (opt == 1) {
int x = read();
writeln(len[find(x)]);
}
if (opt == 2) {
int x = read(), y = read();
int tx = find(x), ty = find(y);
if (tx == ty) continue;
int A = len[tx], B = len[ty];
f[tx] = ty;
len[ty] = max(max(A, B), (A + 1) / 2 + (B + 1) / 2 + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 5;
int n, m, q;
int up[N], path[N], fi[N], se[N];
int fpath[N];
int dsup[N];
int dsu_p(int x) { return x == dsup[x] ? x : dsup[x] = dsu_p(dsup[x]); }
void dsu_union(int x, int y) {
if (dsu_p(x) == dsu_p(y)) return;
dsup[dsu_p(y)] = dsu_p(x);
}
vector<int> G[N];
bool visited[N];
void dfsd(int u, int p) {
visited[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == p) continue;
dsu_union(u, v);
dfsd(v, u);
if (fi[v] + 1 >= fi[u])
se[u] = fi[u], fi[u] = fi[v] + 1;
else if (fi[v] + 1 >= se[u])
se[u] = fi[v] + 1;
}
}
void dfsu(int u, int p) {
path[u] = max(path[u], fi[u] + se[u]);
path[u] = max(path[u], fi[u] + up[u]);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == p) continue;
if (fi[v] + 1 == fi[u])
up[v] = max(up[u], se[u]) + 1;
else
up[v] = max(up[u], fi[u]) + 1;
dfsu(v, u);
}
}
int main() {
for (int i = 0; i < N; i++) dsup[i] = i;
scanf("%d %d %d", &n, &m, &q);
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
dfsd(i, i);
dfsu(i, i);
}
for (int i = 1; i <= n; i++) fpath[dsu_p(i)] = max(fpath[dsu_p(i)], path[i]);
while (q--) {
int type, x, y;
scanf("%d", &type);
if (type == 1) {
scanf("%d", &x);
printf("%d\n", fpath[dsu_p(x)]);
} else {
scanf("%d %d", &x, &y);
x = dsu_p(x);
y = dsu_p(y);
if (x == y) continue;
int newpath = max(fpath[x], fpath[y]);
newpath = max(newpath, (fpath[x] + 1) / 2 + (fpath[y] + 1) / 2 + 1);
dsu_union(x, y);
fpath[dsu_p(x)] = newpath;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
template <typename T>
static T max(T a, T b, T c) {
return max(a, max(b, c));
}
vector<long long int> graph[MAXN];
long long int N, M, Q;
long long int parent[MAXN], visited[MAXN], sz[MAXN], dia[MAXN];
void dfs(long long int u, long long int p, long long int &nn, long long int up,
long long int &lo) {
visited[u] = 1;
if (up > lo) {
lo = up;
nn = u;
}
for (int i = 0; i < graph[u].size(); i++) {
long long int v = graph[u][i];
if (v != p) {
dfs(v, u, nn, up + 1, lo);
}
}
}
void dfs2(long long int u, long long int p, long long int up, long long int &lo,
long long int &nx) {
if (up > lo) {
nx = u;
lo = up;
}
parent[u] = p;
for (int i = 0; i < graph[u].size(); i++) {
long long int v = graph[u][i];
if (v != p) {
dfs2(v, u, up + 1, lo, nx);
}
}
}
void dfs3(long long int u, long long int p) {
parent[u] = p;
for (int i = 0; i < graph[u].size(); i++) {
long long int v = graph[u][i];
if (v != p) dfs3(v, u), sz[u] += sz[v];
}
}
inline long long int find_root(long long int x) {
while (x != parent[x]) {
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
long long int m1, m2, m3, m4;
inline void merge(long long int a, long long int b) {
long long int pa = find_root(a);
long long int push_back = find_root(b);
if (sz[pa] < sz[push_back]) swap(pa, push_back);
if (pa != push_back) {
parent[push_back] = parent[pa];
sz[pa] += sz[push_back];
dia[pa] = max(dia[pa], dia[push_back],
(dia[pa] + 1) / 2 + (dia[push_back] + 1) / 2 + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> Q;
for (int i = 0; i <= N; i++) {
parent[i] = i;
visited[i] = 0;
sz[i] = 1;
dia[i] = 0;
}
long long int x, y;
for (int i = 1; i <= M; i++) {
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
for (int i = 1; i <= N; i++) {
if (visited[i] == 0) {
long long int nn = i, lo = 1, up = 1, nx;
dfs(i, i, nn, up, lo);
up = 1, lo = 1, nx = i;
dfs2(nn, nn, up, lo, nx);
long long int rt = nx;
dia[rt] = lo - 1;
dfs3(rt, rt);
}
}
long long int type;
while (Q--) {
cin >> type;
if (type == 1) {
cin >> x;
long long int root = find_root(x);
cout << dia[root] << "\n";
} else {
cin >> x >> y;
merge(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
vector<int> e[maxn];
int dp[maxn], root[maxn], d[maxn], sz[maxn];
pair<int, int> dfs(int v, int st, int par) {
if (root[v] == -1) sz[st]++;
root[v] = st;
pair<int, int> p = make_pair(0, -1);
for (int i = 0; i < e[v].size(); i++)
if (e[v][i] != par) p = max(p, dfs(e[v][i], st, v));
if (par != -1) p.first++;
if (p.second == -1) p.second = v;
return p;
}
int get_root(int v) { return root[v] == v ? v : root[v] = get_root(root[v]); }
void merge(int v, int u) {
v = get_root(v);
u = get_root(u);
if (sz[v] > sz[u]) swap(v, u);
if (v == u) return;
root[v] = u;
sz[u] += sz[v];
d[u] = max((d[v] + 1) / 2 + (d[u] + 1) / 2 + 1, max(d[v], d[u]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
memset(root, -1, sizeof root);
for (int i = 0; i < m; i++) {
int u, v;
cin >> v >> u;
v--;
u--;
e[v].push_back(u);
e[u].push_back(v);
}
for (int i = 0; i < n; i++)
if (root[i] == -1) d[i] = dfs(dfs(i, i, -1).second, i, -1).first;
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
int x;
cin >> x;
x--;
cout << d[get_root(x)] << '\n';
} else {
int x, y;
cin >> x >> y;
x--;
y--;
merge(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = (int)1e9 + 7;
const int MAXN = (int)2e6 + 7;
int n, m, q;
int dsu[MAXN];
int val[MAXN];
int root;
vector<int> g[MAXN];
pair<int, int> mdist;
void dfs(int v, int parent = 0, int h = 0) {
dsu[v] = root;
mdist = max(mdist, make_pair(h, v));
for (auto to : g[v]) {
if (to != parent) dfs(to, v, h + 1);
}
}
int get(int x) {
if (x == dsu[x]) return x;
return dsu[x] = get(dsu[x]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!dsu[i]) {
root = i;
mdist = make_pair(0, 0);
dfs(i);
int x = mdist.second;
mdist = make_pair(0, 0);
dfs(x);
val[root] = mdist.first;
}
}
while (q--) {
int type, x, y;
scanf("%d%d", &type, &x);
if (type == 1) {
printf("%d\n", val[get(x)]);
} else {
scanf("%d", &y);
x = get(x);
y = get(y);
if (x == y) continue;
dsu[x] = y;
val[y] =
max(max(val[x], val[y]), (val[x] + 1) / 2 + (val[y] + 1) / 2 + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5, MAXM = MAXN << 1;
int head[MAXM], nxt[MAXM], v[MAXM], cnt;
int dp[MAXN], len[MAXN], f[MAXN];
bool tag[MAXN];
int n, m, q;
inline int Find(int x) { return f[x] == x ? x : f[x] = Find(f[x]); }
inline void Addline(int x, int y) {
v[cnt] = y, nxt[cnt] = head[x], head[x] = cnt++;
}
inline void DP(int x, int from) {
for (int i = head[x]; ~i; i = nxt[i])
if (v[i] != from) {
DP(v[i], x);
dp[x] = max(dp[x], len[x] + len[v[i]] + 1);
dp[x] = max(dp[x], dp[v[i]]);
len[x] = max(len[x], len[v[i]] + 1);
}
return;
}
signed main(void) {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) f[i] = i;
memset(head, -1, sizeof head);
for (int i = 1, x, y; i <= m; i++) {
scanf("%d %d", &x, &y);
Addline(x, y), Addline(y, x);
f[Find(x)] = Find(y);
}
for (int i = 1; i <= n; i++)
if (!tag[Find(i)]) DP(Find(i), 0), tag[Find(i)] = true;
for (int i = 1, opt, x, y; i <= q; i++) {
scanf("%d", &opt);
if (opt == 1) scanf("%d", &x), printf("%d\n", dp[Find(x)]);
if (opt == 2) {
scanf("%d %d", &x, &y);
x = Find(x), y = Find(y);
if (x != y) {
dp[x] = max(max(dp[x], dp[y]), (dp[x] + 1) / 2 + (dp[y] + 1) / 2 + 1);
f[y] = x;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[300005 * 2], Next[300005 * 2], head[300005], tot;
int fa[300005], dis[300005], n, m, q, size[300005], depth[300005], tmp,
vis[300005];
inline void read(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return;
}
inline void addedge(int x, int y) {
v[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
return;
}
inline int get(int x) {
if (fa[x] == x)
return x;
else
return fa[x] = get(fa[x]);
}
inline void merge(int x, int y) {
if (x == y) return;
int a = dis[x] / 2, b = dis[y] / 2;
if (dis[x] % 2) a++;
if (dis[y] % 2) b++;
if (size[x] < size[y]) swap(x, y);
dis[x] = max(a + b + 1, max(dis[x], dis[y]));
size[x] += size[y];
fa[y] = x;
return;
}
inline void dfs(int x, int dad) {
for (int i = head[x]; i; i = Next[i]) {
if (v[i] == dad) continue;
depth[v[i]] = depth[x] + 1;
dfs(v[i], x);
}
if (depth[x] > depth[tmp]) tmp = x;
return;
}
inline void init() {
int x, y;
read(n);
read(m);
read(q);
for (int i = 1; i <= n; i++) fa[i] = i, size[i] = 1;
for (int i = 1; i <= m; i++) {
read(x);
read(y);
addedge(x, y);
addedge(y, x);
x = get(x);
y = get(y);
if (x != y) merge(x, y);
}
for (int i = 1; i <= n; i++) {
x = get(i);
if (vis[x]) continue;
vis[x] = 1;
tmp = 0;
dfs(x, 0);
depth[tmp] = 0;
dfs(tmp, 0);
dis[x] = depth[tmp];
}
return;
}
inline void work() {
int opt, x, y;
while (q--) {
read(opt);
if (opt == 1) {
read(x);
cout << dis[get(x)] << endl;
}
if (opt == 2) {
read(x);
read(y);
x = get(x);
y = get(y);
merge(x, y);
}
}
return;
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[300001], r[300001];
int length[300001];
vector<vector<int> > adj(300001);
bool visited[300001];
int depth[300001];
int parent(int a) {
if (p[a] == a) return a;
return p[a] = parent(p[a]);
}
void mergeSet(int a, int b) {
a = parent(a), b = parent(b);
if (r[a] > r[b])
p[b] = a;
else
p[a] = b;
if (r[a] == r[b]) r[b]++;
}
void dfs(int node, int p, vector<int> &v) {
if (visited[node]) return;
v.push_back(node);
visited[node] = true;
depth[node] = depth[p] + 1;
for (int i = 0; i < adj[node].size(); i++) dfs(adj[node][i], node, v);
}
int findFurthestNode(vector<int> &v, bool flag) {
int temp = 0, node = 0;
for (int i = 0; i < v.size(); i++) {
if (!flag) visited[v[i]] = false;
if (depth[v[i]] >= temp) temp = depth[v[i]], node = v[i];
}
return node;
}
void createRegion(int node) {
if (visited[node]) return;
int t = node;
vector<int> v;
dfs(node, 0, v);
node = findFurthestNode(v, false);
v.clear();
dfs(node, 0, v);
node = findFurthestNode(v, true);
t = parent(t);
length[t] = depth[node] - 1;
}
void mergeRegion(int a, int b) {
a = parent(a), b = parent(b);
if (a == b) return;
mergeSet(a, b);
int l1 = length[a], l2 = length[b];
a = parent(a);
int l = max(l1 / 2, l1 - l1 / 2) + max(l2 / 2, l2 - l2 / 2) + 1;
length[a] = max(max(l1, l2), l);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i < 300001; i++) p[i] = i;
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
mergeSet(a, b);
}
for (int i = 1; i <= n; i++) createRegion(i);
for (int i = 0; i < q; i++) {
int t, a, b;
cin >> t;
if (t == 1) {
cin >> a;
cout << length[parent(a)] << "\n";
} else {
cin >> a >> b;
mergeRegion(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int size[300010], par[300010], mx[300010], vis[300010], vb1[300010],
vb2[300010], dis1[300010], dis2[300010];
int find(int x) {
if (par[x] != x) par[x] = find(par[x]);
return par[x];
}
void merge(int x, int y) {
int r = find(x), s = find(y);
if (size[r] < size[s]) {
par[r] = s;
size[s] += size[r];
} else {
par[s] = r;
size[r] += size[s];
}
}
int main() {
int n, m, q, t, a, x, y;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < 300010; i++) par[i] = i, size[i] = 1, mx[i] = 0;
vector<int> vec[300010];
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
x--, y--;
merge(x, y);
vec[x].push_back(y);
vec[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (!vb1[i]) {
list<int> queue;
queue.push_back(i);
dis1[i] = 0;
vb1[i] = 1;
int mxx = 0, y;
while (!queue.empty()) {
int s = queue.front();
queue.pop_front();
for (int j = 0; j < vec[s].size(); j++) {
int x = vec[s][j];
if (vb1[x]) continue;
dis1[x] = dis1[s] + 1;
if (dis1[x] > mxx) {
y = x;
mxx = dis1[x];
}
vb1[x] = 1;
queue.push_back(x);
}
}
dis2[y] = 0;
vb2[y] = 1;
queue.clear();
queue.push_back(y);
while (!queue.empty()) {
int s = queue.front();
queue.pop_front();
for (int j = 0; j < vec[s].size(); j++) {
int x = vec[s][j];
if (vb2[x]) continue;
dis2[x] = dis2[s] + 1;
if (dis2[x] > mxx) {
mxx = dis2[x];
}
vb2[x] = 1;
queue.push_back(x);
}
}
mx[find(i)] = mxx;
}
}
for (int i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &a);
a--;
printf("%d\n", mx[find(a)]);
} else {
scanf("%d %d", &x, &y);
x--, y--;
int fx = find(x), fy = find(y);
if (fx == fy) continue;
int l = mx[fx], r = mx[fy];
merge(fx, fy);
mx[find(x)] = max(l, max((l + 1) / 2 + (r + 1) / 2 + 1, r));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int read() {
int x = 0, f = 1;
char ch;
while (!isdigit(ch = getchar())) (ch == '-') && (f = -f);
for (x = ch ^ 48; isdigit(ch = getchar());
x = (x << 3) + (x << 1) + (ch ^ 48))
;
return x * f;
}
template <class T>
T Max(T a, T b) {
return a > b ? a : b;
}
template <class T>
T Min(T a, T b) {
return a < b ? a : b;
}
struct Edge {
int to;
Edge *nxt;
Edge(int to, Edge *nxt) : to(to), nxt(nxt) {}
} * head[N];
void add(int x, int y) { head[x] = new Edge(y, head[x]); }
int n, m, q, len, vis[N], fa[N], c[N], g[N], d[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void dfs(int x, int f) {
int m1 = 0, m2 = 0;
for (Edge *i = head[x]; i; i = i->nxt) {
if (i->to == f) continue;
dfs(i->to, x);
int tmp = d[i->to] + 1;
d[x] = max(d[x], tmp);
if (tmp > m1)
m2 = m1, m1 = tmp;
else if (tmp > m2)
m2 = tmp;
}
g[x] = max(0, m1 + m2);
len = max(len, g[x]);
}
void calc(int x) {
len = 0;
dfs(x, 0);
c[x] = len;
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1, x, y; i <= m; ++i)
x = read(), y = read(), add(x, y), add(y, x), fa[find(x)] = find(y);
for (int i = 1; i <= n; ++i)
if (fa[i] == i && !vis[i]) calc(i), vis[i] = 1;
for (int i = 1, opt, x, y; i <= q; ++i) {
opt = read();
x = read();
if (opt == 1) {
printf("%d\n", c[find(x)]);
continue;
}
y = read();
x = find(x);
y = find(y);
if (x == y) continue;
int tmp = max((c[x] + 1) / 2 + (c[y] + 1) / 2 + 1, max(c[x], c[y]));
fa[find(x)] = find(y);
c[find(x)] = tmp;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
int p[MAXN];
int r[MAXN];
int len[MAXN];
vector<int> g[MAXN];
int d[MAXN];
bool used[MAXN];
int comp[MAXN], comp_mx[MAXN];
int comp2[MAXN];
int c[MAXN], id[MAXN];
int find_set(int a) {
if (a == p[a])
return a;
else
return p[a] = find_set(p[a]);
}
void dfs(int v, int cm) {
c[v] = cm;
used[v] = 1;
int sz, to;
sz = g[v].size();
for (int i = 0; i < sz; i++) {
to = g[v][i];
if (used[to]) continue;
d[to] = d[v] + 1;
dfs(to, cm);
}
}
void dfs2(int v) {
used[v] = 1;
int sz, to;
sz = g[v].size();
for (int i = 0; i < sz; i++) {
to = g[v][i];
if (used[to]) continue;
d[to] = d[v] + 1;
dfs2(to);
}
}
void join_sets(int a, int b, int t = 0) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
int len1 = len[a], len2 = len[b];
if (r[a] < r[b]) swap(a, b);
r[a] += r[b];
p[b] = a;
if (t) return;
len1 = ceil(0.5 * len1);
len2 = ceil(0.5 * len2);
len[a] = max(len[a], len[b]);
len[a] = max(len[a], len1 + len2 + 1);
}
void solve() {
int m, n, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
len[i] = 0;
r[i] = 1;
p[i] = i;
}
int v, to;
for (int i = 0; i < m; i++) {
scanf("%d%d", &v, &to);
g[v].push_back(to);
g[to].push_back(v);
}
int cnt = 1;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i, cnt);
cnt++;
}
}
for (int i = 1; i < cnt; i++) {
comp_mx[i] = -1;
}
for (int i = 1; i <= n; i++) {
int cc = c[i];
if (comp_mx[cc] < d[i]) {
comp_mx[cc] = d[i];
comp[cc] = i;
}
d[i] = 0;
used[i] = 0;
}
for (int i = 1; i < cnt; i++) {
dfs2(comp[i]);
}
for (int i = 1; i < cnt; i++) {
comp_mx[i] = -1;
}
for (int i = 1; i <= n; i++) {
int cc = c[i];
if (comp_mx[cc] < d[i]) {
comp_mx[cc] = d[i];
comp2[cc] = i;
}
}
for (int i = 1; i < cnt; i++) {
v = comp2[i];
len[v] = d[v];
}
for (int i = 1; i <= n; i++) {
int cc = c[i];
v = comp2[cc];
join_sets(v, i, 1);
}
int t;
for (int i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &v);
v = find_set(v);
printf("%d\n", len[v]);
} else {
scanf("%d%d", &v, &to);
join_sets(v, to);
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, tip, x, y, a, b;
int t[300010], lp[300010], f[300010], c[300010], lpc[300010], d[300010];
vector<int> v[300010];
int tata(int nod) {
if (t[nod] == nod) return nod;
int aux = tata(t[nod]);
t[nod] = aux;
return aux;
}
void df(int nod, int rad) {
if (f[nod]) return;
t[nod] = rad;
f[nod] = 1;
int fiu;
for (int i = 0; i < v[nod].size(); ++i) {
fiu = v[nod][i];
if (f[fiu]) continue;
df(fiu, rad);
d[nod] = max(d[nod], d[fiu] + 1);
}
}
void df2(int nod, int rad, int up) {
if (f[nod] == 2) return;
f[nod] = 2;
int fiu, f1 = 0, f2 = 0;
for (int i = 0; i < v[nod].size(); ++i) {
fiu = v[nod][i];
if (f[fiu] == 2) continue;
if (d[fiu] > d[f1]) {
f2 = f1;
f1 = fiu;
} else if (d[fiu] > d[f2]) {
f2 = fiu;
}
}
lp[rad] = max(lp[rad], d[f1] + d[f2] + 2);
if (up < lpc[rad] && d[nod] < lpc[rad]) {
lpc[rad] = max(up, d[nod]);
c[rad] = nod;
}
for (int i = 0; i < v[nod].size(); ++i) {
fiu = v[nod][i];
if (f[fiu] == 2) continue;
if (fiu == f1)
df2(fiu, rad, max(up, d[f2] + 1) + 1);
else
df2(fiu, rad, max(up, d[f1] + 1) + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
d[0] = -1;
for (int i = 1; i <= n; ++i) {
if (f[i] == 0) {
df(i, i);
c[i] = i;
lpc[i] = d[i];
df2(i, i, 0);
}
}
while (q--) {
scanf("%d", &tip);
if (tip == 1) {
scanf("%d", &x);
printf("%d\n", lp[tata(x)]);
} else {
scanf("%d%d", &x, &y);
x = tata(x);
y = tata(y);
if (x == y) continue;
if (lpc[x] < lpc[y]) swap(x, y);
t[y] = x;
if (lp[y] > lp[x]) lp[x] = lp[y];
if (lpc[y] + 1 + lpc[x] > lp[x]) lp[x] = lpc[y] + 1 + lpc[x];
if (lpc[x] == lpc[y]) ++lpc[x];
}
}
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline void in(T &x) {
x = 0;
register char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + c - 48, c = getchar();
}
int dot, line, q, cnt, root, pos;
int head[300050], dia[300050], bel[300050], dep[300050];
bool vis[300050];
struct Edge {
int to, nex;
} edge[300050 << 1];
inline void addedge(const int &from, const int &to) {
edge[++cnt] = {to, head[from]}, head[from] = cnt;
}
namespace DSU {
int find(const int &now) {
return bel[now] == now ? now : bel[now] = find(bel[now]);
}
inline void combine(register int x, register int y) { bel[x] = find(y); }
} // namespace DSU
void DFS(const int &now, const int &fa) {
vis[now] = true;
if (dep[now] > dep[pos]) pos = now;
for (register int i = head[now]; i; i = edge[i].nex) {
if (edge[i].to == fa) continue;
dep[edge[i].to] = dep[now] + 1;
DFS(edge[i].to, now);
}
}
void merge(const int &now, const int &tar, const int &fa) {
bel[now] = tar;
for (register int i = head[now]; i; i = edge[i].nex) {
if (edge[i].to == fa) continue;
merge(edge[i].to, tar, now);
}
}
void prework(const int &now) {
pos = now;
DFS(now, 0);
root = pos;
dep[root] = 0;
DFS(root, 0);
dia[root] = dep[pos];
merge(root, root, 0);
}
int main(void) {
int a, b, typ;
in(dot), in(line), in(q);
for (register int i = 1; i <= line; ++i)
in(a), in(b), addedge(a, b), addedge(b, a);
for (register int i = 1; i <= dot; ++i)
if (!vis[i]) prework(i);
while (q--) {
in(typ);
if (typ & 1)
in(a), printf("%d\n", dia[DSU::find(a)]);
else {
in(a), in(b);
register int x = DSU::find(a), y = DSU::find(b);
if (x == y) continue;
dia[y] = std::max(std::max(dia[y], dia[x]),
(dia[y] + 1) / 2 + (dia[x] + 1) / 2 + 1);
DSU::combine(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long tests;
int parent[1000005], siz[1000005], ans[1000005], d[1000005];
vector<long long> g[1000005];
void dfs(int v, int printf = 0) {
if (printf) parent[v] = printf;
siz[v] = 1;
int mx = 0, mx2 = 0;
for (auto u : g[v])
if (!parent[u]) {
dfs(u, v);
siz[v] += siz[u];
d[v] = max(d[v], d[u] + 1);
if (d[u] + 1 > mx) {
mx2 = mx;
mx = d[u] + 1;
} else if (d[u] + 1 > mx2)
mx2 = d[u] + 1;
ans[v] = max(mx + mx2, max(ans[v], ans[u]));
}
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
if (siz[a] < siz[b]) swap(a, b);
siz[a] += siz[b];
parent[b] = a;
ans[a] = max(ans[a], max(ans[b], ((ans[a] + 1) / 2 + (ans[b] + 1) / 2 + 1)));
}
long long n, m, q, x, y, cnt;
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &q);
while (m--) {
scanf("%I64d%I64d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!parent[i]) {
parent[i] = i;
dfs(i);
}
while (q--) {
scanf("%I64d", &tests);
if (tests == 1) {
scanf("%I64d", &x);
x = find_set(x);
printf("%d\n", ans[x]);
} else {
scanf("%I64d%I64d", &x, &y);
union_sets(x, y);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long n, m, q;
vector<long long> adj[300005], are[300005];
long long depth[300005], dim[300005];
long long reg[300005], used[300005];
void dfs(long long at, long long fr, long long prt) {
used[at] = 1;
reg[at] = prt;
are[prt].push_back(at);
depth[at] = depth[fr] + 1;
for (long long to : adj[at]) {
if (used[to]) continue;
dfs(to, at, prt);
}
}
long long parent[300005], siz[300005];
void make(long long v) {
parent[v] = v;
siz[v] = 1;
}
long long head(long long v) {
if (v == parent[v]) return v;
return parent[v] = head(parent[v]);
}
void combine(long long a, long long b) {
a = head(a), b = head(b);
if (a != b) {
if (siz[b] < siz[a]) swap(a, b);
parent[b] = a;
siz[a] += siz[b];
}
}
void solve() {
cin >> n >> m >> q;
for (long long i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
long long prt = 0;
for (long long i = 0; i < n; i++) {
if (used[i]) continue;
dfs(i, i, prt);
prt++;
}
long long root[prt];
for (long long i = 0; i < prt; i++) {
long long amx = 0, tmp = -1;
for (long long j : are[i]) {
if (depth[j] > amx) {
amx = depth[j];
tmp = j;
}
}
root[i] = tmp;
}
for (long long i = 0; i < 300005; i++) {
are[i].clear();
depth[i] = used[i] = 0;
}
for (long long i = 0; i < prt; i++) {
make(i);
dfs(root[i], root[i], i);
}
for (long long i = 0; i < prt; i++) {
for (long long j : are[i]) {
dim[head(i)] = max(dim[head(i)], depth[j] - 1);
}
}
long long h, x, y;
while (q--) {
cin >> h;
if (h == 1) {
cin >> x;
x--;
cout << dim[head(reg[x])] << '\n';
} else {
cin >> x >> y;
x--, y--;
long long hx = head(reg[x]), hy = head(reg[y]);
if (hx != hy) {
long long da = dim[hx], db = dim[hy];
long long pa[2] = {da / 2, (da + 1) / 2};
long long push_back[2] = {db / 2, (db + 1) / 2};
long long fdim = max(pa[0] + pa[1], push_back[0] + push_back[1]);
for (long long i = 0; i < 2; i++)
for (long long j = 0; j < 2; j++) {
fdim = max(fdim, pa[i] + push_back[j] + 1);
}
combine(hx, hy);
long long fck = head(reg[x]);
dim[fck] = fdim;
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt = 1;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300050;
vector<int> Tree[N];
int parent[N], ranks[N];
int Find(int u) {
if (parent[u] != u) parent[u] = Find(parent[u]);
return parent[u];
}
void Union(int u, int v) {
int x = Find(u);
int y = Find(v);
if (ranks[x] > ranks[y])
parent[y] = x;
else if (ranks[x] < ranks[y])
parent[x] = y;
else
ranks[x]++, parent[y] = x;
}
int max(int a, int b) { return a > b ? a : b; }
int max(int a, int b, int c) { return max(a, max(b, c)); }
int ans;
bool visited[N];
int val[N];
int DFS(int cur, int prev, int depth) {
int tmp = depth;
ans = max(ans, tmp);
int i;
for (i = 0; i < Tree[cur].size(); i++) {
int v = Tree[cur][i];
if (v != prev) {
int t = DFS(v, cur, depth + 1);
ans = max(ans, t + tmp - 2 * depth);
tmp = max(tmp, t);
}
}
return tmp;
}
int main() {
int n, m, q, i, u, v, t;
scanf("%i %i %i", &n, &m, &q);
for (i = 1; i <= n; i++) parent[i] = i;
for (i = 0; i < m; i++) {
scanf("%i %i", &u, &v);
Union(u, v);
Tree[u].push_back(v);
Tree[v].push_back(u);
}
for (i = 1; i <= n; i++) {
u = Find(i);
if (!visited[u]) {
ans = 0;
DFS(u, 0, 0);
val[u] = ans;
visited[u] = true;
}
}
while (q--) {
scanf("%i", &t);
if (t == 1) {
scanf("%i", &u);
printf("%i\n", val[Find(u)]);
}
if (t == 2) {
scanf("%i %i", &u, &v);
u = Find(u);
v = Find(v);
if (u != v) {
val[u] = val[v] =
max(val[u], val[v], (val[u] + 1) / 2 + (val[v] + 1) / 2 + 1);
Union(u, v);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int S, R, maxi;
vector<int> adj[N];
int par[N], d[N];
void dfs(int ind, int p, int anc) {
int i, u;
d[ind] = d[p] + 1;
if (d[ind] > maxi) R = ind, maxi = d[ind];
par[ind] = anc;
for (i = 0; i < adj[ind].size(); ++i) {
u = adj[ind][i];
if (u != p) {
dfs(u, ind, anc);
}
}
}
int get(int u) {
if (u == par[u]) return u;
return par[u] = get(par[u]);
}
void merge(int u, int v) {
u = get(u), v = get(v);
if (u == v) return;
if (d[u] < d[v]) swap(u, v);
par[v] = u;
d[u] = max(d[u], (d[v] - d[v] / 2) + (d[u] - d[u] / 2) + 1);
}
int main() {
int type, x, y, n, m, q, i, j, a, b;
cin >> n >> m >> q;
for (i = 1; i <= n; ++i) par[i] = i;
d[0] = -1;
for (i = 0; i < m; ++i)
scanf("%d%d", &a, &b), adj[a].push_back(b), adj[b].push_back(a);
for (i = 1; i <= n; ++i) {
if (par[i] == i) {
S = i;
R = i;
maxi = 0;
dfs(S, 0, i);
maxi = 0;
S = R;
dfs(S, 0, i);
d[i] = maxi;
}
}
while (q--) {
scanf("%d%d", &type, &x);
if (type == 1) {
printf("%d\n", d[get(x)]);
} else {
scanf("%d", &y);
merge(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10, M = 3e5 + 10;
struct Edge {
int to, next;
} edge[M << 1];
int idx;
int h[N];
void add_edge(int u, int v) {
edge[++idx] = {v, h[u]};
h[u] = idx;
}
int len[N], vis[N];
int d[N], f[N];
int fa[N];
int n, m, q;
void init() {
memset(h, -1, sizeof h);
for (int i = 1; i <= n; i++) fa[i] = i;
}
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
void dp(int p) {
vis[p] = 1;
for (int i = h[p]; ~i; i = edge[i].next) {
int to = edge[i].to;
if (vis[to]) continue;
dp(to);
f[p] = max(f[p], d[p] + d[to] + 1);
d[p] = max(d[p], d[to] + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
init();
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
x = get(x), y = get(y);
fa[x] = y;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dp(get(i));
int u = get(i);
len[u] = max(len[u], f[i]);
}
while (q--) {
int tp, x, y;
scanf("%d%d", &tp, &x);
if (tp == 1) {
x = get(x);
printf("%d\n", len[x]);
continue;
}
scanf("%d", &y);
x = get(x), y = get(y);
if (x == y) continue;
int d1 = len[x], d2 = len[y];
len[y] = max(d1, d2);
len[y] = max(len[y], ((d1 + 1) >> 1) + ((d2 + 1) >> 1) + 1);
fa[x] = y;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const long long int MAXN = 3e5 + 2;
long long int n, m, q;
vector<long long int> graph[MAXN];
bool visit[MAXN];
long long int parent[MAXN], rankk[MAXN], diameter[MAXN];
long long int maxx, maxv;
void dfs(long long int u, long long int depth, long long int p) {
if (depth > maxx) maxx = depth, maxv = u;
for (long long int v : graph[u]) {
if (v == p) continue;
dfs(v, depth + 1, u);
}
}
long long int find_diameter(long long int u) {
maxx = -1;
dfs(u, 0, -1);
maxx = -1;
dfs(maxv, 0, -1);
return maxx;
}
void init() {
for (int i = (1); i <= (n); ++i) parent[i] = i, rankk[i] = 1, diameter[i] = 0;
}
long long int getSet(long long int v) {
if (parent[v] == v) return v;
return parent[v] = getSet(parent[v]);
}
long long int radius(long long int x) { return (diameter[x] + 1) / 2; }
void unionSets(long long int x, long long int y) {
x = getSet(x), y = getSet(y);
if (x == y) return;
if (rankk[x] > rankk[y]) swap(x, y);
rankk[y] += rankk[x];
parent[x] = y;
diameter[y] = max({radius(x) + radius(y) + 1, diameter[x], diameter[y]});
}
long long int query(long long int x) { return diameter[getSet(x)]; }
void solve() {
cin >> n >> m >> q;
init();
for (int i = (1); i <= (m); ++i) {
long long int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
unionSets(u, v);
}
for (int i = (1); i <= (n); ++i) {
long long int pa = getSet(i);
if (!visit[pa]) {
visit[pa] = true;
diameter[pa] = find_diameter(i);
}
}
while (q--) {
long long int t, x, y;
cin >> t;
if (t == 2) {
cin >> x >> y;
unionSets(x, y);
} else {
cin >> x;
cout << query(x) << endl;
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n, m, q, u, v, op;
int cnt, len, t;
int head[N], fa[N], dis[N], clr[N];
struct edge {
int nxt, to;
} e[N << 1];
inline void add(int u, int v) {
e[++cnt] = edge{head[u], v};
head[u] = cnt;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void merge(int x, int y) {
if (find(x) == find(y)) return;
fa[fa[x]] = fa[y];
}
void dfs(int u, int c, int l) {
if (clr[u] == c) return;
if (len < l) {
len = l;
t = u;
}
clr[u] = c;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
merge(u, v);
dfs(v, c, l + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++)
if (!clr[i]) {
len = 0, t = i;
dfs(i, i, 0);
len = 0;
dfs(t, t, 0);
dis[find(i)] = len;
}
for (; q--;) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &u);
printf("%d\n", dis[find(u)]);
} else {
scanf("%d%d", &u, &v);
u = find(u), v = find(v);
if (u == v) continue;
fa[u] = v;
dis[v] =
max((dis[u] + 1 >> 1) + (dis[v] + 1 >> 1) + 1, max(dis[u], dis[v]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long INF64 = 1e18;
const long double EPS = 1e-7;
mt19937 myrand(time(NULL));
const int N = 300 * 1000 + 13;
int n, m, q;
vector<int> g[N];
int p[N], d[N];
int rk[N];
bool read() {
if (scanf("%d%d%d", &n, &m, &q) != 3) return 0;
for (int i = 0; i < (n); i++) g[i].clear();
for (int i = 0; i < (n); i++) {
p[i] = i;
rk[i] = 1;
}
return 1;
}
int getP(int a) { return (a == p[a] ? a : p[a] = getP(p[a])); }
void unite(int a, int b) {
a = getP(a);
b = getP(b);
if (a == b) return;
if (rk[b] > rk[a]) swap(a, b);
p[b] = a;
rk[a] += rk[b];
d[a] = max(max(d[b], d[a]), (d[b] + 1) / 2 + (d[a] + 1) / 2 + 1);
}
int used[N];
int cc;
char usedgl[N];
int dist[N];
int bfs(int s) {
queue<int> q;
q.push(s);
++cc;
used[s] = cc;
dist[s] = 0;
int lst = -1;
while (!q.empty()) {
int v = q.front();
q.pop();
usedgl[v] = true;
lst = v;
for (auto u : g[v])
if (used[u] != cc) {
used[u] = cc;
dist[u] = dist[v] + 1;
q.push(u);
}
}
return lst;
}
void solve() {
for (int i = 0; i < (m); i++) {
int f, t;
scanf("%d%d", &f, &t);
--f, --t;
g[f].push_back(t);
g[t].push_back(f);
unite(f, t);
}
memset(d, 0, sizeof(d));
memset(usedgl, false, sizeof(usedgl));
cc = 0;
for (int i = 0; i < (n); i++) {
if (usedgl[i]) continue;
int t = bfs(bfs(i));
d[getP(i)] = dist[t];
}
for (int _ = 0; _ < (q); _++) {
int t;
scanf("%d", &t);
if (t == 1) {
int first;
scanf("%d", &first);
--first;
printf("%d\n", d[getP(first)]);
} else {
int first, second;
scanf("%d%d", &first, &second);
--first, --second;
unite(first, second);
}
}
}
int main() {
while (read()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[300005], far, dist;
pair<int, int> d[300005];
vector<int> G[300005];
void dfs(int v, int fat, int c, int distance = 0) {
p[v] = c;
if (distance > dist) dist = distance, far = v;
for (int x : G[v])
if (x != fat) dfs(x, v, c, distance + 1);
}
int findp(int a) {
if (p[a] == a) return a;
return p[a] = findp(p[a]);
}
void mergep(int a, int b) {
int x = findp(a), y = findp(b);
p[x] = y;
if (d[y].first + d[y].second == d[x].first + d[x].second)
d[y] = {d[x].second + 1, d[y].second};
else if (d[y].first + d[y].second > d[x].first + d[x].second) {
if (d[x].second + 1 >= d[y].first) d[y] = {d[x].second + 1, d[y].second};
} else {
if (d[y].second + 1 >= d[x].first)
d[y] = {d[y].second + 1, d[x].second};
else
d[y] = d[x];
}
if (d[y].first > d[y].second) swap(d[y].first, d[y].second);
}
int main() {
int n, m, q, a, b, op;
scanf("%d%d%d", &n, &m, &q);
while (m--) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!p[i]) {
dist = -1;
dfs(i, i, i);
dist = -1;
dfs(far, far, i);
d[i] = {dist / 2, (dist + 1) / 2};
}
}
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &a);
auto leaves = d[findp(a)];
printf("%d\n", leaves.first + leaves.second);
} else {
scanf("%d%d", &a, &b);
if (findp(a) != findp(b)) mergep(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, m, q;
vector<int> adj[300001];
int p[300001];
int rank2[300001];
int radio[300001], diametro[300001];
short int visited[300001];
int dis[300001];
int get_diametro(int v) {
visited[v] = 1;
queue<int> q;
q.push(v);
int last = v;
while (!q.empty()) {
int cur = q.front();
q.pop();
last = cur;
for (int i = 0; i < adj[cur].size(); i++) {
int w = adj[cur][i];
if (visited[w] == 0) {
visited[w] = 1;
q.push(w);
}
}
}
queue<int> q1, q2;
q1.push(last);
q2.push(0);
visited[last] = 2;
int res = 0;
while (!q1.empty()) {
int cur = q1.front();
int d1 = q2.front();
q1.pop(), q2.pop();
res = max(res, d1);
for (int i = 0; i < adj[cur].size(); i++) {
int w = adj[cur][i];
if (visited[w] == 1) {
visited[w] = 2;
q1.push(w);
q2.push(d1 + 1);
}
}
}
return res;
}
int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
void link(int x, int y) {
int a = find(x), b = find(y);
if (a == b) return;
if (rank2[a] < rank2[b]) swap(a, b);
rank2[a] += rank2[b];
p[b] = a;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
int a, b, x, y;
for (int i = 0; i < n; i++) p[i] = i, rank2[i] = 1;
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
link(a, b);
}
for (int i = 0; i < n; i++)
if (visited[i] == 0) {
x = find(i);
diametro[x] = get_diametro(i);
radio[x] = diametro[x] / 2;
if (diametro[x] % 2) radio[x]++;
}
int r1, r2, dia, val, dx, dy;
for (int qq = 0; qq < q; qq++) {
scanf("%d %d", &val, &x);
x--;
if (val == 1) {
x = find(x);
cout << diametro[x] << endl;
;
} else {
scanf("%d", &y);
y--;
x = find(x);
y = find(y);
if (x == y) continue;
r1 = radio[x];
r2 = radio[y];
dx = diametro[x];
dy = diametro[y];
dia = r1 + r2 + 1;
link(x, y);
x = find(x);
diametro[x] = max(dx, max(dy, dia));
radio[x] = diametro[x] / 2;
if (diametro[x] % 2) radio[x]++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-' && c != -1)
;
if (c == -1) return;
if (c == '-') sg = 1, c = getchar();
for (x = 0; c >= '0' && c <= '9';
x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
if (sg) x = -x;
}
template <class T>
void print(T x) {
if (x < 0) return putchar('-'), print(-x);
if (x < 10) {
putchar(x + '0');
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
template <class U, class V>
inline void gn(U &u, V &v) {
gn(u);
gn(v);
}
template <class U, class V, class W>
inline void gn(U &u, V &v, W &w) {
gn(u);
gn(v, w);
}
template <class T>
void println(T x) {
print(x);
putchar('\n');
}
template <class T>
void printsp(T x) {
print(x);
putchar(' ');
}
template <class U, class V>
inline void print(U u, V v) {
printsp(u);
println(v);
}
template <class U, class V, class W>
inline void print(U u, V v, W w) {
printsp(u);
print(v, w);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; a = (long long)a * a % m, b >>= 1)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
vector<int> adj[330303];
int root[330303], sz[330303], D[330303], vst[330303];
int tmp;
int find(int first) {
while (first != root[first]) first = root[first];
return first;
}
bool same(int a, int b) { return find(a) == find(b); }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
root[b] = a;
D[a] = max(D[a], max(D[b], (D[a] + 1) / 2 + (D[b] + 1) / 2 + 1));
}
int dfs(int u) {
vst[u] = 1;
int mx[2] = {
0,
};
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
if (vst[v]) continue;
smax(mx[1], dfs(v) + 1);
if (mx[0] < mx[1]) swap(mx[0], mx[1]);
}
smax(tmp, mx[0] + mx[1]);
return mx[0];
}
int main() {
int n, m, q;
gn(n, m, q);
int u, v;
for (int i = 1; i <= n; i++) root[i] = i, sz[i] = 1;
for (int i = 1; i <= m; i++) {
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
unite(u, v);
}
for (int i = 1; i <= n; i++) {
if (!vst[i]) {
tmp = 0;
dfs(i);
D[find(i)] = tmp;
}
}
int first, second;
while (q--) {
int tp;
gn(tp);
if (tp == 1) {
gn(first);
first = find(first);
println(D[first]);
} else {
gn(first, second);
unite(first, second);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int key[300005], dia[300005], m1[300005], m2[300005], dp1[300005],
dp2[300005];
vector<long long int> kv[300005], adj[300005];
bool mrk[300005];
inline void dfs(long long int x, long long int pr, long long int root) {
if (mrk[x]) return;
mrk[x] = 1;
key[x] = root;
if (x != root) kv[root].push_back(x);
for (auto j : adj[x]) {
if (j == pr) continue;
if (mrk[j]) continue;
dfs(j, x, root);
if (dp1[j] >= m1[x]) {
m2[x] = m1[x];
m1[x] = dp1[j];
} else if (dp1[j] >= m2[x])
m2[x] = dp1[j];
}
dp1[x] = m1[x] + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m, q;
cin >> n >> m >> q;
for (long long int i = 1; i <= n; i++) {
m1[i] = m2[i] = -1;
key[i] = i;
kv[i].push_back(i);
}
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long int i = 1; i <= n; i++) {
if (!mrk[i]) dfs(i, -1, i);
}
long long int mx = 0;
for (long long int i = 1; i <= n; i++) {
dp2[i] = m1[i] + m2[i] + 2;
mx = max(dp1[i], dp2[i]);
dia[key[i]] = max(dia[key[i]], mx);
}
while (q--) {
long long int ch;
cin >> ch;
if (ch == 1) {
long long int x;
cin >> x;
cout << dia[key[x]] << '\n';
continue;
}
long long int x, y;
cin >> x >> y;
if (key[x] != key[y]) {
if (kv[key[x]].size() < kv[key[y]].size()) swap(x, y);
long long int xx = ceil(dia[key[x]] / 2.0) + ceil(dia[key[y]] / 2.0) + 1;
dia[key[x]] = max(max(dia[key[x]], dia[key[y]]), xx);
long long int z = key[y];
for (auto j : kv[z]) {
kv[key[x]].push_back(j);
key[j] = key[x];
}
kv[z].clear();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[301000];
vector<int> root;
int lv[301000], imax, savemid, savelv[301000], save;
bool check[301000];
int findd(int x) {
if (root[x] == x || root[x] == -1) return x;
return root[x] = findd(root[x]);
}
void dfs(int x) {
for (int i = 0; i < a[x].size(); i++) {
if (lv[a[x][i]] == 0) {
lv[a[x][i]] = lv[x] + 1;
root[a[x][i]] = findd(x);
dfs(a[x][i]);
}
}
if (imax < lv[x]) {
imax = lv[x];
save = x;
}
}
void dfs2(int x) {
check[x] = true;
savelv[lv[x]] = x;
for (int i = 0; i < a[x].size(); i++) {
if (check[a[x][i]] == false) {
lv[a[x][i]] = lv[x] + 1;
dfs2(a[x][i]);
}
}
if (imax < lv[x]) {
imax = lv[x];
savemid = savelv[((lv[x] + 1) / 2)];
}
}
struct graph {
int first, centre, maxdis, height;
graph(int x = 1, int y = 1, int z = 0) {
maxdis = z;
centre = y;
first = x;
height = (maxdis + 1) / 2;
}
void build() {
imax = 0;
savemid = 1;
lv[save] = 1;
dfs2(save);
centre = savemid;
maxdis = imax - 1;
height = (maxdis + 1) / 2;
}
graph operator+(graph a) {
root[findd(a.first)] = findd(first);
if (max(a.height, height) - min(a.height, height) <= 1) {
graph ans = graph(first, centre, maxdis);
ans.maxdis = height + a.height + 1;
ans.height = (ans.maxdis + 1) / 2;
if (a.height >= height)
ans.centre = a.centre;
else
ans.centre = centre;
return ans;
} else {
graph ans = graph(first, centre, maxdis);
if (a.height >= height) {
ans.centre = a.centre;
ans.maxdis = a.maxdis;
ans.height = a.height;
} else {
ans.centre = centre;
ans.maxdis = maxdis;
ans.height = height;
}
return ans;
}
}
void prin() { printf("%d %d %d %d", first, maxdis, height, centre); }
} gra[301000];
int grap[301000];
int main() {
int n, m, q, u, v, cnt = 0;
scanf("%d %d %d", &n, &m, &q);
root.assign(n + 1, -1);
while (m--) {
scanf("%d %d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (findd(i) == i) {
imax = -1;
root[i] = i;
lv[i] = 1;
grap[i] = cnt + 1;
dfs(i);
gra[++cnt].first = i;
gra[cnt].build();
}
}
while (q--) {
scanf("%d", &u);
if (u == 2) {
scanf("%d %d", &u, &v);
if (findd(u) != findd(v)) {
gra[grap[findd(u)]] = gra[grap[findd(u)]] + gra[grap[findd(v)]];
}
} else {
scanf("%d", &u);
printf("%d\n", gra[grap[findd(u)]].maxdis);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> adj[300300];
int p[300300], sol[300300];
int m_set(int u) { return p[u] == u ? u : p[u] = m_set(p[u]); }
bool same_set(int u, int v) { return m_set(u) == m_set(v); }
bool P = false;
void join(int u, int v) {
u = m_set(u);
v = m_set(v);
if (u == v)
return;
else {
if (P) {
sol[v] =
max(max((sol[v] + 1) / 2 + (sol[u] + 1) / 2 + 1, sol[v]), sol[u]);
}
p[u] = v;
}
}
void init(int n) {
for (int i = 0; i <= n; i++) p[i] = i;
}
bitset<300300> visited;
pair<int, int> dfs(int u, int p) {
visited[u] = true;
pair<int, int> ans = make_pair(u, 0);
for (__typeof((adj[u]).begin()) v = (adj[u]).begin(); v != (adj[u]).end();
v++)
if (*v != p) {
pair<int, int> aux = dfs(*v, u);
if (aux.second + 1 > ans.second) {
ans.second = aux.second + 1;
ans.first = aux.first;
}
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
init(n);
int u, v;
for (int i = 0; i < int(m); i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
join(u, v);
}
for (int i = 1; i <= n; i++)
if (!visited[i]) {
pair<int, int> aux = dfs(i, -1);
aux = dfs(aux.first, -1);
sol[m_set(i)] = aux.second;
}
P = true;
for (int i = 0; i < int(q); i++) {
int id;
scanf("%d", &id);
if (id == 1) {
int x;
scanf("%d", &x);
printf("%d\n", sol[m_set(x)]);
} else if (id == 2) {
int x, y;
scanf("%d %d", &x, &y);
join(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e6 + 10;
int n, m, q, fa[maxn], maxx, dis[maxn], st;
int cnt, head[maxn], to[maxn << 1], nxt[maxn << 1];
bool vis[maxn], vis2[maxn];
int read() {
int ret = 0, f = 1;
char x = getchar();
while (!isdigit(x)) {
if (x == '-') f = -1;
x = getchar();
}
while (isdigit(x)) {
ret = ret * 10 + x - '0';
x = getchar();
}
return ret * f;
}
void add_edge(int x, int y) {
cnt++;
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
int xx = find(x), yy = find(y);
fa[xx] = yy;
}
void dfs(int x, int val) {
if (maxx < val) maxx = val, st = x;
for (int i = head[x]; i; i = nxt[i]) {
int v = to[i];
if (!vis[v]) {
vis[v] = true;
dfs(v, val + 1);
}
}
vis[x] = false;
}
void dfs2(int x, int val) {
if (maxx < val) maxx = val;
for (int i = head[x]; i; i = nxt[i]) {
int v = to[i];
if (!vis[v]) {
vis[v] = true;
dfs2(v, val + 1);
}
}
vis[x] = false;
}
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
add_edge(x, y), add_edge(y, x);
merge(x, y);
}
for (int i = 1; i <= n; i++) {
int x = find(i);
if (vis2[x]) continue;
maxx = -1;
vis[x] = true;
dfs(x, 0);
maxx = -1;
vis[st] = true;
dfs2(st, 0);
vis2[x] = true;
dis[x] = maxx;
}
for (int i = 1; i <= q; i++) {
int opt = read(), x = read();
if (opt == 1)
printf("%d\n", dis[find(x)]);
else {
int y = read();
int fx = find(x), fy = find(y);
if (fx == fy) continue;
dis[fy] =
max(max((dis[fx] + 1) / 2 + (dis[fy] + 1) / 2 + 1, dis[fx]), dis[fy]);
merge(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
vector<int> adj[N];
int vis[N], pi[N], diam[N], b, d, color, comp;
int find(int v) { return pi[pi[v]] == pi[v] ? pi[v] : pi[v] = find(pi[v]); }
void dfs(int v, int dist) {
vis[v] = color;
if (dist > d) {
b = v;
d = dist;
}
pi[v] = comp;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (vis[u] != color) dfs(u, dist + 1);
}
}
int main() {
int n, m, q;
cin >> n >> m >> q;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
b = i, d = 0, comp = i;
color = 2 * i;
dfs(i, 0);
int a = b;
d = 0;
color = 2 * i + 1;
dfs(b, 0);
diam[i] = d;
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
printf("%d\n", diam[find(x)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
int px = find(x);
int py = find(y);
if (px != py) {
pi[px] = py;
diam[py] = max(max(diam[px], diam[py]),
(diam[px] + 1) / 2 + (diam[py] + 1) / 2 + 1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int p[300005], far, dist, d[300005];
std::vector<int> G[300005];
void dfs(int v, int fat, int c, int d = 0) {
p[v] = c;
if (d > dist) dist = d, far = v;
for (int x : G[v])
if (x != fat) dfs(x, v, c, d + 1);
}
int f(int a) { return p[a] == a ? a : p[a] = f(p[a]); }
void me(int a, int b) {
int x = f(a), y = f(b);
p[x] = y;
d[y] = std::max({d[y], d[x], (d[y] + 1) / 2 + (d[x] + 1) / 2 + 1});
}
int main() {
int n, m, q, a, b;
scanf("%d%d%d", &n, &m, &q);
while (m--) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (!p[i]) {
dist = -1;
dfs(i, i, i);
dist = -1;
dfs(far, far, i);
d[i] = dist;
}
while (q--) {
scanf("%d%d", &m, &a);
if (m == 1)
printf("%d\n", d[f(a)]);
else {
scanf("%d", &b);
if (f(a) != f(b)) me(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 5;
vector<int> graph[maxn];
int n, m, q, a, b, k, parent[maxn], lp[maxn], vertex, len, c, d, l, h[maxn];
int findparent(int x) {
if (x == parent[x])
return x;
else
return parent[x] = findparent(parent[x]);
}
void dfs(int x, int s, int t) {
if (s > len) {
len = s;
vertex = x;
}
h[x] = t;
parent[x] = l;
for (int j = 0; j < graph[x].size(); j++) {
if (h[graph[x][j]] != t) {
h[graph[x][j]] = t;
dfs(graph[x][j], s + 1, t);
}
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (int i = 0; i < m; i++) {
scanf("%d", &a);
scanf("%d", &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (parent[i]) continue;
len = -1;
l = i;
dfs(i, 0, 1);
len = -1;
dfs(vertex, 0, 2);
lp[i] = len;
}
for (int i = 0; i < q; i++) {
scanf("%d", &k);
scanf("%d", &a);
if (k == 2) {
scanf("%d", &b);
c = findparent(a);
d = findparent(b);
if (c == d) continue;
if (c != d) {
lp[c] = max(lp[c], max(lp[d], (lp[c] + 1) / 2 + (lp[d] + 1) / 2 + 1));
parent[d] = c;
}
} else
printf("%d \n", lp[findparent(a)]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, m, q, opt, u, v, xx, yy, p, ans;
int f[N], d[N];
int cnt, head[N];
struct edge {
int next, to;
} e[N << 1];
inline void add(int u, int v) {
cnt++;
e[cnt].next = head[u];
e[cnt].to = v;
head[u] = cnt;
}
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void dfs(int u, int fa, int now) {
if (now > ans) ans = now, p = u;
for (register int i = head[u]; i; i = e[i].next)
if (e[i].to != fa) dfs(e[i].to, u, now + 1);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (register int i = 1; i <= n; ++i) f[i] = i;
for (register int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v), add(u, v), add(v, u);
xx = find(u);
yy = find(v);
if (xx != yy) f[xx] = yy;
}
for (register int i = 1; i <= n; ++i)
if (find(i) == i) {
ans = 0;
p = i;
dfs(p, 0, 0);
ans = 0;
dfs(p, 0, 0);
d[i] = ans;
}
while (q--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d", &u);
xx = find(u);
printf("%d\n", d[xx]);
} else {
scanf("%d%d", &u, &v);
xx = find(u);
yy = find(v);
if (xx == yy) continue;
f[xx] = yy;
d[yy] = max((d[xx] + 1) / 2 + (d[yy] + 1) / 2 + 1, max(d[xx], d[yy]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300100;
int read() {
int x = 0, w = 1;
char ch = 0;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') w = -1;
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * w;
}
vector<int> G[maxn];
int vis[maxn];
int fa[maxn], ans[maxn];
int findfa(int rt) { return rt == fa[rt] ? rt : fa[rt] = findfa(fa[rt]); }
void merge(int a, int b) {
if (findfa(a) != findfa(b)) fa[fa[a]] = fa[b];
}
int tmp = 0, tmp2 = 0;
void dfs(int rt, int col, int res) {
if (vis[rt] == col) return;
if (res > tmp) tmp = res, tmp2 = rt;
vis[rt] = col;
for (int to : G[rt]) merge(rt, to), dfs(to, col, res + 1);
}
int main() {
int n = read(), m = read(), q = read();
for (int i = 1; i <= n; i++) fa[i] = i;
while (m--) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
tmp = 0, tmp2 = i;
dfs(i, i, 0);
tmp = 0;
dfs(tmp2, tmp2, 0);
ans[findfa(i)] = tmp;
}
while (q--) {
int opt = read();
if (opt == 1)
printf("%d\n", ans[findfa(read())]);
else {
int u = read(), v = read();
u = findfa(u), v = findfa(v);
if (u == v) continue;
fa[u] = v;
ans[v] =
max(max(ans[v], ans[u]), (ans[u] + 1) / 2 + (ans[v] + 1) / 2 + 1);
}
}
}
|
#include <bits/stdc++.h>
const int maxN = 5e5 + 10, oo = 23041997;
const double eps = 1e-5;
using namespace std;
int n, m, q, par[maxN], dia[maxN], flag, visited[maxN];
vector<int> adj[maxN];
void dfs(int u, int d, int& max_u, int& max_d) {
visited[u] = flag;
if (max_d < d) {
max_d = d;
max_u = u;
}
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (visited[v] == flag) continue;
dfs(v, d + 1, max_u, max_d);
}
}
int get_root(int u) { return (u == par[u]) ? u : (par[u] = get_root(par[u])); }
void join(int u, int v) {
u = get_root(u);
v = get_root(v);
if (u == v) return;
par[u] = v;
int new_dia = (dia[u] + 1) / 2 + (dia[v] + 1) / 2 + 1;
dia[v] = max(new_dia, max(dia[u], dia[v]));
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) par[i] = i;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
join(u, v);
}
for (int i = 1; i <= n; ++i)
if (get_root(i) == i) {
int u = i, v, d = 0;
++flag;
dfs(i, 0, u, d);
++flag;
dfs(u, 0, v, d);
dia[i] = d;
}
for (int i = 1; i <= q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int u;
scanf("%d", &u);
printf("%d\n", dia[get_root(u)]);
} else {
int u, v;
scanf("%d %d", &u, &v);
join(u, v);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, m, k, q, pos1, pos2, max_dis;
struct node {
int to, next;
} edge[maxn];
int head[maxn], fa[maxn], dis[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void add(int u, int v) {
edge[++k].to = v;
edge[k].next = head[u];
head[u] = k;
}
void merge(int x, int y) {
int fx = find(x), fy = find(y);
fa[fx] = fy;
}
void dfs1(int u, int fa, int len) {
if (max_dis < len) max_dis = len, pos1 = u;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v != fa) dfs1(v, u, len + 1);
}
}
void dfs2(int u, int fa, int len) {
if (max_dis < len) max_dis = len, pos2 = u;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v != fa) dfs2(v, u, len + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int v, u;
scanf("%d%d", &v, &u);
add(v, u), add(u, v);
merge(v, u);
}
for (int i = 1; i <= n; i++) {
if (fa[i] == i) {
max_dis = pos1 = pos2 = 0;
dfs1(i, -1, 0);
dfs2(pos1, -1, 0);
dis[i] = max_dis;
}
}
for (int i = 1; i <= q; i++) {
int opt, x, y;
scanf("%d", &opt);
if (opt == 1) {
scanf("%d", &x);
printf("%d\n", dis[find(x)]);
} else {
scanf("%d%d", &x, &y);
int fx = find(x), fy = find(y);
if (fx == fy) continue;
dis[fy] =
max(max((dis[fx] + 1) / 2 + (dis[fy] + 1) / 2 + 1, dis[fx]), dis[fy]);
merge(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 7;
int n, m, q;
int sz[N], p[N], mx[N];
int findSet(int v) {
if (p[v] == v) return v;
return p[v] = findSet(p[v]);
}
void mergeSets(int a, int b) {
a = findSet(a);
b = findSet(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a;
sz[a] += sz[b];
mx[a] = max((mx[a] + 1) / 2 + (mx[b] + 1) / 2 + 1, max(mx[b], mx[a]));
}
vector<int> g[N];
char used[N];
void dfs(int v, int& d, int& ans) {
used[v] = true;
vector<int> mxs;
d = 0, ans = 0;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) {
int dep, toAns;
dfs(to, dep, toAns);
ans = max(ans, toAns);
d = max(d, dep + 1);
mxs.push_back(dep + 1);
sort(mxs.begin(), mxs.end());
if (mxs.size() > 2) mxs.erase(mxs.begin());
int a = findSet(to);
int b = findSet(v);
if (sz[a] < sz[b]) swap(a, b);
p[a] = b;
sz[a] += sz[b];
}
}
int sum = 0;
for (int i = 0; i < mxs.size(); ++i) sum += mxs[i];
ans = max(ans, sum);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
p[i] = i;
sz[i] = 1;
mx[i] = 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
int ans, d;
dfs(i, d, ans);
mx[findSet(i)] = ans;
}
}
for (int i = 0; i < q; ++i) {
int tp;
cin >> tp;
if (tp == 1) {
int x;
cin >> x;
--x;
int id = findSet(x);
cout << mx[id] << endl;
} else {
int x, y;
cin >> x >> y;
--x, --y;
mergeSets(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, fa[300005], ans[300005], a1, pos;
int vis[300005];
vector<int> G[300005];
int findset(int x) {
if (fa[x] != x) fa[x] = findset(fa[x]);
return fa[x];
}
void dfs(int u, int d, int step) {
if (vis[u] == d) return;
vis[u] = d;
if (step > a1) {
a1 = step;
pos = u;
}
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (findset(v) != findset(u)) fa[fa[v]] = fa[u];
dfs(G[u][i], d, step + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
a1 = 0, pos = i;
dfs(i, i, 0);
a1 = 0;
dfs(pos, pos, 0);
ans[findset(i)] = a1;
}
}
while (q--) {
int flag;
scanf("%d", &flag);
if (flag == 1) {
int u;
scanf("%d", &u);
printf("%d\n", ans[findset(u)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
int v1 = findset(x);
int v2 = findset(y);
if (v1 != v2) {
fa[v1] = v2;
ans[v2] = max(max(ans[v1], ans[v2]),
(ans[v1] + 1) / 2 + (ans[v2] + 1) / 2 + 1);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
};
template <class A, class B>
ostream &operator<<(ostream &os, pair<A, B> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, rge<T> d) {
os << "[";
for (auto it = d.b; it != d.e; it++) os << (it == d.b ? "" : ", ") << *it;
return os << "]";
}
const int N = 3e5 + 5;
const int inf = 2 * N;
struct dsu {
vector<int> pr, rank, mx;
dsu(int nn = 0) {
pr.resize(nn + 5);
iota((pr).begin(), (pr).end(), 0);
rank.resize(nn + 5, 0);
mx.resize(nn + 5, 0);
}
int find(int u) { return pr[u] == u ? u : pr[u] = find(pr[u]); }
void unite(int u, int v) {
u = find(u), v = find(v);
if (u != v) {
if (rank[u] > rank[v]) {
swap(u, v);
}
pr[u] = v;
mx[v] = max({mx[u], mx[v], (mx[u] + 1) / 2 + (mx[v] + 1) / 2 + 1});
if (rank[u] == rank[v]) {
rank[v]++;
}
}
}
int operator[](int u) { return find(u); }
int longest_path(int u) { return mx[find(u)]; }
};
vector<int> g[N];
bool vis[N];
dsu dg;
int n, m, q;
pair<int, int> dfs(int u, int pr = 0) {
vis[u] = true;
pair<int, int> far = {-1, u};
for (int v : g[u])
if (v != pr) {
far = max(far, dfs(v, u));
}
far.first++;
return far;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(15);
cin >> n >> m >> q;
dg = dsu(n);
while (m--) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
dg.unite(u, v);
}
for (int u = (1); u <= ((n)); u += (+1)) {
dg.mx[u] = 0;
}
for (int u = (1); u <= ((n)); u += (+1))
if (!vis[u]) {
dg.mx[dg[u]] = dfs(dfs(u).second).first;
}
while (q--) {
int t, u, v;
cin >> t >> u;
if (t == 1) {
cout << dg.longest_path(u) << '\n';
} else {
cin >> v;
dg.unite(u, v);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4 * 100007;
vector<int> adj[N];
int D[N], par[N], fa, mx;
int find_set(int x) { return par[x] == x ? x : par[x] = find_set(par[x]); }
void dfs(int v) {
par[v] = fa;
for (auto x : adj[v])
if (!par[x]) {
dfs(x);
mx = max(mx, D[x] + D[v] + 1);
D[v] = max(D[v], D[x] + 1);
}
}
int main() {
int n, m, q, a, b;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; ++i)
if (!par[i]) fa = i, mx = 0, dfs(i), D[i] = mx;
for (int i = 0; i < q; ++i) {
int x;
scanf("%d%d", &x, &a);
if (x == 1)
printf("%d\n", D[find_set(a)]);
else {
scanf("%d", &b);
a = find_set(a);
b = find_set(b);
if (a != b) {
par[b] = a;
D[a] = max((D[a] + 1) / 2 + (D[b] + 1) / 2 + 1, max(D[a], D[b]));
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int par[300005];
vector<int> v[300005];
int parent(int x) {
if (x == par[x]) return x;
return par[x] = parent(par[x]);
}
void join(int x, int y) {
x = parent(x);
y = parent(y);
par[x] = y;
}
int dis[300005][2], dia[300005];
int bfs(int x, bool f) {
queue<int> q;
q.push(x);
dis[x][f] = 0;
while (!q.empty()) {
x = q.front();
q.pop();
for (auto nxt : v[x]) {
if (dis[nxt][f] == -1) {
dis[nxt][f] = dis[x][f] + 1;
q.push(nxt);
}
}
}
return x;
}
void mer(int x, int y) {
x = parent(x);
y = parent(y);
if (x == y) return;
int mx = max(dia[x], dia[y]);
mx = max(mx, (dia[x] + 1) / 2 + (dia[y] + 1) / 2 + 1);
par[x] = y;
dia[y] = mx;
}
int main() {
int n, m, q;
while (cin >> n >> m >> q) {
memset(dis, -1, sizeof dis);
for (int i = 0; i <= n; ++i) par[i] = i;
for (int i = 0; i < m; ++i) {
int fr, to;
scanf("%d%d", &fr, &to);
v[fr].push_back(to);
v[to].push_back(fr);
join(fr, to);
}
for (int i = 1; i <= n; ++i) {
if (par[i] != i) continue;
int x = bfs(i, 0);
dia[i] = dis[bfs(x, 1)][1];
}
while (q--) {
int cmd, x, y;
scanf("%d%d", &cmd, &x);
if (cmd == 1) {
x = parent(x);
printf("%d\n", dia[x]);
continue;
}
scanf("%d", &y);
mer(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
int nextInt() {
int x = 0, p = 1;
char c;
do {
c = getchar();
} while (c <= 32);
if (c == '-') {
p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * p;
}
const int maxn = 300500;
int n, m, q;
vector<int> g[maxn];
bool used[maxn];
int p[maxn], sz[maxn], diameter[maxn];
int maxi, maxiV;
void dfs(int v, int depth, int p) {
if (depth > maxi) {
maxi = depth;
maxiV = v;
}
for (size_t i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) dfs(to, depth + 1, v);
}
}
int findLongestWay(int v) {
maxi = -1;
dfs(v, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
void init() {
for (int i = 1; i <= n; i++) p[i] = i, sz[i] = 1, diameter[i] = 0;
}
int getSet(int v) {
if (p[v] == v) return v;
return p[v] = getSet(p[v]);
}
void unionSets1(int x, int y) {
x = getSet(x);
y = getSet(y);
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
p[x] = y;
}
int rad(int x) { return (diameter[x] + 1) / 2; }
void unionSets2(int x, int y) {
x = getSet(x);
y = getSet(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
p[x] = y;
diameter[y] = max(rad(x) + rad(y) + 1, diameter[x], diameter[y]);
}
int query(int x) { return diameter[getSet(x)]; }
int main() {
n = nextInt();
m = nextInt();
q = nextInt();
init();
for (int i = 1; i <= m; i++) {
int x, y;
x = nextInt();
y = nextInt();
g[x].push_back(y);
g[y].push_back(x);
unionSets1(x, y);
}
for (int i = 1; i <= n; i++) {
int pp = getSet(i);
if (!used[pp]) {
used[pp] = 1;
diameter[pp] = findLongestWay(i);
}
}
while (q--) {
int t, x, y;
t = nextInt();
if (t == 2) {
x = nextInt();
y = nextInt();
unionSets2(x, y);
} else {
x = nextInt();
printf("%d\n", query(x));
}
}
}
|
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
using pii = std::pair<long long, long long>;
using namespace std;
long long n, m, q, t, a, b, parent[300005], visited[300005], sz[300005],
diameter[300005], last, ldist;
vector<long long> adj[300005];
class CCivilization {
public:
void solve(std::istream& in, std::ostream& out) {
in >> n >> m >> q;
for (long long i = (0); i < (n); i++) {
adj[i].clear();
visited[i] = 0;
diameter[i] = 0;
parent[i] = i;
sz[i] = 0;
}
for (long long i = (0); i < (m); i++) {
in >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = (0); i < (n); i++)
if (!visited[i]) {
last = ldist = -1;
dfs(i, i, 0);
diameter[i] = dfs2(last);
}
for (long long i = (0); i < (q); i++) {
in >> t;
if (t == 1) {
in >> a;
a--;
a = getparent(a);
out << diameter[a] - 1 << "\n";
} else {
in >> a >> b;
a--;
b--;
combine(a, b);
}
}
}
void dfs(long long x, long long start, long long dist) {
if (visited[x]) return;
visited[x] = 1;
if (dist > ldist) {
last = x;
ldist = dist;
}
parent[x] = start;
sz[start]++;
for (auto v : adj[x])
if (!visited[v]) dfs(v, start, dist + 1);
}
long long dfs2(long long x) {
if (visited[x] == 2) return 0;
visited[x] = 2;
long long best = 0;
for (auto v : adj[x])
if (visited[v] != 2) best = max(best, dfs2(v));
return 1 + best;
}
long long getparent(long long x) {
if (parent[x] == x) return x;
return parent[x] = getparent(parent[x]);
}
void combine(long long u, long long v) {
u = getparent(u);
v = getparent(v);
if (u == v) return;
if (sz[u] < sz[v]) swap(u, v);
parent[v] = u;
sz[u] += sz[v];
if (diameter[u] < diameter[v]) swap(diameter[u], diameter[v]);
diameter[u] = max(diameter[u], ((diameter[u] / 2) + (diameter[v] / 2) + 2));
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
CCivilization solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long bigmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
const int N = 300505;
int n, m, q;
vector<int> g[N];
int vis[N], pr[N], sz[N], dia[N], maxd, maxN;
void init() {
for (int i = int(1); i < int(N + 1); ++i)
pr[i] = i, vis[i] = 0, sz[i] = 1, dia[i] = 0;
}
int Find(int r) {
if (r == pr[r]) return r;
return pr[r] = Find(pr[r]);
}
void Union(int x, int y) {
x = Find(x);
y = Find(y);
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
pr[x] = y;
}
void dfs(int v, int d, int u) {
if (d > maxd) {
maxN = v;
maxd = d;
}
for (size_t i = 0; i < g[v].size(); i++) {
int it = g[v][i];
if (it != u) {
dfs(it, d + 1, v);
}
}
}
int val(int x) { return (dia[x] + 1) / 2; }
int Depth(int v) {
maxd = -1;
dfs(v, 0, -1);
maxd = -1;
dfs(maxN, 0, -1);
return maxd;
}
void Merge(int x, int y) {
x = Find(x);
y = Find(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
pr[x] = y;
dia[y] = max(val(x) + val(y) + 1, max(dia[x], dia[y]));
}
int main() {
memset(g, 0, sizeof g);
;
memset(vis, 0, sizeof vis);
;
memset(pr, 0, sizeof pr);
;
memset(sz, 0, sizeof sz);
;
memset(dia, 0, sizeof dia);
;
init();
int t, x, y;
scanf("%d %d %d", &n, &m, &q);
for (int i = int(0); i < int(m); ++i) {
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
Union(x, y);
}
for (int i = int(1); i < int(n + 1); ++i) {
x = Find(i);
if (!vis[x]) {
vis[x] = 1;
dia[x] = Depth(i);
}
}
for (int i = int(0); i < int(q); ++i) {
scanf("%d", &t);
if (t == 2) {
scanf("%d %d", &x, &y);
Merge(x, y);
} else {
scanf("%d", &x);
printf("%d\n", dia[Find(x)]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int C = 333333;
vector<int> adj[C];
int root[C], sz[C], d[C], src;
pair<int, int> f;
int find_root(int u) {
return (root[u] == u ? u : root[u] = find_root(root[u]));
}
void add(int u, int v) {
int uu = find_root(u), vv = find_root(v);
if (uu == vv) return;
sz[vv] += sz[uu];
root[uu] = vv;
smax(d[vv], max(d[uu], (1 + d[uu]) / 2 + (1 + d[vv]) / 2 + 1));
}
void dfs(int u, int dp = 0) {
root[u] = src;
sz[src]++;
if (dp > f.second) {
f.second = dp;
f.first = u;
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (root[v]) continue;
dfs(v, dp + 1);
}
}
void rdfs(int u, int dp = 0, int fa = 0) {
smax(d[src], dp);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
rdfs(v, dp + 1, u);
}
}
void solve_C() {
int n, m, q, u, v;
gn(n, m, q);
for (int i = 0; i < m; i++) {
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!root[i]) {
f.first = i;
f.second = 0;
src = i;
dfs(i);
rdfs(f.first);
}
while (q--) {
int t;
gn(t);
if (t == 1) {
gn(u);
u = find_root(u);
println(d[u]);
} else {
gn(u, v);
add(u, v);
}
}
exit(0);
}
int main() {
solve_C();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
vector<int> v[N];
vector<int> d(N, -1);
vector<int> p(N, 0);
vector<int> sz(N, 1);
vector<int> res(N, 1);
int find_set(int a) {
if (a == p[a])
return a;
else
return p[a] = find_set(p[a]);
}
void merge_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a;
sz[a] += sz[b];
int one = res[a] / 2 + 1;
int two = res[b] / 2 + 1;
res[a] = max(one + two, max(res[a], res[b]));
}
void ini(int a) {
d[a] = 0;
queue<int> q;
vector<int> t;
q.push(a);
int src = a;
while (!q.empty()) {
int x = q.front();
q.pop();
t.push_back(x);
for (int to : v[x]) {
if (d[to] != -1) continue;
d[to] = d[x] + 1;
if (d[to] > d[src]) src = to;
q.push(to);
}
}
for (int x : t) d[x] = -1;
d[src] = 1;
q.push(src);
int best = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
t.push_back(x);
for (int to : v[x]) {
if (d[to] != -1) continue;
d[to] = d[x] + 1;
best = max(best, d[to]);
q.push(to);
}
}
res[find_set(a)] = best;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) p[i] = i;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
merge_sets(a, b);
}
for (int i = 1; i <= n; i++)
if (d[i] == -1) ini(i);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int a;
scanf("%d", &a);
printf("%d\n", res[find_set(a)] - 1);
} else if (t == 2) {
int a, b;
scanf("%d%d", &a, &b);
merge_sets(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
struct arr {
int to, ne;
} e[300006 << 1];
int n, m, q, opt, cnt, x, y, f[300006], l[300006], d[300006], w[300006],
head[300006];
inline int read() {
int x = 0, c = getchar(), f = 1LL;
while (c < '0' || c > '9') f = (c == '-' ? -f : f), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1LL) + (x << 3) + c - 48, c = getchar();
return f > 0 ? x : -x;
}
void print(int x) {
if (x > 9) print(x / 10);
putchar(x % 10 + 48);
}
inline void add(int x, int y) {
e[++cnt].to = y;
e[cnt].ne = head[x];
head[x] = cnt;
}
int get(int x) { return x == f[x] ? x : f[x] = get(f[x]); }
void dfs(int p, int x, int y) {
f[x] = p;
d[x] = d[y] + 1;
w[x] = x;
for (int i = head[x]; i; i = e[i].ne)
if (e[i].to != y)
dfs(p, e[i].to, x), d[w[e[i].to]] > d[w[x]] ? w[x] = w[e[i].to] : 0;
}
void dfs(int x, int y) {
d[x] = d[y] + 1;
w[x] = x;
for (int i = head[x]; i; i = e[i].ne)
if (e[i].to != y)
dfs(e[i].to, x), d[w[e[i].to]] > d[w[x]] ? w[x] = w[e[i].to] : 0;
}
int main() {
n = read();
m = read();
q = read();
d[0] = -1;
for (int i = 1; i <= n; i++) f[i] = i, l[i] = 0;
for (int i = 1; i <= m; i++) x = read(), y = read(), add(x, y), add(y, x);
for (int i = 1; i <= n; i++)
if (f[i] == i && head[i]) dfs(i, i, 0), dfs(x = w[i], 0), l[i] = d[w[x]];
while (q--) {
opt = read();
x = read();
if (opt == 1)
print(l[get(x)]), puts("");
else {
x = get(x), y = get(read());
if (x != y)
f[y] = x, l[x] = (l[x] > (l[y] > (l[x] + 1) / 2 + (l[y] + 1) / 2 + 1
? l[y]
: (l[x] + 1) / 2 + (l[y] + 1) / 2 + 1)
? l[x]
: (l[y] > (l[x] + 1) / 2 + (l[y] + 1) / 2 + 1
? l[y]
: (l[x] + 1) / 2 + (l[y] + 1) / 2 + 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5 * 100007;
int par[N], _rank[N], mx, mx_v, diameter[N], used[N];
vector<int> adj[N];
void dfs(int v, int d, int p) {
if (mx < d) {
mx = d;
mx_v = v;
}
for (auto x : adj[v])
if (x != p) dfs(x, d + 1, v);
}
int cal_dia(int v) {
mx = -1;
dfs(v, 0, -1);
mx = -1;
dfs(mx_v, 0, -1);
return mx;
}
int find_set(int x) {
if (par[x] == x) return x;
return par[x] = find_set(par[x]);
}
void _union(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (_rank[a] < _rank[b]) swap(a, b);
par[b] = a;
if (_rank[a] == _rank[b]) ++_rank[a];
}
}
int rad(int val) { return (diameter[val] + 1) / 2; }
void __union(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (_rank[a] < _rank[b]) swap(a, b);
par[b] = a;
if (_rank[a] == _rank[b]) ++_rank[a];
diameter[a] = max(rad(a) + rad(b) + 1, max(diameter[a], diameter[b]));
}
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) par[i] = i;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
_union(a, b);
}
for (int i = 1; i <= n; ++i) {
int pp = find_set(i);
if (!used[pp]) {
used[pp] = 1;
diameter[pp] = cal_dia(pp);
}
}
while (q--) {
int a, b, c;
scanf("%d%d", &c, &a);
if (c == 1)
printf("%d\n", diameter[find_set(a)]);
else {
scanf("%d", &b);
__union(a, b);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
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 = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
const int Size = 300001;
vector<int> to[Size];
int dp[Size];
int len[Size];
int father[Size];
int n, m, q, ans, point, nowrt;
void PushEdge(int f, int t) { to[f].push_back(t); }
void dfs(int now, int lastnode, int dist) {
father[now] = nowrt;
if (dist > ans) {
ans = dist;
point = now;
}
int len = to[now].size();
for (int i = 0; i < len; i++) {
if (to[now][i] == lastnode) {
continue;
} else {
dfs(to[now][i], now, dist + 1);
}
}
}
void init() {
n = read();
m = read();
q = read();
for (int i = 1; i <= n; i++) father[i] = i;
for (int i = 1; i <= m; i++) {
int f = read();
int t = read();
PushEdge(f, t);
PushEdge(t, f);
}
for (int i = 1; i <= n; i++) {
nowrt = i;
if (father[i] == i) {
ans = -1;
dfs(i, i, 0);
ans = -1;
dfs(point, point, 0);
dp[i] = ans;
}
}
}
int find(int x) {
if (father[x] == x) return x;
return father[x] = find(father[x]);
}
void Union(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx == fy) return;
father[fy] = fx;
dp[fx] =
max(max(dp[fx], dp[fy]), ((dp[fx] + 1) >> 1) + ((dp[fy] + 1) >> 1) + 1);
}
int main() {
init();
int op, x, y;
while (q--) {
op = read();
if (op == 1) {
x = read();
printf("%d\n", dp[find(x)]);
} else {
x = read();
y = read();
Union(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, z, t, n, m, sum, ans, x, y, maxm = 0, q;
bool flag;
vector<int> v[300005];
int id[300005];
bool vis[300005];
int maxlen[300005];
int sz[300005];
int nextInt() {
int x = 0, p = 1;
char c;
do {
c = getchar();
} while (c <= 32);
if (c == '-') {
p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * p;
}
int getSet(int v) {
if (id[v] == v) return v;
return id[v] = getSet(id[v]);
}
void unionSets2(int x, int y) {
x = getSet(x);
y = getSet(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
id[x] = y;
}
void unionSets1(int x, int y) {
x = getSet(x);
y = getSet(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
id[x] = y;
maxlen[y] = max(
maxlen[x], max(maxlen[y], (maxlen[x] + 1) / 2 + (maxlen[y] + 1) / 2 + 1));
}
void dfs(int x, int depth, int p) {
if (depth > maxm) {
maxm = depth;
ans = x;
}
for (size_t i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to != p) dfs(to, depth + 1, x);
}
}
int findLongestWay(int v) {
maxm = -1;
dfs(v, 0, -1);
maxm = -1;
dfs(ans, 0, -1);
return maxm;
}
int main() {
n = nextInt();
m = nextInt();
q = nextInt();
for (int i = 1; i < n + 1; i++) id[i] = i, sz[i] = 1;
while (m--) {
x = nextInt();
y = nextInt();
v[x].push_back(y);
v[y].push_back(x);
unionSets2(x, y);
}
for (int i = 1; i < n + 1; i++) {
x = getSet(i);
if (!vis[x]) {
vis[x] = true;
maxlen[x] = findLongestWay(x);
}
}
while (q--) {
x = nextInt();
if (x == 2) {
x = nextInt();
y = nextInt();
unionSets1(x, y);
} else {
x = nextInt();
x = getSet(x);
printf("%d\n", int(maxlen[x]));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 3e5 + 5;
int n, m, q, fa[MAX_N], len[MAX_N], mxlen;
vector<int> e[MAX_N];
bool vis[MAX_N];
int dfs(int v, int f) {
fa[v] = f;
vis[v] = true;
int l1 = 0, l2 = 0;
for (int i = 0; i < e[v].size(); i++) {
int u = e[v][i];
if (u != f) {
int tmp = dfs(u, v) + 1;
if (tmp > l1) {
l2 = l1, l1 = tmp;
} else if (tmp > l2)
l2 = tmp;
}
}
mxlen = max(mxlen, l1 + l2);
return l1;
}
int getFa(int x) { return fa[x] == x ? x : (fa[x] = getFa(fa[x])); }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
mxlen = 0;
dfs(i, i);
len[i] = mxlen;
}
}
while (q--) {
int t, x, y;
scanf("%d", &t);
if (t == 1) {
scanf("%d", &x);
printf("%d\n", len[getFa(x)]);
} else {
scanf("%d%d", &x, &y);
int fx = getFa(x), fy = getFa(y);
if (fx == fy) continue;
fa[fx] = fy;
int t = max(len[fx], len[fy]);
t = max(t, (len[fx] + 1) / 2 + (len[fy] + 1) / 2 + 1);
len[fy] = t;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[300005], far, dist;
int d[300005];
vector<int> G[300005];
void dfs(int v, int fat, int c, int d = 0) {
p[v] = c;
if (d > dist) dist = d, far = v;
for (int x : G[v])
if (x != fat) dfs(x, v, c, d + 1);
}
int f(int a) {
if (p[a] == a) return a;
return p[a] = f(p[a]);
}
void me(int a, int b) {
int x = f(a), y = f(b);
p[x] = y;
d[y] = max({d[y], d[x], (d[y] + 1) / 2 + (d[x] + 1) / 2 + 1});
}
int main() {
int n, m, q, a, b;
scanf("%d%d%d", &n, &m, &q);
while (m--) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!p[i]) {
dist = -1;
dfs(i, i, i);
dist = -1;
dfs(far, far, i);
d[i] = dist;
}
}
while (q--) {
scanf("%d%d", &m, &a);
if (m == 1)
printf("%d\n", d[f(a)]);
else {
scanf("%d", &b);
if (f(a) != f(b)) me(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> graph[300005], yo;
bool done[300005] = {0}, done2[300005] = {0};
int parent[300005], ans[300005] = {0}, dp[300005][2];
int get(int x) {
while (x != parent[x]) x = parent[x];
return x;
}
void merge(int x, int y) {
int cntx = 0, cnty = 0;
while (x != parent[x]) x = parent[x], cntx++;
while (y != parent[y]) y = parent[y], cnty++;
if (cntx < cnty)
parent[x] = y;
else
parent[y] = x;
}
int go(int src) {
pair<int, int> maxx = {src, 0};
stack<pair<int, int> > s;
s.push({src, 0});
while (!s.empty()) {
int x = s.top().first, d = s.top().second;
if (d > maxx.second) maxx = {x, d};
s.pop();
done2[x] = 1;
for (auto it : graph[x])
if (!done2[it]) s.push({it, d + 1});
}
s.push({maxx.first, 0});
maxx.second = 0;
while (!s.empty()) {
int x = s.top().first, d = s.top().second;
if (d > maxx.second) maxx = {x, d};
s.pop();
done[x] = 1;
yo.push_back(x);
for (auto it : graph[x])
if (!done[it]) s.push({it, d + 1});
}
return maxx.second;
}
int main() {
for (__typeof(300005) i = 0 - (0 > 300005); i != 300005 - (0 > 300005);
i += 1 - 2 * (0 > 300005))
parent[i] = i;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (__typeof(m) i = 0 - (0 > m); i != m - (0 > m); i += 1 - 2 * (0 > m)) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
graph[u].push_back(v);
graph[v].push_back(u);
merge(u, v);
}
for (__typeof(n + 1) i = 1 - (1 > n + 1); i != n + 1 - (1 > n + 1);
i += 1 - 2 * (1 > n + 1)) {
if (!done[i]) {
yo.clear();
int dia = go(i);
for (auto it : yo) ans[it] = dia;
}
}
for (__typeof(q) i = 0 - (0 > q); i != q - (0 > q); i += 1 - 2 * (0 > q)) {
int mode;
scanf("%d", &mode);
if (mode == 1) {
int x;
scanf("%d", &x);
printf("%d\n", ans[get(x)]);
} else {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
if (get(x) == get(y)) continue;
int a = ans[get(x)], b = ans[get(y)], c = (a + 1) / 2 + (b + 1) / 2 + 1;
merge(x, y);
ans[get(x)] = max(c, max(a, b));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
int n, m, q, p[MAXN + 3], rk[MAXN + 3], dia[MAXN + 3], type, x, y,
dist[MAXN + 3];
bool flag[MAXN + 3];
vector<int> adj[MAXN + 3];
int ceil(int n) {
if (!n) return 0;
return (n - 1) / 2 + 1;
}
int find(int x) { return (p[x] == x ? x : (p[x] = find(p[x]))); }
void join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rk[x] < rk[y]) swap(x, y);
rk[x] += rk[y];
p[y] = x;
}
void join2(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rk[x] < rk[y]) swap(x, y);
dia[x] = max(max(dia[x], dia[y]), ceil(dia[x]) + ceil(dia[y]) + 1);
rk[x] += rk[y];
p[y] = x;
}
int calDia(int p) {
queue<int> q;
q.push(p);
flag[p] = true;
dist[p] = 0;
int u, v;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < (int)adj[u].size(); ++i) {
v = adj[u][i];
if (!flag[v]) {
flag[v] = true;
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
q.push(u);
flag[u] = false;
dist[u] = 0;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < (int)adj[u].size(); ++i) {
v = adj[u][i];
if (flag[v]) {
flag[v] = false;
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
return dist[u];
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; ++i) p[i] = i, rk[i] = 1;
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &x, &y);
join(x, y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; ++i)
if (find(i) == i) {
dia[i] = calDia(i);
}
while (q-- > 0) {
scanf("%d %d", &type, &x);
if (type == 1) {
printf("%d\n", dia[find(x)]);
} else {
scanf("%d", &y);
join2(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, dia[300005], rad[300005], par[300005];
bool vis[300005];
int rt;
vector<int> V[300005];
void dfs(int id) {
vis[id] = true;
par[id] = rt;
rad[id] = dia[id] = 0;
for (int i = 0; i < V[id].size(); i++) {
int to = V[id][i];
if (vis[to]) continue;
dfs(to);
dia[id] = max(dia[id], dia[to]);
dia[id] = max(dia[id], rad[id] + rad[to] + 1);
if (rad[to] + 1 > rad[id]) rad[id] = rad[to] + 1;
}
return;
}
int f(int x) {
if (par[x] == x)
return x;
else
return par[x] = f(par[x]);
}
void merge(int a, int b) {
int fa = f(a);
int fb = f(b);
if (fa == fb) return;
int nd =
max(max(dia[fa], dia[fb]), (dia[fa] + 1) / 2 + (dia[fb] + 1) / 2 + 1);
dia[fa] = 0;
par[fa] = fb;
dia[fb] = nd;
return;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
rt = i;
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
if (par[i] != i) {
dia[i] = 0;
}
}
for (int i = 1; i <= q; i++) {
int a, b, c;
scanf("%d", &a);
if (a == 1) {
scanf("%d", &b);
int fb = f(b);
printf("%d\n", dia[fb]);
} else {
scanf("%d %d", &b, &c);
merge(b, c);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, pa[300005], d[300005];
vector<int> adj[300005];
int Find(int x) { return pa[x] == x ? x : pa[x] = Find(pa[x]); }
void Union(int u, int v, bool f) {
int ru = Find(u), rv = Find(v);
if (ru == rv) return;
pa[ru] = rv;
if (!f) return;
d[rv] = max(max(d[ru], d[rv]), (d[ru] + 1) / 2 + (d[rv] + 1) / 2 + 1);
}
int dfs(int p, int v) {
int ans = v, i, u, x;
for (i = 0; i < (adj[v].size()); i++) {
u = adj[v][i];
if (u == p) continue;
d[u] = d[v] + 1;
x = dfs(v, u);
if (d[ans] < d[x]) ans = x;
}
return ans;
}
int main() {
int i, u, v, flag;
scanf("%d%d%d", &n, &m, &q);
for (i = 1; i <= (n); i++) pa[i] = i;
for (i = 0; i < (m); i++) {
scanf("%d%d", &u, &v);
Union(u, v, false);
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(d, 0, sizeof(d));
for (i = 1; i <= (n); i++) {
if (Find(i) == i) {
u = dfs(0, i);
d[u] = 0;
d[i] = d[dfs(0, u)];
}
}
while (q--) {
scanf("%d", &flag);
if (flag == 1) {
scanf("%d", &u);
printf("%d\n", d[Find(u)]);
} else {
scanf("%d%d", &u, &v);
Union(u, v, true);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int r = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') r = (r << 1) + (r << 3) + c - '0', c = getchar();
return r * f;
}
int fa[300100];
int find(int x) { return x == fa[x] ? fa[x] : (fa[x] = find(fa[x])); }
vector<int> mp[300100];
int dp[300100];
int len[300100];
int Size[300100];
void dfs(int x, int f) {
for (int i = 0; i < mp[x].size(); ++i) {
int y = mp[x][i];
if (y == f) continue;
fa[y] = fa[x];
++Size[fa[x]];
dfs(y, x);
len[find(x)] = max(dp[x] + dp[y] + 1, len[find(x)]);
dp[x] = max(dp[x], dp[y] + 1);
}
}
int ediv(int x, int y) { return x / y + (x % y != 0); }
int main() {
int n = read(), m = read(), q = read();
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
mp[u].push_back(v);
mp[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (fa[i] == i) {
dfs(i, 0);
}
}
for (int i = 1; i <= q; ++i) {
int op = read();
if (op == 1) {
int x = find(read());
printf("%d\n", len[x]);
} else {
int x = find(read()), y = find(read());
if (x == y) continue;
if (Size[y] < Size[x]) {
Size[x] += Size[y];
len[x] =
max(max(len[x], len[y]), ediv(len[x], 2) + ediv(len[y], 2) + 1);
fa[y] = x;
} else {
Size[y] += Size[x];
len[y] =
max(max(len[x], len[y]), ediv(len[x], 2) + ediv(len[y], 2) + 1);
fa[x] = y;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600010;
int ROOT, MAX, CITY;
int p[N], was[N];
vector<int> g[N];
void dfs(int v, int d, int mark) {
p[v] = ROOT;
if (d > MAX) {
MAX = d;
CITY = v;
}
was[v] = mark + 1;
int sz = g[v].size();
for (int j = 0; j < sz; j++) {
int u = g[v][j];
if (was[u] > mark) {
continue;
}
dfs(u, d + 1, mark);
}
}
int diam[N];
int find_set(int x) {
if (x != p[x]) {
p[x] = find_set(p[x]);
}
return p[x];
}
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
g[i].clear();
}
for (int i = 0; i < m; i++) {
int foo, bar;
scanf("%d %d", &foo, &bar);
g[foo].push_back(bar);
g[bar].push_back(foo);
}
for (int i = 1; i <= n; i++) {
was[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (was[i] == 0) {
ROOT = i;
MAX = -1;
CITY = 0;
dfs(i, 0, 0);
int to = CITY;
MAX = -1;
CITY = 0;
dfs(to, 0, 1);
diam[i] = MAX;
}
}
while (q--) {
int com;
scanf("%d", &com);
if (com == 1) {
int x;
scanf("%d", &x);
printf("%d\n", diam[find_set(x)]);
} else {
int x, y;
scanf("%d %d", &x, &y);
if (q % 7 <= 4) {
swap(x, y);
}
x = find_set(x);
y = find_set(y);
if (x == y) {
continue;
}
p[x] = y;
int old = (diam[x] > diam[y]) ? diam[x] : diam[y];
diam[y] = ((diam[y] + 1) / 2) + 1 + ((diam[x] + 1) / 2);
if (old > diam[y]) {
diam[y] = old;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 1e5 + 100;
queue<int> q;
vector<int> adj[maxn];
int d[maxn], mark[maxn], comp, far, dist, now, u[maxn];
int qotr[maxn];
int par[maxn], dis[maxn];
inline int make_set(int x) {
par[x] = x;
dis[x] = 0;
comp++;
}
inline int findpar(int x) {
return par[x] = (par[x] == x ? x : findpar(par[x]));
}
inline bool merge(int x, int y) {
y = findpar(y);
x = findpar(x);
if (x == y) return false;
comp--;
if (dis[x] < dis[y]) swap(x, y);
par[y] = x;
dis[x] += dis[y];
return true;
}
void Dfs(int v, int s, int pr) {
par[v] = now;
if (s > dist) {
far = v;
dist = s;
}
u[v] = 1;
for (int i : adj[v]) {
if (i != pr) Dfs(i, s + 1, v);
}
}
int n, m, qu;
inline int read_input() {
scanf("%d %d %d", &n, &m, &qu);
for (int i = 1; i <= n; i++) make_set(i);
for (int i = 0, u, v; i < m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
merge(u, v);
}
return 1;
}
int main() {
read_input();
for (int i = 1; i <= n; i++) {
if (!u[i]) {
par[i] = i;
far = 0, dist = -1;
Dfs(i, 0, i);
now = i;
dist = -1;
Dfs(far, 0, far);
qotr[i] = max(qotr[i], dist);
}
}
for (int i = 1, a, b, c; i <= qu; i++) {
scanf("%d", &a);
if (a == 1) {
scanf("%d", &b);
int ans = qotr[findpar(b)];
printf("%d\n", ans);
} else {
scanf("%d %d", &b, &c);
b = findpar(b);
c = findpar(c);
if (b == c) continue;
int cnt = max(qotr[b],
max(qotr[c], 1 + ((qotr[c] + 1) / 2) + (qotr[b] + 1) / 2));
merge(b, c);
qotr[b] = cnt;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int l[300005];
int d[300005];
int n, m, q;
vector<int> adj[300005];
int gl(int i) { return l[i] == i ? i : l[i] = gl(l[i]); }
int seen[300005];
int dst[300005];
int S;
int gf(int i) {
S++;
queue<int> q;
q.push(i);
seen[i] = S;
dst[i] = 0;
int f;
while (!q.empty()) {
f = q.front();
q.pop();
for (int j = (0); j < (int(adj[f].size())); j++)
if (seen[adj[f][j]] != S) {
seen[adj[f][j]] = S;
dst[adj[f][j]] = dst[f] + 1;
q.push(adj[f][j]);
}
}
return f;
}
void fd(int i) { d[i] = dst[gf(gf(i))]; }
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = (0); i < (n); i++) {
l[i] = i;
d[i] = -1;
}
for (int i = (0); i < (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
l[gl(a)] = gl(b);
}
for (int i = (0); i < (n); i++)
if (d[gl(i)] == -1) fd(gl(i));
for (int i = (0); i < (q); i++) {
int t, a, b;
scanf("%d %d", &t, &a);
if (t == 1)
printf("%d\n", d[gl(a - 1)]);
else {
scanf("%d", &b);
a--;
b--;
a = gl(a);
b = gl(b);
if (a != b) {
d[a] = ((d[a]) > (((d[b]) > ((d[a] + 1) / 2 + 1 + (d[b] + 1) / 2)
? (d[b])
: ((d[a] + 1) / 2 + 1 + (d[b] + 1) / 2)))
? (d[a])
: (((d[b]) > ((d[a] + 1) / 2 + 1 + (d[b] + 1) / 2)
? (d[b])
: ((d[a] + 1) / 2 + 1 + (d[b] + 1) / 2))));
l[b] = a;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int par[int(1e5) * 4], size[int(1e5) * 4], com[int(1e5) * 4];
vector<int> adj[int(1e5) * 4];
bool flag[int(1e5) * 4];
bool flag1[int(1e5) * 4];
int n, m, q, mx, node;
void dfs(int a, int k) {
flag[a] = true;
if (k > mx) {
mx = k;
node = a;
}
for (int i = 0; i < adj[a].size(); i++) {
if (!flag[adj[a][i]]) dfs(adj[a][i], k + 1);
}
}
void dfs1(int a, int k) {
flag1[a] = true;
if (k > mx) {
mx = k;
node = a;
}
for (int i = 0; i < adj[a].size(); i++) {
if (!flag1[adj[a][i]]) dfs1(adj[a][i], k + 1);
}
}
int find(int a) {
if (par[a] == a) return a;
return find(par[a]);
}
void merge(int a, int b) {
int pa = find(a), push_back = find(b);
if (pa == push_back) return;
if (size[pa] > size[push_back]) {
par[push_back] = pa;
size[pa] += size[push_back];
} else {
par[pa] = push_back;
size[push_back] += size[pa];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
par[i] = i;
size[i] = 1;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
merge(a, b);
}
for (int i = 1; i <= n; i++) {
if (!flag[i]) {
node = i;
dfs(i, 0);
mx = 0;
dfs1(node, 0);
com[find(i)] = mx;
mx = 0;
}
}
for (int i = 0; i < q; i++) {
int a;
cin >> a;
if (a == 1) {
int b;
cin >> b;
cout << com[find(b)] << endl;
} else {
int b, c;
cin >> b >> c;
int push_back = find(b), pc = find(c);
if (push_back != pc) {
int t = max(com[push_back],
max(com[pc], int(ceil(float(com[push_back]) / 2) +
ceil(float(com[pc]) / 2) + 1)));
merge(b, c);
com[find(b)] = t;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()) {
v.assign(a, vector<T>(b, t));
}
template <class F, class T>
void convert(const F &f, T &t) {
stringstream ss;
ss << f;
ss >> t;
}
struct UF {
vector<int> par;
UF(int m) : par(m + 1) {
for (int i = 1; i <= m; ++i) {
par[i] = i;
}
}
int find(int x) { return x != par[x] ? par[x] = find(par[x]) : x; }
void unite(int x, int y) { par[find(x)] = find(y); }
};
vector<vector<int> > G;
pair<int, int> dfs(int u, int p) {
pair<int, int> r(0, u);
for (int v : G[u]) {
if (v != p) {
pair<int, int> t = dfs(v, u);
++t.first;
r = max(r, t);
}
}
return r;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
UF uf(n);
G.resize(n + 1);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
uf.unite(a, b);
G[a].push_back(b);
G[b].push_back(a);
}
vector<int> ds(n + 1);
for (int i = 1; i <= n; ++i) {
if (uf.find(i) == i) {
pair<int, int> r = dfs(i, -1);
pair<int, int> t = dfs(r.second, -1);
ds[i] = t.first;
}
}
for (int i = 0; i < q; ++i) {
int tp, x, y;
scanf("%d%d", &tp, &x);
if (tp == 1) {
int r = ds[uf.find(x)];
printf("%d\n", r);
} else {
scanf("%d", &y);
x = uf.find(x);
y = uf.find(y);
if (x != y) {
int a = ds[x], b = ds[y];
uf.unite(x, y);
int z = uf.find(x);
ds[z] = max({a, b, (a + 1) / 2 + (b + 1) / 2 + 1});
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int par[300050];
int rk[300050];
int dia[300050];
int vis[300050];
inline int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void _merg(int x, int y) {
int a = find(x);
int b = find(y);
if (a == b) return;
if (rk[b] > rk[a]) swap(a, b);
par[b] = a;
rk[a] += rk[b];
}
void merg(int x, int y) {
int a = find(x);
int b = find(y);
if (a == b) return;
if (rk[b] > rk[a]) swap(a, b);
par[b] = a;
rk[a] += rk[b];
int r1 = dia[a] + 1;
int r2 = dia[b] + 1;
r1 = r1 / 2;
r2 = r2 / 2;
r1 = r1 + r2 + 1;
dia[a] = max(dia[a], r1);
dia[a] = max(dia[a], dia[b]);
}
vector<int> gr[300050];
void init() {
for (int i = 0; i < 300050; i++) {
par[i] = i;
rk[i] = 1;
dia[i] = 0;
}
}
int maxi, maxiV;
void dfs(int v, int d, int p) {
if (d > maxi) {
maxi = d;
maxiV = v;
}
for (int to : gr[v]) {
if (to != p) dfs(to, d + 1, v);
}
}
int calcd(int v) {
maxi = -1;
dfs(v, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
int32_t main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int x, y;
init();
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
gr[x].push_back(y);
gr[y].push_back(x);
_merg(x, y);
}
for (int i = 1; i <= n; i++) {
int re = find(i);
if (vis[re] == 0) {
vis[re] = 1;
dia[re] = calcd(re);
}
}
int t;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &x);
printf("%d\n", dia[find(x)]);
} else {
scanf("%d%d", &x, &y);
merg(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653689793238460;
const long long inf = 0x3f3f3f3f3f3f;
const int N = 2e5 + 5;
const int pr = 31;
using ld = long double;
int mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int fact(int n) {
int res = 1;
for (int i = 2; i <= n; i++) res = res * i % mod;
return res % mod;
}
int ncr(int n, int r) { return fact(n) / (fact(r) * fact(n - r)); }
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (1ll * res * x) % p;
y = y >> 1;
x = (1ll * x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long ncrm(unsigned long long n, int r, int p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[2043];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
unsigned int setbit(long long n) {
unsigned long long count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int sub(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return i;
}
return -1;
}
bool subse(string str1, string str2) {
int j = 0;
for (int i = 0; i < str2.length() && j < str1.length(); i++)
if (str1[j] == str2[i]) j++;
return (j == str1.length());
}
unsigned P2(unsigned x) {
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
void phi_1n(int n) {
vector<int> phi(n + 1);
phi[0] = 0;
phi[1] = 1;
for (int i = 2; i <= n; i++) phi[i] = i;
for (int i = 2; i <= n; i++) {
if (phi[i] == i) {
for (int j = i; j <= n; j += i) phi[j] -= phi[j] / i;
}
}
}
long long largestpower(long long n, long long p) {
long long x = 0;
long long curr = n;
while (curr) {
curr /= p;
x += curr;
}
return x;
}
struct DSU {
vector<int> e;
DSU(int N) { e = vector<int>(N, -1); }
int get(int x) { return e[x] < 0 ? x : e[x] = get(e[x]); }
bool same_set(int a, int b) { return get(a) == get(b); }
int size(int x) { return -e[get(x)]; }
bool unite(int x, int y) {
x = get(x), y = get(y);
if (x == y) return false;
if (e[x] > e[y]) swap(x, y);
e[x] += e[y];
e[y] = x;
return true;
}
};
const long long INF = 1e18;
int n, m, q;
bool used[300005];
int p[300005], sz[300005], dia[300005];
int maxi, maxiV;
vector<int> a[300005];
void dfs(int v, int depth, int p) {
if (depth > maxi) {
maxi = depth;
maxiV = v;
}
for (auto u : a[v]) {
if (u != p) {
dfs(u, depth + 1, v);
}
}
}
int finddia(int v) {
maxi = -1;
dfs(v, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
void init() {
for (int i = (int)1; i <= (int)n; ++i) {
p[i] = i;
sz[i] = 1;
dia[i] = 0;
}
}
int getset(int v) {
if (p[v] == v) return v;
return p[v] = getset(p[v]);
}
void unionset1(int x, int y) {
x = getset(x);
y = getset(y);
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
p[x] = y;
}
int rad(int v) { return (dia[v] + 1) / 2; }
void unionset2(int x, int y) {
x = getset(x);
y = getset(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
p[x] = y;
dia[y] = max(rad(x) + rad(y) + 1, max(dia[x], dia[y]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> q;
init();
for (int i = 0; i < (int)m; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
unionset1(x, y);
}
for (int i = (int)1; i <= (int)n; ++i) {
int pp = getset(i);
if (!used[pp]) {
used[pp] = 1;
dia[pp] = finddia(i);
}
}
while (q--) {
int d;
cin >> d;
if (d == 2) {
int x, y;
cin >> x >> y;
unionset2(x, y);
} else {
int x;
cin >> x;
cout << dia[getset(x)] << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline int read(T& x) {
x = 0;
char c = getchar(), f = 1;
while (c > '9' || c < '0') {
if (c == '-') f = -1;
if (c == -1) return -1;
c = getchar();
}
while (c <= '9' && c >= '0')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x *= f;
return 1;
}
template <typename T, typename... Args>
inline int read(T& x, Args&... args) {
return read(x) + read(args...);
}
template <typename T>
inline int write(T x) {
if (x < 0) return putchar('-') & write((~x) + 1);
if (x / 10) return write(x / 10) & putchar(x % 10 | 48);
return putchar(x | 48);
}
template <typename T>
inline int write(T x, char c) {
return write(x) + putchar(c);
}
struct edge {
int v, nxt;
inline edge() {}
} e[300005 << 1];
int f[300005], tot;
inline void addEdge(int u, int v) {
tot++, e[tot].v = v, e[tot].nxt = f[u], f[u] = tot;
}
bool vis[300005];
inline pair<int, int> dfs(int x) {
if (vis[x]) return make_pair(-1, -1);
vis[x] = 1;
pair<int, int> ans(0, x);
for (int i = f[x]; i; i = e[i].nxt) {
pair<int, int> tmp = dfs(e[i].v);
tmp.first++;
ans = ((ans) > (tmp) ? (ans) : (tmp));
}
vis[x] = 0;
return ans;
}
bool dd[300005];
inline int doftree(int x) {
pair<int, int> t = dfs(x);
pair<int, int> tt = dfs(t.second);
return tt.first;
}
int fa[300005];
inline void init() {
for (int i = 1; i < 300005; i++) fa[i] = i;
}
inline int findSet(int x) {
while (x != fa[x]) x = fa[x] = fa[fa[x]];
return x;
}
inline void unionSet(int x, int y) { fa[findSet(x)] = findSet(y); }
inline bool same(int x, int y) { return findSet(x) == findSet(y); }
int n, m, q;
int d[300005];
signed main() {
read(n, m, q);
init();
for (int i = 1, u, v; i <= m; i++) {
read(u, v);
addEdge(u, v), addEdge(v, u);
unionSet(u, v);
}
for (int i = 1; i <= n; i++) {
if (!dd[findSet(i)])
d[i] = doftree(i), d[findSet(i)] = d[i];
else
d[i] = d[findSet(i)];
dd[findSet(i)] = 1;
}
for (int i = 1; i <= q; i++) {
int ty;
read(ty);
int x, y;
if (ty == 1) {
read(x);
write(d[findSet(x)], '\n');
}
if (ty == 2) {
read(x, y);
if (same(x, y)) continue;
int dx = d[findSet(x)], dy = d[findSet(y)];
unionSet(x, y);
d[findSet(x)] = ((((dx + 1) >> 1) + ((dy + 1) >> 1) + 1) >
(((dx) > (dy) ? (dx) : (dy)))
? (((dx + 1) >> 1) + ((dy + 1) >> 1) + 1)
: (((dx) > (dy) ? (dx) : (dy))));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
const int N = 3e5 + 11, mod = 1e9 + 7, mod2 = 998244353;
const int MAX = 1e5 + 11;
const int INF1 = 2e9 + 11;
const ll INF2 = 2e18 + 11;
const double INF3 = 1e8 + 11;
const int base = 500;
const int P = 31;
const int dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
const int dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
const double EPS = 1e-4;
const double PI = acos(-1.0);
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m, q, pr[N], sz[N], r;
vi g[N];
int f(int x) { return (pr[x] == x ? x : pr[x] = f(pr[x])); }
int main() {
if (fopen("threesum"
".in",
"r"))
freopen(
"threesum"
".in",
"r", stdin),
freopen(
"threesum"
".out",
"w", stdout);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i += 1) pr[i] = i;
for (int i = 1; i <= m; i += 1) {
int u, v;
cin >> u >> v;
g[u].emplace_back(v);
g[v].emplace_back(u);
u = f(u);
v = f(v);
if (u != v) pr[u] = v;
}
int mx = 0;
function<void(int, int, int)> dfs1 = [&](int v, int pr, int d) {
if (d > mx) {
mx = d;
r = v;
}
for (int to : g[v]) {
if (to != pr) {
dfs1(to, v, d + 1);
}
}
};
for (int i = 1; i <= n; i += 1) {
if (!sz[f(i)]) {
mx = 0;
r = i;
dfs1(r, r, 0);
mx = 0;
dfs1(r, r, 0);
r = f(r);
sz[r] = mx;
}
}
while (q--) {
int type, x, y;
cin >> type >> x;
if (type == 1)
cout << sz[f(x)] << "\n";
else {
cin >> y;
x = f(x);
y = f(y);
if (x == y) continue;
int a = sz[x], b = sz[y];
sz[x] = max((sz[x] + 1) / 2 + (sz[y] + 1) / 2 + 1, max(a, b));
pr[y] = x;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
const int N = 300007;
int n, m, q, par[N], size[N], len[N];
vector<int> G[N];
int dist[N];
int get(int u) { return par[u] == u ? u : par[u] = get(par[u]); }
void unite(int u, int v, bool flag = false) {
u = get(u);
v = get(v);
if (u == v) return;
if (size[u] < size[v]) swap(u, v);
size[u] += size[v];
par[v] = u;
if (flag)
len[u] = max(len[u], max(len[v], 1 + (len[u] + 1) / 2 + (len[v] + 1) / 2));
}
int bfs(int u, int &v, vector<int> &mas) {
dist[u] = 0;
queue<int> Q;
Q.push(u);
int maxi = -1;
while (!Q.empty()) {
u = Q.front();
Q.pop();
mas.push_back(u);
if (dist[u] > maxi) {
maxi = dist[u];
v = u;
}
for (int i = 0; i < (int)(G[u]).size(); ++i) {
int to = G[u][i];
if (dist[to] == -1) {
dist[to] = dist[u] + 1;
Q.push(to);
}
}
}
return maxi;
}
void solve() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
par[i] = i;
size[i] = 1;
dist[i] = -1;
}
for (int i = 1; i <= n; ++i) {
if (dist[i] == -1) {
vector<int> mas;
int u, v, d;
d = bfs(i, u, mas);
for (int j = 0; j < (int)(mas).size(); ++j) dist[mas[j]] = -1;
mas.clear();
d = bfs(u, v, mas);
for (int j = 0; j < (int)(mas).size(); ++j) unite(i, mas[j]);
len[get(i)] = d;
}
}
while (q--) {
int ty, u, v;
scanf("%d", &ty);
if (ty == 1) {
scanf("%d", &u);
printf("%d\n", len[get(u)]);
} else {
scanf("%d%d", &u, &v);
unite(u, v, true);
}
}
}
int main() {
cerr << fixed;
cerr.precision(2);
cout << fixed;
cout.precision(9);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 1000000007) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
struct node {
int p, sz = 0, lp = 0, h = 0;
} arr[300005];
int h[300005], h1[300005], h2[300005];
void init(int n) {
for (int i = 1; i <= n; i++) arr[i].p = i;
}
int root(int x) {
while (x != arr[x].p) x = arr[arr[x].p].p;
return x;
}
void wu(int x, int y) {
int rx = root(x), ry = root(y);
if (rx == ry) return;
if (arr[rx].sz < arr[ry].sz) {
arr[ry].sz += arr[rx].sz;
arr[rx].p = ry;
arr[ry].lp = max({arr[rx].lp, arr[ry].lp, arr[rx].h + arr[ry].h + 1});
int h1 = max(arr[rx].h, arr[ry].h + 1);
int h2 = max(arr[ry].h, arr[rx].h + 1);
arr[ry].h = min(h1, h2);
} else {
arr[rx].sz += arr[ry].sz;
arr[ry].p = rx;
arr[rx].lp = max({arr[rx].lp, arr[ry].lp, arr[rx].h + arr[ry].h + 1});
int h1 = max(arr[rx].h, arr[ry].h + 1);
int h2 = max(arr[ry].h, arr[rx].h + 1);
arr[rx].h = min(h1, h2);
}
}
int v[300005];
vector<int> ed[300005];
int l = 0, hp = 4000004;
void dfs(int x, int p) {
if (v[x]) return;
v[x] = 1;
arr[x].p = p;
arr[p].sz++;
long long a = -1, b = -1;
for (auto it : ed[x]) {
dfs(it, p);
if (h1[it] > a) {
b = a;
a = h1[it];
} else if (h1[it] > b)
b = h1[it];
}
h1[x] = a + 1;
h2[x] = b + 1;
l = max(l, h1[x] + h2[x]);
}
void dfs1(int x, int p, int ha) {
if (v[x] == 2) return;
v[x] = 2;
int hb = -1, hc = -1;
for (auto it : ed[x]) {
if (it == p) continue;
if (h1[it] > hb) {
hc = hb;
hb = h1[it];
} else if (h1[it] > hc)
hc = h1[it];
}
h[x] = max(ha + 1, hb + 1);
hp = min(hp, h[x]);
ha++;
for (auto it : ed[x]) {
int t = (hb != h1[it] ? hb + 1 : hc + 1);
t = max(t, ha);
dfs1(it, x, t);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
init(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
ed[x].push_back(y);
ed[y].push_back(x);
}
for (int i = 0; i <= n; i++) {
h1[i] = -1;
h2[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (v[i]) continue;
l = 0;
hp = 4000004;
dfs(i, i);
dfs1(i, 0, -1);
arr[i].lp = l;
arr[i].h = hp;
}
while (q--) {
int c;
cin >> c;
if (c == 1) {
int x;
cin >> x;
cout << arr[root(x)].lp << '\n';
} else {
int x, y;
cin >> x >> y;
wu(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void si(T &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c<48 | c> 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
long long bigmod(long long p, long long e, long long M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return ret;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long modinverse(long long a, long long M) { return bigmod(a, M - 2, M); }
void io() { freopen("/Users/MyMac/Desktop/in.txt", "r", stdin); }
const int N = 3e5 + 5;
int d[N], P[N];
int F[N];
int Tree[N];
bool vis[N];
int dia[N];
vector<int> Nodes[N], G[N];
int col = 0;
void dfs(int u, int p = -1) {
vis[u] = 1;
Nodes[col].push_back((u));
for (auto a : G[u])
if (a != p) {
d[a] = 1 + d[u];
P[a] = u;
dfs(a, u);
}
}
int f(int u) {
if (F[u] == u)
return u;
else
return F[u] = f(F[u]);
}
int main() {
int n, m, q;
si(n);
si(m);
si(q);
for (int i = 0; i < (m); i++) {
int a, b;
si(a);
si(b);
G[a].push_back((b));
G[b].push_back((a));
}
for (int i = 1; i <= n; i++) F[i] = i, dia[i] = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
d[i] = 0;
dfs(i);
int root = -1, iM = -1;
for (auto a : Nodes[col]) {
if (d[a] > iM) {
iM = d[a];
root = a;
}
d[a] = 0;
}
Nodes[col].clear();
d[root] = 0;
dfs(root);
iM = -1;
int end = -1;
for (auto a : Nodes[col]) {
if (d[a] > iM) {
end = a;
iM = d[a];
}
}
root = end;
for (int i = 0; i < d[end] / 2; i++) root = P[root];
dia[col] = iM;
for (auto a : Nodes[col]) F[a] = root, Tree[a] = col;
col++;
}
}
while (q--) {
int t;
si(t);
if (t == 1) {
int x;
si(x);
int u = f(x);
printf("%d\n", dia[Tree[u]]);
} else {
int x, y;
si(x);
si(y);
int u = f(x), v = f(y);
if (u != v) {
F[u] = v;
dia[Tree[v]] =
((dia[Tree[v]]) >
((dia[Tree[u]] + 1) / 2 + (dia[Tree[v]] + 1) / 2 + 1)
? (dia[Tree[v]])
: ((dia[Tree[u]] + 1) / 2 + (dia[Tree[v]] + 1) / 2 + 1));
dia[Tree[v]] =
((dia[Tree[v]]) > (dia[Tree[u]]) ? (dia[Tree[v]]) : (dia[Tree[u]]));
Tree[u] = Tree[v];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mo(long long a) { return a % (long long)(1e9 + 7); }
long long po(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res % p;
}
vector<vector<long long>> g;
long long n, m, q;
struct dsu {
int n;
vector<long long> a, rank, dia;
void init(long long si) {
n = si;
a.resize(n);
rank.resize(n);
dia.resize(n);
for (long long i = 0; i < n; i++) {
rank[i] = 1;
a[i] = i;
dia[i] = 0;
}
}
long long get(long long i) { return a[i] = ((i == a[i]) ? i : get(a[i])); }
void unio(long long i, long long j) {
long long x = get(i), y = get(j);
if (x == y) return;
if (rank[x] == rank[y]) rank[x]++;
if (rank[y] > rank[x]) swap(x, y);
a[y] = x;
dia[x] = max({dia[x], dia[y], (dia[x] + 1) / 2 + (dia[y] + 1) / 2 + 1});
}
};
vector<long long> vis, dist, vis2;
long long root;
dsu ds;
void dfs(long long par, long long is) {
vis[par] = 1;
if (dist[root] < dist[par]) root = par;
for (long long e : g[par]) {
if (!vis[e]) {
ds.unio(par, e);
dist[e] = dist[par] + 1;
dfs(e, is);
}
}
if (is) vis[par] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> q;
g.assign(n, {});
vis.assign(n, 0);
dist.assign(n, 0);
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
ds.init(n);
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
root = i;
dist[root] = 0;
dfs(i, 1);
dist[root] = 0;
dfs(root, 0);
ds.dia[ds.get(i)] = dist[root];
}
}
while (q--) {
long long op;
cin >> op;
if (op == 1) {
long long x;
cin >> x;
x--;
cout << ds.dia[ds.get(x)] << "\n";
} else {
long long x, y;
cin >> x >> y;
x--;
y--;
ds.unio(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int parents[300005];
int longest[300005];
int ra[300005];
bool visited[300005];
vector<int> nodes[300005];
int fi(int x) {
if (parents[x] == x) return x;
return parents[x] = fi(parents[x]);
}
bool uni(int x, int y) {
int px = fi(x);
int py = fi(y);
if (px == py) return false;
if (ra[px] > ra[py]) {
parents[py] = px;
} else if (ra[px] < ra[py]) {
parents[px] = py;
} else {
ra[px]++;
parents[py] = px;
}
return 1;
}
pair<int, int> dfs1(int x) {
if (visited[x]) return {-10e5, -1};
visited[x] = true;
pair<int, int> temp;
temp = {-1, x};
int s = nodes[x].size();
for (int i = 0; i < s; i++) {
pair<int, int> tt = dfs1(nodes[x][i]);
if (tt.second != -1 && tt.first > temp.first) temp = tt;
}
visited[x] = false;
return {temp.first + 1, temp.second};
}
int dfs2(int x, int y) {
if (visited[x]) return -10e5;
if (x == y) return 0;
visited[x] = true;
int temp = 0;
int s = nodes[x].size();
for (int i = 0; i < s; i++) {
temp = max(temp, dfs2(nodes[x][i], y) + 1);
}
visited[x] = false;
return temp;
}
int main() {
int q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i <= n; i++) {
parents[i] = i;
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
uni(x, y);
nodes[x].push_back(y);
nodes[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (parents[i] == i) {
int tx = fi(i);
pair<int, int> ta = dfs1(tx);
pair<int, int> tb = dfs1(ta.second);
longest[tx] = dfs2(ta.second, tb.second);
}
}
for (int i = 0; i < q; i++) {
int x, y, z;
scanf("%d", &x);
if (x == 1) {
scanf("%d", &y);
cout << longest[fi(y)] << endl;
} else {
scanf("%d%d", &y, &z);
int ta = fi(y), tb = fi(z);
if (!uni(y, z)) {
continue;
}
int tx = fi(y);
longest[tx] =
max(longest[ta] - longest[ta] / 2 + longest[tb] - longest[tb] / 2 + 1,
max(longest[ta], longest[tb]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 90000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
const int MX = 301000;
int vis[MX], dp[MX], dis[MX], par[MX];
vector<int> store, adjList[MX];
int findSet(int x) {
if (x != par[x]) return par[x] = findSet(par[x]);
return x;
}
void mergeSet(int x, int y) {
x = findSet(x);
y = findSet(y);
if (x == y) return;
par[y] = x;
;
dp[x] = max(max(dp[x], dp[y]), (dp[x] + 1) / 2 + (dp[y] + 1) / 2 + 1);
;
return;
}
void dfs(int u, int setnum, int d) {
par[u] = setnum;
vis[u] = true;
dis[u] = d;
store.push_back(u);
for (auto v : adjList[u]) {
if (vis[v]) continue;
dfs(v, setnum, d + 1);
}
}
void func(int u) {
store.clear();
int ret = 0, maxindex = u;
dfs(u, u, 0);
for (auto it : store) {
if (dis[it] > dis[maxindex]) maxindex = it;
}
for (auto it : store) vis[it] = false, dis[it] = 0;
dfs(maxindex, u, 0);
for (auto it : store) ret = max(dis[it], ret);
dp[u] = ret;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
adjList[a - 1].push_back(b - 1);
adjList[b - 1].push_back(a - 1);
}
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
func(i);
}
}
while (q--) {
int d;
scanf("%d", &d);
if (d == 1) {
int x;
scanf("%d", &x);
;
printf("%d\n", dp[findSet(x - 1)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
mergeSet(x - 1, y - 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
bool v[N];
int n, m, q, x, y, f[N], g[N], d[N], t;
vector<int> a[N];
int F(int x) {
if (f[x] == x) return x;
return f[x] = F(f[x]);
}
void D(int k) {
f[k] = x;
for (int i = 0; i < a[k].size(); i++)
if (!f[a[k][i]])
D(a[k][i]), g[x] = max(g[x], d[k] + d[a[k][i]] + 1),
d[k] = max(d[k], d[a[k][i]] + 1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
while (m-- && cin >> x >> y) a[x].push_back(y), a[y].push_back(x);
for (int i = 1; i <= n; i++)
if (!f[i]) x = i, D(i);
while (q-- && cin >> t >> x)
if (t == 1)
cout << g[F(x)] << '\n';
else {
cin >> y;
x = F(x), y = F(y);
if (x != y)
f[y] = x,
g[x] = max(max(g[x], g[y]), (g[x] + 1) / 2 + (g[y] + 1) / 2 + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[300050];
int rk[300050];
int dia[300050];
int vis[300050];
inline int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void _merg(int x, int y) {
int a = find(x);
int b = find(y);
if (a == b) return;
if (rk[b] > rk[a]) swap(a, b);
par[b] = a;
rk[a] += rk[b];
}
void merg(int x, int y) {
int a = find(x);
int b = find(y);
if (a == b) return;
if (rk[b] > rk[a]) swap(a, b);
par[b] = a;
rk[a] += rk[b];
int r1 = dia[a] + 1;
int r2 = dia[b] + 1;
r1 = r1 / 2;
r2 = r2 / 2;
r1 = r1 + r2 + 1;
dia[a] = max(dia[a], r1);
dia[a] = max(dia[a], dia[b]);
}
vector<int> gr[300050];
void init() {
for (int i = 0; i < 300050; i++) {
par[i] = i;
rk[i] = 1;
dia[i] = 0;
}
}
int maxi, maxiV;
void dfs(int v, int d, int p) {
if (d > maxi) {
maxi = d;
maxiV = v;
}
for (int to : gr[v]) {
if (to != p) dfs(to, d + 1, v);
}
}
int calcd(int v) {
maxi = -1;
dfs(v, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
int32_t main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int x, y;
init();
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
gr[x].push_back(y);
gr[y].push_back(x);
_merg(x, y);
}
for (int i = 1; i <= n; i++) {
int re = find(i);
if (vis[re] == 0) {
vis[re] = 1;
dia[re] = calcd(re);
}
}
int t;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &x);
printf("%d\n", dia[find(x)]);
} else {
scanf("%d%d", &x, &y);
merg(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> Edge[300005];
int Par[300005], Ht[300005];
void Swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int find(int x) {
if (x != Par[x]) return Par[x] = find(Par[x]);
return x;
}
void set_union(int x, int y) {
int parx = find(x);
int pary = find(y);
if (parx == pary) return;
if (Ht[parx] < Ht[pary]) Swap(&parx, &pary);
Ht[parx] = max(Ht[parx], max(Ht[pary], (int)(ceil(Ht[parx] / 2.0) +
ceil(Ht[pary] / 2.0) + 1)));
Par[pary] = Par[parx];
}
int MaxHt;
bool vis[300005];
int dfs(int k) {
int l = Edge[k].size(), M1 = 0, M2 = 0;
for (int i = 0; i < l; i++) {
if (vis[Edge[k][i]] == 0) {
vis[Edge[k][i]] = 1;
int M = dfs(Edge[k][i]);
if (M >= M1) {
M2 = M1;
M1 = M;
} else if (M > M2)
M2 = M;
}
}
MaxHt = max(MaxHt, M1 + M2);
return M1 + 1;
}
void Components(int n) {
for (int i = 1; i <= n; i++) {
MaxHt = 0;
if (vis[i] == 0) {
vis[i] = 1;
dfs(i);
Ht[find(i)] = MaxHt;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i < 300005; i++) Par[i] = i;
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (find(a) == find(b)) continue;
Edge[a].push_back(b);
Edge[b].push_back(a);
set_union(a, b);
}
Components(n);
while (q--) {
int a;
cin >> a;
if (a == 1) {
int x;
cin >> x;
cout << Ht[find(x)] << "\n";
} else {
int x, y;
cin >> x >> y;
set_union(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Q;
int type, a, b;
int uf[300005];
int len[300005];
int find(int n) { return n == uf[n] ? n : uf[n] = find(uf[n]); }
void link(int a, int b) {
int fa = find(a);
int fb = find(b);
if (fa == fb) return;
if (len[fa] < len[fb]) swap(fa, fb);
len[fa] =
max(len[fa] / 2 + len[fa] % 2 + 1 + len[fb] / 2 + len[fb] % 2, len[fa]);
uf[fb] = fa;
}
vector<int> T[300005];
int bio[300005];
int dad[300005];
int d[300005];
vector<int> visited;
queue<int> q;
int bfs(int n) {
visited.clear();
q.push(n);
d[n] = 1;
while (!q.empty()) {
int c = q.front();
q.pop();
visited.push_back(c);
for (auto m : T[c]) {
if (d[m]) continue;
d[m] = d[c] + 1;
dad[m] = c;
q.push(m);
}
}
int best = n;
for (auto v : visited)
if (d[v] > d[best]) best = v;
for (auto v : visited) d[v] = 0, bio[v] = 1;
return best;
}
vector<int> path;
void get_center(int n) {
int a = bfs(n);
int b = bfs(a);
path.clear();
path.push_back(b);
while (b != a) {
b = dad[b];
path.push_back(b);
}
int center = path[path.size() / 2];
for (auto v : visited) uf[v] = center;
len[center] = path.size() - 1;
}
int main(void) {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= N; ++i) uf[i] = i;
for (int i = 0; i < M; ++i) {
scanf("%d%d", &a, &b);
T[a].push_back(b);
T[b].push_back(a);
}
for (int i = 1; i <= N; ++i) {
if (bio[i]) continue;
get_center(i);
}
for (int i = 0; i < Q; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d", &a);
printf("%d\n", len[find(a)]);
} else {
scanf("%d%d", &a, &b);
link(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<vector<int> > v;
int sz[300000];
int clr[300000];
int atMx, curMx;
int find(int u) {
if (u == clr[u]) return u;
return clr[u] = find(clr[u]);
}
void dfs(int u, int P, int d) {
if (d > curMx) {
curMx = d;
atMx = u;
}
for (int i = 0; i < v[u].size(); i++)
if (v[u][i] != P) dfs(v[u][i], u, d + 1);
}
int main() {
cin >> n >> m >> q;
v.resize(n);
memset(sz, -1, sizeof(sz));
for (int i = 0; i < n; i++) clr[i] = i;
for (int i = 0, a, b; i < m; i++) {
scanf("%d%d", &a, &b);
--a;
--b;
v[a].push_back(b);
v[b].push_back(a);
clr[find(a)] = find(b);
}
for (int i = 0; i < n; i++)
if (sz[find(i)] == -1) {
curMx = -1;
dfs(find(i), -1, 0);
curMx = -1;
dfs(atMx, -1, 0);
sz[find(i)] = curMx;
}
while (q--) {
int ty, x, y;
scanf("%d", &ty);
if (ty == 2) {
scanf("%d%d", &x, &y);
--x;
--y;
x = find(x);
y = find(y);
if (x != y) {
int tmp;
tmp = (sz[x] + 1) / 2 + (sz[y] + 1) / 2 + 1;
tmp = max(tmp, sz[x]);
sz[y] = max(sz[y], tmp);
clr[x] = y;
}
} else {
scanf("%d", &x);
--x;
printf("%d\n", sz[find(x)]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
struct DSU {
std::vector<int> s;
DSU(const int& _n) { s.assign(_n, -1); }
int find(const int& i) { return s[i] < 0 ? i : (s[i] = find(s[i])); }
bool join(int a, int b) {
if ((a = find(a)) == (b = find(b))) return false;
if (s[a] == s[b]) s[a]--;
if (s[a] <= s[b])
s[b] = a;
else
s[a] = b;
return true;
}
};
const static int INF = 0x3f3f3f3f;
static inline void setio(void);
const int MAX_N = 300001;
int dia[MAX_N], dist[MAX_N];
std::vector<int> gr[MAX_N];
std::vector<int> comps[MAX_N];
DSU sets(MAX_N);
void get_dia(const int& start) {
for (const auto& node : comps[start]) dist[node] = INF;
dist[start] = 0;
std::queue<int> order;
order.push(start);
while (!order.empty()) {
int cur = order.front();
order.pop();
for (const auto& nei : gr[cur]) {
if (dist[nei] > 1 + dist[cur]) {
dist[nei] = 1 + dist[cur];
order.push(nei);
}
}
}
int max = start, md = dist[start];
for (const auto& node : comps[start]) {
if (dist[node] > md) {
max = node;
md = dist[node];
}
dist[node] = INF;
}
dist[max] = 0;
order.push(max);
while (!order.empty()) {
int cur = order.front();
order.pop();
for (const auto& nei : gr[cur]) {
if (dist[nei] > 1 + dist[cur]) {
dist[nei] = 1 + dist[cur];
order.push(nei);
}
}
}
md = 0;
for (const auto& node : comps[start]) {
md = std::max(md, dist[node]);
}
dia[start] = md;
}
void merge(const int& a, const int& b) {
int ahead = sets.find(a), bhead = sets.find(b);
if (!sets.join(ahead, bhead)) return;
int newhead = sets.find(ahead);
if (newhead != ahead) {
comps[newhead].insert(comps[newhead].end(), comps[ahead].begin(),
comps[ahead].end());
comps[ahead].clear();
}
if (newhead != bhead) {
comps[newhead].insert(comps[newhead].end(), comps[bhead].begin(),
comps[bhead].end());
comps[bhead].clear();
}
dia[newhead] = std::max(std::max(dia[ahead], dia[bhead]),
1 + (1 + dia[ahead]) / 2 + (1 + dia[bhead]) / 2);
}
int main(void) {
setio();
int n, m, q;
std::cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
comps[i].push_back(i);
dia[i] = 0;
}
for (int i = 0, a, b; i < m; ++i) {
std::cin >> a >> b;
--a;
--b;
gr[a].push_back(b);
gr[b].push_back(a);
merge(a, b);
}
for (int i = 0; i < n; ++i) {
if (sets.find(i) == i) get_dia(i);
}
for (int type, x, y; q--;) {
std::cin >> type >> x;
if (type == 1) {
std::cout << dia[sets.find(x - 1)] << "\n";
} else {
std::cin >> y;
merge(x - 1, y - 1);
}
}
std::cerr << static_cast<double>(clock()) / CLOCKS_PER_SEC << "\n";
return 0;
}
static inline void setio(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.precision(10);
std::cout << std::fixed;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<vector<int>> adj(n);
for (int u, v; m--;) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int mx, who;
vector<int> d(n), par(n, -1);
function<void(int, int)> dfs = [&](int u, int p) {
if (d[u] > mx) mx = d[u], who = u;
for (auto v : adj[u])
if (v != p) {
d[v] = d[u] + 1;
par[v] = u;
dfs(v, u);
}
};
vector<int> l(n);
for (int i = 0; i < n; ++i)
if (par[i] == -1) {
mx = -1;
d[i] = 0;
dfs(i, -1);
mx = -1;
d[who] = 0;
dfs(who, -1);
int v = who;
int dist = d[v];
for (int it = d[v] / 2; it--;) v = par[v];
mx = -1;
par[v] = -2;
d[v] = 0;
dfs(v, -1);
d[v] = mx;
l[v] = dist;
}
function<int(int)> find = [&](int u) {
if (par[u] <= -1) return u;
return par[u] = find(par[u]);
};
auto merge = [&](int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
if (d[v] > d[u]) swap(u, v);
par[v] = u;
l[u] = max({l[u], l[v], d[u] + d[v] + 1});
d[u] = max(d[u], d[v] + 1);
};
for (int t, x, y; q--;) {
cin >> t >> x;
if (t == 1) {
--x;
x = find(x);
cout << l[x] << "\n";
} else {
cin >> y;
--x, --y;
merge(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, par[300010], ans[300010], sz[300010], vis[300010];
vector<int> G[300010];
int maxu, maxd;
int dfs(int u, int c, int d, int color) {
par[u] = c;
vis[u] = color;
if (d > maxd) {
maxu = u;
maxd = d;
}
int outp = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v] != color) outp += dfs(v, c, d + 1, color);
}
return outp + 1;
}
int findpar(int u) { return (par[u] == u ? u : findpar(par[u])); }
void join(int u, int v) {
int x = findpar(u), y = findpar(v);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
par[y] = x;
sz[x] += sz[y];
ans[x] = max(max(ans[x], ans[y]), (ans[x] + 1) / 2 + (ans[y] + 1) / 2 + 1);
}
int main() {
int color = 1;
scanf("%d%d%d", &n, &m, &q);
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
fill(par, par + n, -1);
for (int i = 0; i < n; i++)
if (par[i] == -1) {
maxu = i;
maxd = 0;
sz[i] = dfs(i, i, 0, color++);
maxd = 0;
dfs(maxu, i, 0, color++);
ans[i] = maxd;
}
for (int i = 0; i < q; i++) {
int c;
scanf("%d", &c);
if (c == 1) {
scanf("%d", &a);
a--;
printf("%d\n", ans[findpar(a)]);
} else {
scanf("%d%d", &a, &b);
a--;
b--;
join(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph, g;
vector<int> vis, pr, md;
int root, mx;
int DFS(int x) {
vis[x] = 1;
pr[x] = root;
g[root].push_back(x);
int mx1 = 0, mx2 = 0;
for (auto to : graph[x])
if (!vis[to]) {
int depth = DFS(to);
if (depth >= mx1) {
mx2 = mx1;
mx1 = depth;
} else if (depth > mx2)
mx2 = depth;
}
mx = max(mx, mx1 + mx2);
return mx1 + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
graph.resize(n);
vis.resize(n);
pr.resize(n);
md.resize(n);
g.resize(n);
for (int i = 0; i < n; i++) {
pr[i] = i;
g[i].push_back(i);
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 0; i < n; i++)
if (!vis[i]) {
mx = 0;
root = i;
DFS(i);
md[root] = mx;
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x;
cin >> x;
x--;
cout << md[pr[x]] << "\n";
continue;
}
int x, y;
cin >> x >> y;
x--;
y--;
int pr1 = pr[x], pr2 = pr[y];
if (pr1 == pr2) continue;
if (g[pr1].size() > g[pr2].size()) swap(pr1, pr2);
int new_md =
max({(md[pr1] + 1) / 2 + (md[pr2] + 1) / 2 + 1, md[pr1], md[pr2]});
md[pr2] = new_md;
for (auto xx : g[pr1]) {
pr[xx] = pr2;
g[pr2].push_back(xx);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 10;
struct edge {
int nex, to;
} e[N << 1];
int n, m, q, vis[N], cnt, head[N], f[N], maxl, s, len[N], vis2[N], rak[N];
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void add(int x, int y) {
e[++cnt] = ((edge){head[x], y});
head[x] = cnt;
}
inline int calc(int k) { return (k + 1) / 2; }
inline int find(int k) {
if (k == f[k]) return k;
return f[k] = find(f[k]);
}
inline void unite(int x, int y) { f[find(x)] = find(y); }
inline void dfs(int u, int dis) {
if (dis > maxl) maxl = dis, s = u;
for (int i = head[u]; i; i = e[i].nex) {
int v = e[i].to;
if (vis[v]) continue;
vis[v] = 1;
dfs(v, dis + 1);
}
vis[u] = 0;
}
inline void unitetree(int x, int y) {
len[y] = max(max(len[x], len[y]), calc(len[x]) + calc(len[y]) + 1);
}
int main() {
int x, y, z;
n = read();
m = read();
q = read();
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
add(x, y);
add(y, x);
unite(x, y);
}
for (int i = 1; i <= n; i++) {
int x = find(i);
if (vis2[x]) continue;
maxl = -1;
vis[x] = 1;
dfs(x, 0);
vis[s] = 1;
maxl = -1;
dfs(s, 0);
vis2[x] = 1;
len[x] = maxl;
}
while (q--) {
z = read();
if (z == 1) {
x = read();
printf("%d\n", len[find(x)]);
} else {
x = read();
y = read();
int xx = find(x), yy = find(y);
if (xx == yy) continue;
unitetree(xx, yy);
unite(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300100;
int head[maxn], nxt[maxn << 1], ver[maxn << 1], tot;
void addedge(int a, int b) {
nxt[++tot] = head[a];
ver[tot] = b;
head[a] = tot;
nxt[++tot] = head[b];
ver[tot] = a;
head[b] = tot;
}
int f[maxn], getlen;
void treedp(int x, int fat) {
f[x] = 0;
int mx = 0, sm = 0;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fat) continue;
treedp(y, x);
int F = f[y] + 1;
f[x] = max(f[x], F);
if (F >= mx)
sm = mx, mx = F;
else if (F > sm)
sm = F;
}
getlen = max(getlen, mx + sm);
}
int getpath(int x) {
getlen = 0;
treedp(x, 0);
return getlen;
}
int v[maxn], fa[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a, b);
fa[find(a)] = find(b);
}
for (int i = 1; i <= n; i++)
if (find(i) == i) v[i] = getpath(i);
for (int i = 1; i <= q; i++) {
int opt, a, b;
scanf("%d", &opt);
if (opt == 1)
scanf("%d", &a), printf("%d\n", v[find(a)]);
else {
scanf("%d%d", &a, &b);
a = find(a);
b = find(b);
if (a == b) continue;
v[b] = max(max(v[a], v[b]), ((v[a] + 1) >> 1) + ((v[b] + 1) >> 1) + 1);
fa[a] = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long INF64 = 1e18;
const long double EPS = 1e-7;
mt19937 myrand(time(NULL));
const int N = 300 * 1000 + 13;
int n, m, q;
vector<int> g[N];
int p[N], d[N];
bool read() {
if (scanf("%d%d%d", &n, &m, &q) != 3) return 0;
for (int i = 0; i < (n); i++) g[i].clear();
for (int i = 0; i < (n); i++) p[i] = i;
return 1;
}
int getP(int a) { return (a == p[a] ? a : p[a] = getP(p[a])); }
void unite(int a, int b) {
a = getP(a);
b = getP(b);
if (a == b) return;
if (myrand() & 1) swap(a, b);
p[b] = a;
d[a] = max(max(d[b], d[a]), (d[b] + 1) / 2 + (d[a] + 1) / 2 + 1);
}
int used[N];
int cc;
char usedgl[N];
int dist[N];
int bfs(int s) {
queue<int> q;
q.push(s);
++cc;
used[s] = cc;
dist[s] = 0;
int lst = -1;
while (!q.empty()) {
int v = q.front();
q.pop();
usedgl[v] = true;
lst = v;
for (auto u : g[v])
if (used[u] != cc) {
used[u] = cc;
dist[u] = dist[v] + 1;
q.push(u);
}
}
return lst;
}
void solve() {
for (int i = 0; i < (m); i++) {
int f, t;
scanf("%d%d", &f, &t);
--f, --t;
g[f].push_back(t);
g[t].push_back(f);
unite(f, t);
}
memset(d, 0, sizeof(d));
memset(usedgl, false, sizeof(usedgl));
cc = 0;
for (int i = 0; i < (n); i++) {
if (usedgl[i]) continue;
int t = bfs(bfs(i));
d[getP(i)] = dist[t];
}
for (int _ = 0; _ < (q); _++) {
int t;
scanf("%d", &t);
if (t == 1) {
int first;
scanf("%d", &first);
--first;
printf("%d\n", d[getP(first)]);
} else {
int first, second;
scanf("%d%d", &first, &second);
--first, --second;
unite(first, second);
}
}
}
int main() {
while (read()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300 * 1000 + 5;
int par[N];
int dis[N];
bool mark[N];
int ans[N];
int d[N];
int cnt[N];
vector<int> adj[N];
queue<int> q;
void dfs(int v, int root) {
if (mark[v]) return;
mark[v] = true;
par[v] = root;
for (auto u : adj[v]) {
dfs(u, root);
}
}
int get_par(int v) {
if (par[v] == v) {
return v;
}
return par[v] = get_par(par[v]);
}
int main() {
ios ::sync_with_stdio(false);
int n, m, t;
cin >> n >> m >> t;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (adj[i].size() <= 1) {
q.push(i);
} else {
dis[i] = N;
}
}
while (q.size()) {
int v = q.front();
q.pop();
bool b = true, c = false;
for (auto u : adj[v]) {
cnt[u]++;
if (cnt[u] + 1 == adj[u].size()) {
dis[u] = dis[v] + 1;
q.push(u);
}
if (dis[u] > dis[v] || (dis[u] == dis[v] && u > v)) {
b = false;
}
if (dis[u] == dis[v]) {
c = true;
}
}
if (b) {
dfs(v, v);
if (c) {
ans[v] = 2 * dis[v] + 1;
d[v] = dis[v];
d[v]++;
} else {
ans[v] = 2 * dis[v];
d[v] = dis[v];
}
}
}
for (int i = 0; i < t; i++) {
int qt, v, u = 0;
cin >> qt >> v;
if (qt == 2) {
cin >> u;
u = get_par(u);
v = get_par(v);
if (v == u) {
continue;
}
ans[v] = max(ans[v], d[v] + d[u] + 1);
ans[u] = max(ans[u], ans[v]);
ans[v] = max(ans[u], ans[v]);
int x = d[v];
d[v] = max(d[v], d[u] + 1);
d[u] = max(d[u], x + 1);
if (d[u] < d[v]) {
par[v] = u;
} else {
par[u] = v;
}
} else {
cout << ans[get_par(v)] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return abs(a);
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const long long T = 1 << 20;
const long double inf = 1e18;
long long m, n, k, q;
vector<vector<long long> > G(N);
long long rep[N];
long long srednica[N];
long long checked[N];
long long Find(long long x) {
return (x == rep[x] ? x : rep[x] = Find(rep[x]));
}
void Union(long long a, long long b) { rep[Find(a)] = Find(b); }
pair<long long, long long> dfs(long long x, long long pre = -1) {
pair<long long, long long> ret = {1, x};
for (auto &u : G[x])
if (u != pre) {
pair<long long, long long> pom = dfs(u, x);
pom.first++;
ret = max(ret, pom);
}
return ret;
}
long long polacz(long long a, long long b) {
return max({a, b, (a + 2) / 2 + (b + 2) / 2});
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
for (long long i = 1; i <= n; i++) rep[i] = i;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
Union(a, b);
}
for (long long i = 1; i <= n; i++)
if (!checked[Find(i)]) {
checked[Find(i)] = 1;
pair<long long, long long> a = dfs(Find(i));
pair<long long, long long> b = dfs(a.second);
srednica[Find(i)] = b.first;
}
while (q--) {
long long a, b, c;
cin >> a >> b;
if (a == 1)
cout << srednica[Find(b)] - 1 << '\n';
else {
cin >> c;
b = Find(b), c = Find(c);
if (b != c) {
srednica[c] = polacz(srednica[c], srednica[b]);
Union(b, c);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxInt = 300010;
bool arrUsados[MaxInt];
vector<int> mapa[MaxInt];
int caminos[MaxInt], tam[MaxInt], diametro[MaxInt];
int aux, aux2;
int find(int i);
void agregarCamino(int x, int y);
void juntarCiudad(int x, int y);
void depthFirst(int i, int depth, int k);
int main() {
int n, m, q, qT, x = 0, y, aux3;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i <= n; i++) {
caminos[i] = i;
tam[i] = i;
diametro[i] = 0;
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
mapa[x].push_back(y);
mapa[y].push_back(x);
agregarCamino(x, y);
}
for (int i = 0; i <= n; i++) {
aux3 = find(i);
if (!arrUsados[aux3]) {
arrUsados[aux3] = 1;
aux = -1;
depthFirst(i, 0, -1);
aux = -1;
depthFirst(aux2, 0, -1);
diametro[aux3] = aux;
}
}
while (q--) {
scanf("%d %d", &qT, &x);
if (qT == 2) {
scanf("%d", &y);
juntarCiudad(x, y);
} else {
printf("%d\n", diametro[find(x)]);
}
}
return 0;
}
int find(int i) {
if (caminos[i] == i) return i;
caminos[i] = find(caminos[i]);
return caminos[i];
}
void agregarCamino(int ciudad, int ciudad2) {
ciudad = find(ciudad);
ciudad2 = find(ciudad2);
if (tam[ciudad] > tam[ciudad2]) swap(ciudad, ciudad2);
tam[ciudad2] += tam[ciudad];
caminos[ciudad] = ciudad2;
}
void juntarCiudad(int ciudad, int ciudad2) {
ciudad = find(ciudad);
ciudad2 = find(ciudad2);
if (ciudad != ciudad2) {
if (tam[ciudad] > tam[ciudad2]) swap(ciudad, ciudad2);
tam[ciudad2] += tam[ciudad];
caminos[ciudad] = ciudad2;
diametro[ciudad2] =
max(((diametro[ciudad] + 1) / 2 + (diametro[ciudad2] + 1) / 2 + 1),
max(diametro[ciudad], diametro[ciudad2]));
}
}
void depthFirst(int i, int depth, int k) {
if (depth > aux) {
aux = depth;
aux2 = i;
}
for (int j = 0; j < mapa[i].size(); j++) {
int to = mapa[i][j];
if (to != k) depthFirst(to, depth + 1, i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAX_N = 600100;
int const INT_INF = 1000000000;
int my_rank[MAX_N], my_parent[MAX_N], diam_ancestor[MAX_N];
int d[MAX_N], och[MAX_N], nnew[MAX_N];
void make_set(int v) {
my_parent[v] = v;
diam_ancestor[v] = 0;
my_rank[v] = 0;
}
int find_set(int v) {
if (v != my_parent[v]) my_parent[v] = find_set(my_parent[v]);
return my_parent[v];
}
void my_Link(int x, int y, int flag) {
if (my_rank[x] > my_rank[y])
my_parent[y] = x;
else
my_parent[x] = y;
my_rank[y] += my_rank[x] == my_rank[y];
if (flag) {
int D1 = diam_ancestor[x];
int D2 = diam_ancestor[y];
int new_VVV = find_set(x);
int val = (D1 + 1) / 2 + (D2 + 1) / 2 + 1;
diam_ancestor[new_VVV] = max(D1, max(D2, val));
}
}
void my_Union(int x, int y, int flag) {
int V1 = find_set(x);
int V2 = find_set(y);
if (V1 == V2) return;
my_Link(V1, V2, flag);
}
vector<int> e[MAX_N];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) make_set(i);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
my_Union(a, b, 0);
e[a].push_back(b);
e[b].push_back(a);
}
for (int i = 0; i < n; i++) d[i] = INT_INF;
for (int i = 0; i < n; i++)
if (!nnew[i]) {
int p_read = 0, p_write = 1;
och[p_read] = i;
nnew[i] = 1;
d[i] = 0;
while (p_read < p_write) {
int v = och[p_read];
p_read++;
for (int j = 0; j < (int)e[v].size(); j++) {
int new_v = e[v][j];
if (d[new_v] > d[v] + 1) {
d[new_v] = d[v] + 1;
och[p_write] = new_v;
p_write++;
nnew[new_v] = 1;
}
}
}
int mx_dist = -1, ans_vertex = -1;
for (int j = 0; j < p_write; j++)
if (d[och[j]] > mx_dist) {
mx_dist = d[och[j]];
ans_vertex = och[j];
}
for (int j = 0; j < p_write; j++) d[och[j]] = INT_INF;
p_read = 0, p_write = 1;
och[p_read] = ans_vertex;
d[ans_vertex] = 0;
while (p_read < p_write) {
int v = och[p_read];
p_read++;
for (int j = 0; j < (int)e[v].size(); j++) {
int new_v = e[v][j];
if (d[new_v] > d[v] + 1) {
d[new_v] = d[v] + 1;
och[p_write] = new_v;
p_write++;
}
}
}
mx_dist = -1;
for (int j = 0; j < p_write; j++) mx_dist = max(mx_dist, d[och[j]]);
diam_ancestor[find_set(i)] = mx_dist;
}
for (int i = 0; i < q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 2) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
my_Union(a, b, 1);
} else if (tp == 1) {
int v;
scanf("%d", &v);
v--;
int VVV = find_set(v);
printf("%d\n", diam_ancestor[VVV]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x = 0, p = 1;
char c;
do {
c = getchar();
} while (c <= 32);
if (c == '-') {
p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * p;
}
const int INF = INT_MAX;
const int maxn = 300500;
vector<vector<int> > g(maxn);
int n, m, q;
bool used[maxn];
int p[maxn], sz[maxn], diameter[maxn];
int maxi, maxiV;
void dfs(int v, int depth, int p) {
if (depth > maxi) {
maxi = depth;
maxiV = v;
}
for (auto to : g[v]) {
if (to != p) {
dfs(to, depth + 1, v);
}
}
}
int findLongestway(int v) {
maxi = -1;
dfs(v, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
void init() {
for (int i = 1; i <= n; i++) {
p[i] = i;
sz[i] = 1;
diameter[i] = 0;
}
}
int getSet(int v) {
if (p[v] == v) {
return v;
}
return p[v] = getSet(p[v]);
}
void unionSets1(int x, int y) {
x = getSet(x);
y = getSet(y);
if (x == y) {
return;
}
if (sz[x] > sz[y]) {
swap(x, y);
}
sz[y] += sz[x];
p[x] = y;
}
int radius(int x) { return (diameter[x] + 1) / 2; }
void unionSets2(int x, int y) {
x = getSet(x);
y = getSet(y);
if (x == y) {
return;
}
if (sz[x] > sz[y]) {
swap(x, y);
}
sz[y] += sz[x];
p[x] = y;
diameter[y] = max(max(diameter[x], diameter[y]), radius(x) + radius(y) + 1);
}
int query(int x) { return diameter[getSet(x)]; }
int main() {
n = nextInt();
m = nextInt();
q = nextInt();
g.resize(n + 1);
init();
for (int i = 1; i <= m; i++) {
int a, b;
a = nextInt();
b = nextInt();
g[a].push_back(b);
g[b].push_back(a);
unionSets1(a, b);
}
for (int i = 1; i <= n; i++) {
int pp = getSet(i);
if (!used[pp]) {
used[pp] = 1;
diameter[pp] = findLongestway(i);
}
}
while (q--) {
int t, x, y;
t = nextInt();
if (t == 2) {
x = nextInt();
y = nextInt();
unionSets2(x, y);
} else {
x = nextInt();
cout << (query(x)) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[300005], yo;
int n, m, q, ans[300005] = {0};
bool done[300005] = {0}, done2[300005] = {0};
int parent[300005] = {0}, size[300005] = {0};
void make_set(int v) {
parent[v] = v;
size[v] = 1;
}
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void merge_set(int a, int b) {
a = find_set(a), b = find_set(b);
if (a != b) {
if (size[a] > size[b]) swap(a, b);
parent[a] = b;
size[b] += size[a];
}
}
int go(int src) {
pair<int, int> maxx = {src, 0};
stack<pair<int, int> > s;
s.push({src, 0});
while (!s.empty()) {
int x = s.top().first, d = s.top().second;
if (d > maxx.second) maxx = {x, d};
s.pop();
done2[x] = 1;
for (auto it : graph[x])
if (!done2[it]) s.push({it, d + 1});
}
s.push({maxx.first, 0});
maxx.second = 0;
while (!s.empty()) {
int x = s.top().first, d = s.top().second;
if (d > maxx.second) maxx = {x, d};
s.pop();
done[x] = 1;
yo.push_back(x);
for (auto it : graph[x])
if (!done[it]) s.push({it, d + 1});
}
return maxx.second;
}
int main() {
for (__typeof(300005) i = 0 - (0 > 300005); i != 300005 - (0 > 300005);
i += 1 - 2 * (0 > 300005))
make_set(i);
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (__typeof(m) i = 0 - (0 > m); i != m - (0 > m); i += 1 - 2 * (0 > m)) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
graph[u].push_back(v);
graph[v].push_back(u);
merge_set(u, v);
}
for (__typeof(n + 1) i = 1 - (1 > n + 1); i != n + 1 - (1 > n + 1);
i += 1 - 2 * (1 > n + 1)) {
if (!done[i]) {
yo.clear();
int dia = go(i);
for (auto it : yo) ans[it] = dia;
}
}
for (__typeof(q) i = 0 - (0 > q); i != q - (0 > q); i += 1 - 2 * (0 > q)) {
int mode;
scanf("%d", &mode);
if (mode == 1) {
int x;
scanf("%d", &x);
printf("%d\n", ans[find_set(x)]);
} else {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
int a = find_set(x), b = find_set(y);
if (a == b) continue;
int A = ans[a], B = ans[b], C = (A + 1) / 2 + (B + 1) / 2 + 1;
a = find_set(a), b = find_set(b);
if (a != b) {
if (size[a] > size[b]) swap(a, b);
parent[a] = b;
size[b] += size[a];
}
ans[b] = max(C, max(A, B));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
int N, components;
vector<int> par, s, val;
DSU(int n) {
N = n;
components = n;
par.resize(N + 1);
s.resize(N + 1);
s.assign(N + 1, 1);
val.resize(N + 1);
iota((par).begin(), (par).end(), 0);
}
int find_par(int node) {
if (node == par[node])
return node;
else
return par[node] = find_par(par[node]);
}
void merge(int u, int v) {
u = find_par(u);
v = find_par(v);
if (u == v) return;
if (s[u] < s[v]) swap(u, v);
par[v] = u;
s[u] += s[v];
s[v] = 0;
val[u] = max({val[u], val[v], val[u] / 2 + val[v] / 2 + 2});
components--;
}
};
int n, m, q, vis[300005], h[300005];
vector<int> a[300005];
vector<int> v;
int bfs(int node) {
v.clear();
queue<int> Q;
Q.push(node);
int ans = -1;
while (!Q.empty()) {
auto d = Q.front();
Q.pop();
vis[d] = 1;
ans = d;
v.push_back(d);
for (auto i : a[d]) {
if (!vis[i]) Q.push(i), h[i] = h[d] + 1;
}
}
return ans;
}
void solve() {
cin >> n >> m >> q;
DSU obj(n);
for (int i = 0; i < m; i++) {
int first, second;
cin >> first >> second;
a[first].push_back(second);
a[second].push_back(first);
}
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
int d = bfs(i);
for (auto j : v) vis[j] = 0, h[j] = 0;
d = bfs(d);
for (auto j : v) {
obj.merge(j, i);
}
obj.val[obj.find_par(i)] = h[d] + 1;
}
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int first;
cin >> first;
first = obj.find_par(first);
cout << obj.val[first] - 1 << '\n';
} else {
int first, second;
cin >> first >> second;
obj.merge(first, second);
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.