text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
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, max(diameter[x], diameter[y]));
}
int query(int x) { return diameter[getSet(x)]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
cin >> n >> m >> q;
init();
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
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;
cin >> t;
if (t == 2) {
cin >> x >> y;
unionSets2(x, y);
} else {
cin >> x;
printf("%d\n", query(x));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[300005];
int par[300005], longest[300005], Rank[300005];
bool vis[300005];
int find_par(int x) {
if (par[x] == x) return x;
return par[x] = find_par(par[x]);
}
void union_sets(int x, int y) {
x = find_par(x), y = find_par(y);
if (x == y) return;
if (Rank[x] > Rank[y]) swap(x, y);
par[x] = y;
if (Rank[x] == Rank[y]) Rank[y]++;
int a = 1 + (longest[x] + 1) / 2 + (longest[y] + 1) / 2;
a = max(a, longest[x]);
a = max(a, longest[y]);
longest[y] = a;
}
pair<int, int> diameter(int node, int parent) {
vis[node] = 1;
int diam = 0;
int mxHeights[3] = {-1, -1, -1};
for (int child : adj[node]) {
if (child == parent) continue;
pair<int, int> p = diameter(child, node);
diam = max(diam, p.first);
mxHeights[0] = p.second + 1;
sort(mxHeights, mxHeights + 3);
}
for (int i = 0; i < 3; i++)
if (mxHeights[i] == -1) mxHeights[i] = 0;
diam = max(diam, mxHeights[1] + mxHeights[2]);
return {diam, mxHeights[2]};
}
void dfs(int node, int x) {
if (par[node] != -1) return;
par[node] = x;
for (int child : adj[node]) dfs(child, x);
}
int main() {
int n, m, q, a, b, c;
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);
}
memset(par, -1, sizeof(par));
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
int d = diameter(i, -1).first;
longest[i] = d;
dfs(i, i);
}
while (q--) {
scanf("%d", &c);
if (c == 1) {
scanf("%d", &a);
a = find_par(a);
printf("%d\n", longest[a]);
} else {
scanf("%d%d", &a, &b);
union_sets(a, b);
a = find_par(a), b = find_par(b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 3e5 + 5;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
vector<long long int> gr[N], comp[N];
long long int n, m, k;
long long int vis[N];
struct dsu {
vector<long long int> p, sz;
long long int comp, n;
void init(long long int _n) {
n = _n;
comp = n;
p.clear();
sz.clear();
p.resize(n);
sz.resize(_n, 0);
iota(p.begin(), p.end(), 0);
}
long long int get(long long int x) {
return (x == p[x] ? x : (p[x] = get(p[x])));
}
void unite(long long int x, long long int y) {
x = get(x);
y = get(y);
if (x != y) {
p[x] = y;
sz[y] = max({sz[x], sz[y], (sz[y] + 1) / 2 + (sz[x] + 1) / 2 + 1});
sz[x] = 0;
comp--;
}
}
} G;
long long int res;
void dfs(long long int curr, long long int cmp, long long int par = -1) {
vis[curr] = 1;
comp[cmp].push_back(curr);
for (auto x : gr[curr]) {
if (x != par) {
dfs(x, cmp, curr);
}
}
}
long long int diam(long long int curr, long long int par = -1) {
vector<long long int> temp;
for (auto x : gr[curr]) {
if (x != par) {
temp.push_back(diam(x, curr));
}
}
temp.push_back(0);
temp.push_back(0);
sort(temp.rbegin(), temp.rend());
res = max({res, temp[0] + temp[1]});
return (1 + temp[0]);
}
long long int find_diam(long long int cnt) {
res = 0;
diam(comp[cnt][0]);
return res;
}
void solve() {
cin >> n >> m >> k;
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
}
G.init(n + 1);
long long int cnt = 0;
for (long long int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, cnt++);
long long int dia = find_diam(cnt - 1);
for (long long int j = 1; j < comp[cnt - 1].size(); j++) {
G.unite(comp[cnt - 1][j], comp[cnt - 1][j - 1]);
}
G.sz[G.get(comp[cnt - 1][0])] = dia;
}
}
while (k--) {
long long int type, x, y;
cin >> type >> x;
if (type == 1) {
cout << G.sz[G.get(x)] << '\n';
} else {
cin >> y;
G.unite(x, y);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
template <typename T>
void upd(T &x, T y, T mod) {
x = x + y > mod ? x + y - mod : x + y;
}
template <typename T>
void sub(T &x, T y, T mod) {
x = x - y < 0 ? x - y + mod : x - y;
}
template <typename T>
void multi(T &x, T y, T mod) {
x = 1ll * x * y % mod;
}
const int INF = (1ll << 30);
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 3e5 + 7;
struct EDGE {
int to, nxt;
} edge[N << 1];
int n, m, q, E, dp[N], fa[N], ans[N], head[N];
bool vis[N];
inline void addedge(int u, int v) {
edge[++E].to = v;
edge[E].nxt = head[u];
head[u] = E;
}
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline bool merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
fa[x] = y;
return true;
}
inline void dfs(int u, int fa, int rt) {
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == fa) continue;
dfs(v, u, rt);
chkmax(ans[rt], dp[v] + dp[u] + 1);
chkmax(dp[u], dp[v] + 1);
}
}
int main() {
read(n);
read(m);
read(q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1, u, v; i <= m; i++) {
read(u);
read(v);
addedge(u, v);
addedge(v, u);
merge(u, v);
}
for (int i = 1; i <= n; i++)
if (fa[i] == i) dfs(i, 0, i);
for (int i = 1, opt, x, y; i <= q; i++) {
read(opt);
if (opt == 1) {
read(x);
printf("%d\n", ans[find(x)]);
} else {
read(x);
read(y);
int xx = find(x), yy = find(y);
if (xx == yy) continue;
merge(x, y);
ans[find(x)] =
max((ans[xx] + 1) / 2 + (ans[yy] + 1) / 2 + 1, max(ans[xx], ans[yy]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int cut, head[300030], ver[600060], kkkkfgdsg[600060];
int f[300030], dep[300030], st, maxx, dis[300030], book[300030];
void add(int x, int y) {
ver[++cut] = y;
kkkkfgdsg[cut] = head[x];
head[x] = cut;
}
int getf(int v) {
if (f[v] == v) return v;
return f[v] = getf(f[v]);
}
void dfs(int x, int vv) {
if (maxx < vv) maxx = vv, st = x;
for (int ii = head[x]; ii; ii = kkkkfgdsg[ii]) {
int y = ver[ii];
if (!book[y]) book[y] = 1, dfs(y, vv + 1);
}
book[x] = 0;
}
void dfs2(int x, int vv) {
if (maxx < vv) maxx = vv;
for (int ii = head[x]; ii; ii = kkkkfgdsg[ii]) {
int y = ver[ii];
if (!book[y]) book[y] = 1, dfs(y, vv + 1);
}
book[x] = 0;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) f[i] = i;
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
f[getf(x)] = getf(y);
}
for (int i = 1; i <= n; ++i) {
int t = getf(i);
if (t != i) continue;
maxx = -1;
book[t] = 1;
dfs(t, 0);
maxx = -1;
book[st] = 1;
dfs2(st, 0);
dis[t] = maxx;
}
while (q--) {
int a;
scanf("%d", &a);
if (a == 1) {
int x;
scanf("%d", &x);
printf("%d\n", dis[getf(x)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
int t1 = getf(x), t2 = getf(y);
if (t1 == t2) continue;
dis[t2] =
max(max((dis[t1] + 1) / 2 + (dis[t2] + 1) / 2 + 1, dis[t1]), dis[t2]);
f[getf(t1)] = getf(t2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 3e5 + 3;
vector<int> adj[Max];
int Dist[Max], longest[Max];
bool visited[Max];
vector<int> p(Max, -1);
int find(int x) { return p[x] < 0 ? x : p[x] = find(p[x]); }
void merge(int x, int y) {
if ((x = find(x)) == (y = find(y))) return;
if (p[y] < p[x]) swap(x, y);
p[x] += p[y];
p[y] = x;
}
pair<int, int> bfs(int node) {
queue<int> q;
q.push(node);
Dist[node] = 0;
visited[node] = true;
vector<int> nodes;
nodes.push_back(node);
while (!q.empty()) {
node = q.front();
q.pop();
for (int to : adj[node]) {
if (Dist[to] > Dist[node] + 1) {
Dist[to] = Dist[node] + 1;
q.push(to);
nodes.push_back(to);
visited[to] = true;
}
}
}
int farthestNode, farthest = -1;
for (int node : nodes) {
if (farthest < Dist[node]) {
farthest = Dist[node];
farthestNode = node;
}
}
for (int node : nodes) {
Dist[node] = 1e9;
}
return {farthestNode, farthest};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
merge(u, v);
}
for (int i = 1; i <= n; ++i) {
Dist[i] = 1e9;
visited[i] = false;
}
for (int i = 1; i <= n; ++i) {
if (visited[i]) continue;
pair<int, int> res = bfs(i);
res = bfs(res.first);
longest[find(res.first)] = res.second;
}
int type;
for (int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
cin >> u;
cout << longest[find(u)] << '\n';
} else {
cin >> u >> v;
if (find(u) == find(v)) continue;
int dist1 = longest[find(u)];
int dist2 = longest[find(v)];
merge(u, v);
longest[find(u)] =
max(max(dist1, dist2), (dist1 + 1) / 2 + (dist2 + 1) / 2 + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long infl = 1e18 + 5;
std::vector<vector<int> > g(300004);
long long int m, n, q, x, y, k, mx = -1, mn = infl, f, val, cnt, ans, t = 1, i,
j, ind = -1;
long long int a[300004], c[300004], d[300004], sz[300004], sm[300004],
vis[300004];
std::vector<int> p;
void dfs(int ver, int par = 0) {
vis[ver] = 1;
p.push_back(ver);
if (sm[ver] > mx) {
mx = sm[ver];
ind = ver;
}
for (auto &it : g[ver]) {
if (it == par) continue;
sm[it] = sm[ver] + 1;
dfs(it, ver);
}
}
void dfs2(int ver, int par = 0) {
if (sm[ver] > mx) {
mx = sm[ver];
ind = ver;
}
for (auto &it : g[ver]) {
if (it == par) continue;
sm[it] = sm[ver] + 1;
dfs2(it, ver);
}
}
int find(int ver) {
while (c[ver] != ver) {
ver = c[ver];
}
return ver;
}
void merg(int u, int v) {
x = find(u);
y = find(v);
if (x == y) return;
if (d[x] < d[y]) {
swap(x, y);
}
c[y] = x;
sz[x] += sz[y];
long long int nd = 1 + (d[x] + 1) / 2 + (d[y] + 1) / 2;
d[x] = max(nd, d[x]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("inp.txt", "r")) {
freopen("myfile.txt", "w", stdout);
freopen("inp.txt", "r", stdin);
}
int u, v;
cin >> n >> m >> q;
for (i = 1; i < n + 1; i++) {
c[i] = i;
sz[i] = 1;
}
for (i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (i = 1; i < n + 1; i++) {
if (!vis[i]) {
mx = -1;
p.clear();
dfs(i);
sm[ind] = 0;
mx = -1;
dfs2(ind);
for (j = 0; j < p.size(); j++) {
if (sm[p[j]] == mx / 2) {
ind = p[j];
break;
}
}
for (j = 0; j < p.size(); j++) {
c[p[j]] = ind;
d[p[j]] = mx;
}
}
}
for (i = 0; i < q; i++) {
cin >> t;
if (t == 1) {
cin >> u;
x = find(u);
cout << d[x] << "\n";
} else {
cin >> u >> v;
merg(u, v);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300500;
vector<int> g[maxn];
int n, m, q, x, y, op, f[maxn], len[maxn], path[maxn];
void dfs(int u, int rt) {
f[u] = rt;
for (auto v : g[u]) {
if (!f[v]) {
dfs(v, rt);
path[u] = max(path[u], path[v]);
path[u] = max(path[u], len[u] + len[v] + 1);
len[u] = max(len[u], len[v] + 1);
}
}
}
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!f[i]) dfs(i, i);
for (int i = 1; i <= q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &x);
printf("%d\n", path[find(x)]);
} else {
scanf("%d%d", &x, &y);
if (find(x) != find(y)) {
int mx = max(path[find(x)], path[find(y)]);
mx = max(mx, (path[find(x)] + 1) / 2 + (path[find(y)] + 1) / 2 + 1);
f[find(x)] = find(y);
path[find(x)] = mx;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > adj;
vector<long long> longest, parent, sz;
vector<bool> vis, vis2;
stack<long long> visited_here;
long long farthest;
long long mxdist = -1;
void dfs(long long root, long long distfrom) {
visited_here.push(root);
vis[root] = true;
mxdist = max(mxdist, distfrom);
if (mxdist == distfrom) farthest = root;
for (auto ver : adj[root]) {
if (vis[ver] == false) {
dfs(ver, distfrom + 1);
}
}
}
void dfs2(long long root, long long distfrom) {
vis2[root] = true;
mxdist = max(mxdist, distfrom);
if (mxdist == distfrom) farthest = root;
for (auto ver : adj[root]) {
if (vis2[ver] == false) {
dfs2(ver, distfrom + 1);
}
}
}
long long find(long long x) {
while (x != parent[x]) x = parent[x];
return x;
}
void merge(long long x, long long y) {
x = find(x), y = find(y);
if (x == y) return;
long long la = longest[x], lb = longest[y];
if (sz[y] > sz[x]) swap(x, y);
parent[y] = x, sz[x] += sz[y];
longest[x] = max(la, lb);
longest[x] = max(longest[x], (la + 1) / 2 + (lb + 1) / 2 + 1);
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long begtime = clock();
;
long long n, m, q;
cin >> n >> m >> q;
parent.resize(n + 1);
sz.resize(n + 1, 1);
adj.resize(n + 1);
longest.resize(n + 1, 0);
vis.resize(n + 1, false);
vis2.resize(n + 1, false);
for (long long i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b), adj[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (vis[i] == false) {
mxdist = -1;
farthest = -1;
dfs(i, 0);
dfs2(farthest, 0);
parent[i] = i;
sz[i] = visited_here.size();
longest[i] = mxdist;
while (!visited_here.empty()) {
long long tp = visited_here.top();
if (tp != i) {
parent[tp] = i;
longest[tp] = longest[i];
sz[tp] = sz[i];
}
visited_here.pop();
}
while (!visited_here.empty()) visited_here.pop();
}
}
for (long long i = 1; i <= q; i += 1) {
long long type;
cin >> type;
if (type == 1) {
long long pt;
cin >> pt;
cout << longest[find(pt)] << endl;
} else {
long long a, b;
cin >> a >> b;
merge(a, b);
}
}
long long endtime = clock();
cerr << endl
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC
<< " ms";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int maxm = 400010;
const int INF = 0x3f3f3f3f;
const long long LINF = 3e17 + 1;
const int mod = 1e9 + 7;
int n, r, c, m;
inline int read() {
register int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return (f == 1) ? x : -x;
}
int fa[maxn];
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
void join(int x, int y) {
int xx = getfa(x), yy = getfa(y);
if (xx != yy) {
fa[xx] = yy;
}
}
struct edge {
int v, nxt;
} E[maxm << 1];
int head[maxn], eid;
void add(int u, int v) {
E[eid] = (edge){v, head[u]};
head[u] = eid++;
}
int farnode;
int maxw;
int dist;
int d[maxn];
void dfs(int u, int f, int deep) {
if (deep > maxw) {
maxw = deep;
farnode = u;
}
for (int v, i = head[u]; i != -1; i = E[i].nxt) {
v = E[i].v;
if (v == f) continue;
dfs(v, u, deep + 1);
}
}
int main() {
;
ios::sync_with_stdio(0);
cin.tie(0);
;
int k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) fa[i] = i;
memset(head, -1, sizeof(head));
for (int u, v, i = 0; i < m; i++) {
cin >> u >> v;
add(u, v);
add(v, u);
join(u, v);
}
for (int i = 1; i <= n; i++) {
if (getfa(i) == i) {
farnode = i;
maxw = 0;
dfs(farnode, farnode, 0);
maxw = 0;
dfs(farnode, farnode, 0);
d[i] = maxw;
}
}
for (int u, v, op, i = 0; i < k; i++) {
cin >> op;
if (op == 1) {
cin >> u;
cout << d[getfa(u)] << endl;
} else {
cin >> u >> v;
if (getfa(u) != getfa(v)) {
d[getfa(v)] = max(max(d[getfa(u)], d[getfa(v)]),
(int)(ceil(1.0 * d[getfa(u)] / 2) +
ceil(1.0 * d[getfa(v)] / 2) + 1));
join(u, v);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph(300005);
vector<int> dsu(300005);
vector<int> longest(300005);
vector<int> visited(300005);
vector<pair<int, int> > branches(300005);
int parent(int u) {
if (dsu[u] != u) {
int p = parent(dsu[u]);
dsu[u] = p;
}
return dsu[u];
}
int visit(int u, int m) {
int sz = graph[u].size();
int path = 0;
dsu[u] = m;
for (int i = 0; i < sz; i++) {
int v = graph[u][i];
if (dsu[v]) continue;
path = max(path, visit(v, m));
int b = 1 + branches[v].first;
if (b > branches[u].first) swap(b, branches[u].first);
if (b > branches[u].second) swap(b, branches[u].second);
}
path = max(path, branches[u].first + branches[u].second);
return path;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
dsu[i] = 0;
longest[i] = 0;
visited[i] = 0;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!dsu[i]) {
longest[i] = visit(i, i);
}
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
x = parent(x);
printf("%d\n", longest[x]);
}
if (t == 2) {
int x, y;
scanf("%d%d", &x, &y);
x = parent(x);
y = parent(y);
if (x == y) continue;
dsu[x] = dsu[y];
int temp = (longest[x] + 1) / 2 + (longest[y] + 1) / 2 + 1;
longest[y] = max(longest[y], longest[x]);
longest[y] = max(longest[y], temp);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 800001;
long long n, m, tot, k, ans, q;
long long head[N], f[N], d[N], c[N];
struct lll {
long long to, next;
} e[N];
inline long long read() {
long long x = 0, k = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') k = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * k;
}
void add(long long u, long long v) {
e[++tot].to = v;
e[tot].next = head[u];
head[u] = tot;
}
long long find(long long x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
long long dfs(long long u, long long fa) {
long long m1 = 0, m2 = 0;
for (long long i = head[u]; i; i = e[i].next) {
long long v = e[i].to;
if (v == fa) continue;
long long r = dfs(v, u) + 1;
if (m1 < r)
m2 = m1, m1 = r;
else if (m2 < r)
m2 = r;
ans = max(ans, m1 + m2);
}
return m1;
}
signed main() {
n = read();
m = read();
q = read();
for (long long i = 1; i <= n; i++) f[i] = i;
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read();
add(x, y);
add(y, x);
f[find(y)] = find(x);
}
for (long long i = 1; i <= n; i++) {
long long fi = find(i);
if (c[fi] == 0) {
c[fi] = 1;
ans = 0;
dfs(i, 0);
d[fi] = ans;
}
}
for (long long i = 1; i <= q; i++) {
long long opt = read();
if (opt == 1) {
long long x = read();
long long fx = find(x);
printf("%lld\n", d[fx]);
} else if (opt == 2) {
long long x = read(), y = read();
long long fx = find(x), fy = find(y);
if (fx == fy) continue;
f[fy] = fx;
d[fx] = max(d[fx], max(d[fy], (d[fx] + 1) / 2 + (d[fy] + 1) / 2 + 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gr[300005];
int mp[300005];
int un(int a) {
if (gr[a] == a) return a;
return gr[a] = un(gr[a]);
}
vector<int> veze[300005];
int n, m, q;
bool bio[300005];
int maks_path;
int dfs(int pos) {
++bio[pos];
int mb1 = 0, mb2 = 0;
for (int i = 0; i < veze[pos].size(); ++i) {
int x = veze[pos][i];
if (bio[x]) continue;
int y = dfs(x);
gr[x] = pos;
if (y > mb2) mb2 = y;
if (y > mb1) {
mb2 = mb1;
mb1 = y;
}
}
maks_path = max(maks_path, mb1 + mb2 + 1);
return mb1 + 1;
}
void get() {
int a;
scanf("%d", &a);
a = un(a);
printf("%d\n", mp[a] - 1);
}
void merge() {
int a, b;
scanf("%d%d", &a, &b);
a = un(a);
b = un(b);
if (a == b) return;
gr[b] = a;
int x = mp[a], y = mp[b], r = max(mp[a], mp[b]);
x = x / 2 + 1;
y = y / 2 + 1;
r = max(r, x + y);
mp[a] = r;
}
int main() {
for (int i = 0; i <= 300000; ++i) gr[i] = i;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
veze[a].push_back(b);
veze[b].push_back(a);
}
for (int i = 1; i <= n; ++i)
if (!bio[i]) {
dfs(i);
mp[un(i)] = maks_path;
maks_path = 0;
}
for (int i = 0; i < q; ++i) {
int t;
scanf("%d", &t);
if (t == 1)
get();
else
merge();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
char c = getchar();
int x = 0, f = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return f * x;
}
int n, m, Q;
int res, dp[300005];
struct edge {
int to, nxt, w;
} e[300005 << 1];
int tot, head[300005];
inline void adde(int u, int v, int w) {
e[++tot] = (edge){v, head[u], w};
head[u] = tot;
}
void dfs(int u, int fa) {
dp[u] = 0;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
res = max(res, dp[u] + dp[v] + e[i].w);
dp[u] = max(dp[u], dp[v] + e[i].w);
}
}
int v[300005], fa[300005];
int getf(int x) {
if (x == fa[x]) return x;
return fa[x] = getf(fa[x]);
}
signed main() {
n = read(), m = read(), Q = read();
for (register int i = (1); i <= (n); ++i) fa[i] = i;
for (register int i = (1); i <= (m); ++i) {
int u = read(), v = read();
adde(u, v, 1);
adde(v, u, 1);
fa[getf(u)] = getf(v);
}
for (register int i = (1); i <= (n); ++i)
if (getf(i) == i) {
res = 0;
dfs(i, 0);
v[i] = res;
}
while (Q--) {
int op = read();
if (op == 1)
printf("%d\n", v[getf(read())]);
else {
int x = getf(read()), y = getf(read());
if (x == y) continue;
int len = max((v[x] + 1) / 2 + (v[y] + 1) / 2 + 1, max(v[x], v[y]));
fa[y] = fa[x];
v[x] = len;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
const int N = 300002;
vector<int> v[N];
bool vis[N];
int p[N], r[N], ans[N], dep[N], init;
vector<int> check;
void in(int n) {
for (int i = 1; i <= n; ++i) {
r[i] = 0;
p[i] = i;
ans[i] = 0;
}
}
int parent(int i) {
if (i == p[i]) return i;
return p[i] = parent(p[i]);
}
void merge(int x, int y) {
x = parent(x);
y = parent(y);
if (x == y) return;
int zz = max({ans[x], ans[y], (ans[x] + 1) / 2 + (ans[y] + 1) / 2 + 1});
if (r[x] > r[y]) {
p[y] = x;
ans[x] = zz;
} else {
p[x] = y;
ans[y] = zz;
}
if (r[x] == r[y]) ++r[y];
}
void dfs(int s, int &md, int &val, int para) {
vis[s] = true;
for (auto j : v[s]) {
if (!vis[j]) {
check.push_back(j);
dep[j] = dep[s] + 1;
p[j] = init;
if (dep[j] > md) {
md = dep[j];
val = j;
}
dfs(j, md, val, para);
dep[j] = 0;
}
}
if (para == 1) vis[s] = false;
}
int findDiameter(int s) {
dep[s] = 0;
int ans1 = 0;
int md = 0, val = s, para;
dfs(s, md, val, para = 1);
dep[val] = 0;
md = 0;
dfs(val, md, s, para = 0);
return md;
}
int _runtimeTerror_() {
int n, m, q;
cin >> n >> m >> q;
in(n);
while (m--) {
int xx, yy;
cin >> xx >> yy;
v[xx].push_back(yy);
v[yy].push_back(xx);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
check.clear();
init = i;
ans[i] = findDiameter(i);
}
}
while (q--) {
int tt, xx, yy;
cin >> tt >> xx;
if (tt == 1) {
cout << ans[parent(xx)] << "\n";
} else {
cin >> yy;
merge(xx, yy);
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int apa[300009];
int melyseg[300009];
int atmero[300009];
int szint[300009];
vector<int> p[300009];
bool bejar[300009];
bool bejar2[300009];
int sor[300009];
int sk, sv, akt;
int unio(int x, int y) {
if (melyseg[x] > melyseg[y]) {
apa[y] = x;
} else if (melyseg[y] > melyseg[x]) {
apa[x] = y;
} else {
apa[x] = y;
melyseg[y]++;
}
return 0;
}
int unio2(int x, int y) {
int uj;
uj = max(max(atmero[x], atmero[y]),
(atmero[x] + 1) / 2 + (atmero[y] + 1) / 2 + 1);
if (melyseg[x] > melyseg[y]) {
apa[y] = x;
atmero[x] = uj;
} else if (melyseg[y] > melyseg[x]) {
apa[x] = y;
atmero[y] = uj;
} else {
apa[x] = y;
melyseg[y]++;
atmero[y] = uj;
}
return 0;
}
int holvan(int x) {
if (apa[x] == -1) return x;
int y = holvan(apa[x]);
apa[x] = y;
return y;
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
apa[i] = -1;
melyseg[i] = 1;
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
p[a].push_back(b);
p[b].push_back(a);
if (holvan(a) != holvan(b)) unio(holvan(a), holvan(b));
}
for (int i = 1; i <= n; i++) {
if (!bejar[i]) {
sk = 1;
sv = 1;
sor[1] = i;
szint[i] = 0;
bejar[i] = true;
while (sk <= sv) {
akt = sor[sk];
for (int j = 0; j < p[akt].size(); j++) {
int sz = p[akt][j];
if (!bejar[sz]) {
sv++;
sor[sv] = sz;
szint[sz] = szint[akt] + 1;
bejar[sz] = true;
}
}
sk++;
}
sk = 1;
sv = 1;
bejar2[akt] = true;
sor[1] = akt;
szint[akt] = 0;
while (sk <= sv) {
akt = sor[sk];
for (int j = 0; j < p[akt].size(); j++) {
int sz = p[akt][j];
if (!bejar2[sz]) {
sv++;
sor[sv] = sz;
szint[sz] = szint[akt] + 1;
bejar2[sz] = true;
}
}
sk++;
}
atmero[holvan(i)] = szint[akt];
}
}
for (int i = 1; i <= q; i++) {
int d, e, f;
scanf("%d", &d);
scanf("%d", &e);
if (d == 1) {
printf("%d\n", atmero[holvan(e)]);
} else {
scanf("%d", &f);
if (holvan(e) != holvan(f)) unio2(holvan(e), holvan(f));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, q;
vector<int> g[N];
int par[N], siz[N], val[N];
bitset<N> vis;
pair<int, int> dfs(int v, int p) {
vis[v] = 1;
pair<int, int> mx = {0, v};
for (auto x : g[v]) {
if (x == p) continue;
auto xx = dfs(x, v);
if (xx.first + 1 > mx.first) mx = {xx.first + 1, xx.second};
}
return mx;
}
long long get1(int v) { return par[v] == v ? v : par[v] = get1(par[v]); }
void merge1(int x, int y) {
x = get1(x);
y = get1(y);
if (x == y) return;
if (siz[x] < siz[y]) swap(x, y);
par[y] = par[x];
siz[x] += siz[y];
}
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++) par[i] = i, siz[i] = 1;
;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
merge1(x, y);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
auto x = dfs(i, i);
x = dfs(x.second, x.second);
int xx = get1(x.second);
val[xx] = x.first;
}
int ch;
for (int i = 0; i < q; i++) {
cin >> ch;
if (ch == 1) {
cin >> x;
x = get1(x);
cout << val[x] << endl;
continue;
}
cin >> x >> y;
x = get1(x), y = get1(y);
if (x == y) continue;
int mxx = max(max(val[x], val[y]),
(val[x] / 2 + val[x] % 2 + val[y] / 2 + val[y] % 2 + 1));
merge1(x, y);
x = par[x];
val[x] = mxx;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int dad[300100], ran[300100], bst[300100];
int fin(int pos) {
if (pos == dad[pos]) return pos;
return dad[pos] = fin(dad[pos]);
}
void unir(int b1, int b2) {
if (b1 == b2) return;
int t1 = bst[b1] / 2 + (bst[b1] % 2);
t1 += bst[b2] / 2 + (bst[b2] % 2) + 1;
t1 = max(t1, max(bst[b1], bst[b2]));
if (ran[b1] <= ran[b2]) {
if (ran[b1] == ran[b2]) ran[b2]++;
dad[b1] = dad[b2];
bst[b2] = t1;
} else {
dad[b2] = dad[b1];
bst[b1] = t1;
}
}
bool vis[300100];
vector<int> adj[300100];
int sl, vl = 0;
void dfs(int pos, int dad, int lvl) {
vis[pos] = true;
if (lvl > vl) {
sl = pos;
vl = lvl;
}
for (int i = 0; i < adj[pos].size(); i++)
if (adj[pos][i] != dad) {
unir(fin(pos), fin(adj[pos][i]));
dfs(adj[pos][i], pos, lvl + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) dad[i] = i;
int tip, t1, t2;
for (int i = 0; i < m; i++) {
cin >> t1 >> t2;
adj[t1].push_back(t2);
adj[t2].push_back(t1);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
vl = 0;
dfs(i, i, 0);
vl = 0;
dfs(sl, sl, 0);
bst[fin(sl)] = vl;
}
while (q--) {
cin >> tip >> t1;
if (tip == 2) {
cin >> t2;
unir(fin(t1), fin(t2));
} else
cout << bst[fin(t1)] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
struct DSU {
int par[maxn];
void makeset() {
for (int i = 0; i < maxn; i++) par[i] = i;
}
int find_par(int n) {
if (par[n] == n) return n;
par[n] = find_par(par[n]);
return par[n];
}
void merge(int x, int y) {
int u = find_par(x);
int v = find_par(y);
if (u != v) par[u] = v;
}
DSU() { makeset(); }
} D;
vector<int> adj[maxn];
int dis[maxn], component[maxn], dia[maxn];
int farthest, mx;
void dfs(int u, int fa, int dep) {
dis[u] = dep;
if (dep > mx) {
mx = dep;
farthest = u;
}
for (auto v : adj[u]) {
if (v != fa) {
dfs(v, u, dep + 1);
}
}
}
void sett(int u, int fa, int base) {
D.merge(u, base);
dia[u] = dia[base];
for (auto v : adj[u]) {
if (v != fa) {
sett(v, u, base);
}
}
}
void get_diameter(int u) {
mx = -1;
dfs(u, u, 0);
mx = -1;
dfs(farthest, farthest, 0);
dia[u] = mx;
sett(u, u, u);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int q;
scanf("%d", &q);
while (m--) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(dia, -1, sizeof(dia));
for (int i = 1; i <= n; i++) {
if (dia[i] == -1) {
get_diameter(i);
}
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
int u = D.find_par(x);
printf("%d\n", dia[u]);
} else {
int x, y;
scanf("%d %d", &x, &y);
int u = D.find_par(x);
int v = D.find_par(y);
int diax = dia[u];
int diay = dia[v];
if (u != v) {
int newD = max(max(diax, diay), 1 + (diax + 1) / 2 + (diay + 1) / 2);
D.merge(x, y);
dia[D.find_par(x)] = newD;
dia[D.find_par(y)] = newD;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 412345;
int p[N];
int find(int x) { return p[x] = p[x] == x ? x : find(p[x]); }
int ans[N], md[N], ct[N];
void join(int x, int y) {
int px = find(x);
int py = find(y);
if (px != py) {
if (ans[px] < ans[py]) swap(px, py);
if (ans[px] < 1 + md[px] + md[py]) {
ans[px] = 1 + md[px] + md[py];
if (max(md[px], 1 + md[py]) <= max(1 + md[px], md[py])) {
md[px] = max(md[px], 1 + md[py]);
} else {
md[px] = max(1 + md[px], md[py]);
ct[px] = ct[py];
}
}
p[py] = px;
}
}
int vis[N], foi[N];
int dist[N];
int pa[N];
vector<int> v;
vector<int> g[N];
void dfs(int u, int d = 0) {
vis[u] = 1;
dist[u] = d;
v.push_back(u);
for (int v : g[u])
if (!vis[v]) {
dfs(v, d + 1);
pa[v] = u;
}
}
int main() {
iota(p, p + N, 0);
iota(ct, ct + N, 0);
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);
int pa = find(a);
int pb = find(b);
p[pa] = pb;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!foi[i]) {
dfs(i);
int best = i;
int dbest = 0;
for (int u : v) {
foi[u] = 1;
if (dist[u] > dbest) {
best = u;
dbest = dist[u];
}
dist[u] = 0;
pa[u] = 0;
vis[u] = 0;
}
v.clear();
dfs(best);
dbest = 0;
for (int u : v) {
if (dist[u] > dbest) {
best = u;
dbest = dist[u];
}
}
int c = best;
int qt = dbest / 2;
for (int i = 0; i < qt; i++) {
c = pa[c];
}
int pi = find(i);
ans[pi] = dbest;
ct[pi] = c;
md[pi] = (dbest + 1) / 2;
for (int u : v) {
dist[u] = pa[u] = vis[u] = 0;
}
}
}
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
scanf("%d", &x);
printf("%d\n", ans[find(x)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
join(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 10;
int n, m, q;
vector<int> g[N];
int parent[N], rang[N], diametr[N];
bool used[N];
pair<int, int> mx;
void dfs(int v, int prev = -1, int h = 0) {
mx = max(mx, make_pair(h, v));
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == prev) continue;
dfs(to, v, h + 1);
}
}
int get_tree_diametr(int v) {
mx = make_pair(-1, -1);
dfs(v);
v = mx.second;
mx = make_pair(-1, -1);
dfs(v);
return mx.first;
}
void make_set(int v) {
parent[v] = v;
rang[v] = 0;
diametr[v] = 0;
}
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void union_set1(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rang[a] < rang[b]) swap(a, b);
parent[b] = a;
if (rang[a] == rang[b]) rang[a]++;
}
}
void union_set2(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rang[a] < rang[b]) swap(a, b);
parent[b] = a;
if (rang[a] == rang[b]) rang[a]++;
diametr[a] = max(diametr[a],
max(diametr[b], diametr[a] / 2 + diametr[b] / 2 +
diametr[a] % 2 + diametr[b] % 2 + 1));
}
}
string to_str(int x) {
string res;
if (x == 0) return "0";
while (x > 0) {
res += (x % 10 + '0');
x /= 10;
}
reverse(res.begin(), res.end());
return res;
}
int main() {
string ans;
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) make_set(i);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
union_set1(x, y);
}
for (int i = 0; i < n; ++i) {
int s = find_set(i);
if (used[s]) continue;
used[s] = true;
diametr[s] = get_tree_diametr(i);
}
while (q--) {
int tp;
cin >> tp;
switch (tp) {
case 1: {
int x;
cin >> x;
x--;
ans += to_str(diametr[find_set(x)]);
ans += "\n";
break;
}
case 2: {
int x, y;
cin >> x >> y;
x--;
y--;
union_set2(x, y);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, cnt, head[400010], maxx[400010], d[400010], pre[400010], ans;
bool vis[400010];
struct edge {
int x, y;
int next;
} e[600010];
void add(int x, int y) {
e[++cnt].x = x;
e[cnt].y = y;
e[cnt].next = head[x];
head[x] = cnt;
return;
}
inline int read() {
int s = 0, w = 1;
char ch;
ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
int find(int root) {
int son = root, tmp;
while (root != pre[root]) root = pre[root];
while (pre[son] != root) {
tmp = pre[son];
pre[son] = root;
son = tmp;
}
return root;
}
void dfs(int now, int pd, int fa) {
pre[now] = fa;
int maxx1 = 0, maxx2 = 0;
for (int i = head[now]; i != -1; i = e[i].next) {
if (e[i].y == pd) continue;
dfs(e[i].y, now, fa);
if (maxx[e[i].y] + 1 > maxx1) {
maxx2 = maxx1;
maxx1 = maxx[e[i].y] + 1;
} else if (maxx[e[i].y] + 1 > maxx2)
maxx2 = maxx[e[i].y] + 1;
}
maxx[now] = maxx1;
d[fa] = max(d[fa], maxx1 + maxx2);
return;
}
int main() {
n = read();
m = read();
q = read();
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int x, y;
x = read();
y = read();
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++) {
if (!pre[i]) dfs(i, 0, i);
}
for (int i = 1; i <= q; i++) {
int tmp, x;
tmp = read();
x = read();
if (tmp == 1)
printf("%d\n", d[find(x)]);
else {
int y, px, py;
y = read();
px = find(x);
py = find(y);
if (px == py) continue;
pre[px] = py;
d[py] = max(max(d[px], d[py]), (d[px] + 1) / 2 + (d[py] + 1) / 2 + 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 readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, q, tot;
int f[300005], max1[300005], max2[300005], v[600005], nxt[600005], h[300005],
d[300005];
bool vis[300005];
int getf(int v) {
if (v == f[v]) return v;
return f[v] = getf(f[v]);
}
void addedge(int x, int y) {
v[++tot] = y;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
nxt[tot] = h[y];
h[y] = tot;
}
void dfs(int u, int k) {
for (int p = h[u]; p; p = nxt[p]) {
if (vis[v[p]]) continue;
vis[v[p]] = true;
dfs(v[p], k);
if (max1[v[p]] + 1 > max1[u])
max2[u] = max1[u], max1[u] = max1[v[p]] + 1;
else if (max1[v[p]] + 1 > max2[u])
max2[u] = max1[v[p]] + 1;
}
d[k] = max(d[k], max1[u] + max2[u]);
}
int main() {
n = readint();
m = readint();
q = readint();
for (int i = 1; i <= n; i++) f[i] = i;
int opt, x, y;
for (int i = 1; i <= m; i++) {
x = readint();
y = readint();
addedge(x, y);
x = getf(x), y = getf(y);
if (x == y) continue;
f[x] = y;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vis[i] = true;
dfs(i, getf(i));
}
}
for (int i = 1; i <= q; i++) {
opt = readint();
x = readint();
if (opt == 1)
printf("%d\n", d[getf(x)]);
else {
y = readint();
x = getf(x), y = getf(y);
if (x == y) continue;
f[x] = y;
d[y] = max(max(d[x], d[y]), (d[x] + 1) / 2 + (d[y] + 1) / 2 + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, T, x, y, type, maxi, maxiV;
int diam[300005], p[300005], a[300005];
bool viz[300005];
vector<vector<int> > v;
void init();
void dfs(int node, int lg, int p);
int grp(int x);
void update1(int x, int y);
void update2(int x, int y);
int mndr(int node);
int query(int x);
void read(int &x) {
int sign = 1;
char ch;
x = 0;
while (!isdigit(ch = getchar())) {
if (ch == '-') {
sign = -1;
} else {
sign = 1;
}
}
do {
x = x * 10 + ch - '0';
} while (isdigit(ch = getchar()));
x *= sign;
}
int main() {
read(n), read(m), read(T);
init();
v.resize(n + 5);
for (int i = 1; i <= m; ++i) {
read(x), read(y);
v[x].push_back(y);
v[y].push_back(x);
update1(x, y);
}
for (int i = 1; i <= n; i++) {
int pp = grp(i);
if (!viz[pp]) {
viz[pp] = 1;
diam[pp] = mndr(i);
}
}
for (int i = 1; i <= T; ++i) {
read(type);
if (type == 1) {
read(x);
printf("%d\n", query(x));
} else {
read(x), read(y);
update2(x, y);
}
}
return 0;
}
void dfs(int node, int lg, int p) {
if (lg > maxi) {
maxi = lg;
maxiV = node;
}
for (vector<int>::iterator it = v[node].begin(); it != v[node].end(); ++it) {
int to = *it;
if (to != p) dfs(to, lg + 1, node);
}
}
int mndr(int node) {
maxi = -1;
dfs(node, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
void init() {
for (int i = 1; i <= n; ++i) {
p[i] = i;
a[i] = 1;
diam[i] = 1;
}
}
void update1(int x, int y) {
int rx = grp(x);
int ry = grp(y);
if (rx == ry) return;
if (a[rx] > a[ry]) {
swap(rx, ry);
}
a[rx] += a[ry];
p[ry] = rx;
}
void update2(int x, int y) {
int rx = grp(x);
int ry = grp(y);
if (rx == ry) return;
if (a[rx] >= a[ry]) {
swap(rx, ry);
}
a[rx] += a[ry];
p[ry] = rx;
diam[rx] =
max(diam[rx], max(diam[ry], (diam[rx] + 1) / 2 + (diam[ry] + 1) / 2 + 1));
}
int grp(int x) {
int cx = x;
while (p[x] != x) {
x = p[x];
}
while (cx != x) {
int aux = p[cx];
p[cx] = x;
cx = aux;
}
return x;
}
int query(int x) {
int qq = grp(x);
return diam[qq];
}
|
#include <bits/stdc++.h>
const int N = 300005;
const int mod = 1e9 + 9;
const int inf = 1 << 29;
using namespace std;
int n, m, q;
int eh[N], tot;
struct edge {
int v, next;
} et[N << 1];
int dp[N][3], rt[N], mx[N];
int fa[N];
int rn;
void init() {
tot = 0;
memset(eh, -1, sizeof(eh));
}
void add(int u, int v) {
edge e = {v, eh[u]};
et[tot] = e, eh[u] = tot++;
}
void input() {
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
add(u, v), add(v, u);
}
}
void dfs1(int u, int mfa) {
fa[u] = rn;
dp[u][0] = dp[u][1] = 0;
for (int i = eh[u]; i != -1; i = et[i].next) {
int v = et[i].v;
if (v == mfa) continue;
dfs1(v, u);
int tmp = dp[v][0] + 1;
if (tmp > dp[u][0]) swap(dp[u][0], tmp);
if (tmp > dp[u][1]) swap(dp[u][1], tmp);
}
}
void dfs2(int u, int mfa) {
for (int i = eh[u]; i != -1; i = et[i].next) {
int v = et[i].v;
if (v == mfa) continue;
if (dp[u][0] == dp[v][0] + 1)
dp[v][2] = max(dp[u][1], dp[u][2]) + 1;
else
dp[v][2] = max(dp[u][0], dp[u][2]) + 1;
dfs2(v, u);
}
}
void work() {
rn = 0;
memset(fa, 0, sizeof(fa));
for (int i = 1; i <= n; i++) {
if (fa[i]) continue;
++rn;
dfs1(i, -1);
dp[i][2] = 0;
dfs2(i, -1);
}
for (int i = 1; i <= rn; i++) mx[i] = n + 20;
for (int i = 1; i <= n; i++) {
int k = fa[i];
if (dp[i][2] > dp[i][0]) swap(dp[i][2], dp[i][0]);
if (dp[i][2] > dp[i][1]) swap(dp[i][2], dp[i][1]);
if (dp[i][0] < mx[k]) mx[k] = dp[i][0], rt[k] = i;
}
for (int i = 1; i <= n; i++) fa[i] = rt[fa[i]];
for (int i = 1; i <= rn; i++) {
int k = rt[i];
}
}
void merge(int x, int y) {
int tmp = dp[y][0] + 1, tmd = dp[x][0] + 1;
if (tmp > dp[x][0]) swap(dp[x][0], tmp);
if (tmp > dp[x][1]) swap(dp[x][1], tmp);
if (tmd > dp[y][0]) swap(dp[y][0], tmd);
if (tmd > dp[y][1]) swap(dp[y][1], tmd);
if (dp[x][0] + dp[x][1] > dp[y][0] + dp[y][1])
fa[y] = x;
else if (dp[x][0] + dp[x][1] == dp[y][0] + dp[y][1]) {
if (dp[x][0] <= dp[y][0])
fa[y] = x;
else
fa[x] = y;
} else
fa[x] = y;
}
int find(int k) { return fa[k] == k ? k : (fa[k] = find(fa[k])); }
void query() {
int op, x, y;
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &x);
x = find(x);
printf("%d\n", dp[x][0] + dp[x][1]);
} else {
scanf("%d%d", &x, &y);
x = find(x), y = find(y);
if (x != y) merge(x, y);
}
}
}
int main() {
while (cin >> n >> m >> q) {
init();
input();
work();
query();
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 300005;
struct Edges {
int next, to;
} e[maxn << 1];
int head[maxn], tot;
int fa[maxn], size[maxn];
int pos, maxd;
int len[maxn];
int n, m, q;
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void link(int u, int v) {
e[++tot] = (Edges){head[u], v};
head[u] = tot;
}
void dfs(int u, int f, int dep) {
if (dep > maxd) {
maxd = dep;
pos = u;
}
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == f) continue;
dfs(v, u, dep + 1);
}
}
int get_diameter(int s) {
pos = -1, maxd = -1;
dfs(s, 0, 0);
int sb = pos;
pos = -1, maxd = -1;
dfs(sb, 0, 0);
return maxd;
}
int rad(int x) { return (len[x] + 1) / 2; }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i, size[i] = 1;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
link(u, v);
link(v, u);
int uu = find(u), vv = find(v);
if (uu == vv) continue;
if (size[uu] < size[vv]) std::swap(uu, vv);
fa[vv] = uu;
size[uu] += size[vv];
}
for (int i = 1; i <= n; i++) {
if (find(i) == i) len[i] = get_diameter(i);
}
while (q--) {
int opt, x, y;
scanf("%d", &opt);
if (opt == 1) {
scanf("%d", &x);
printf("%d\n", len[find(x)]);
} else if (opt == 2) {
scanf("%d%d", &x, &y);
int uu = find(x), vv = find(y);
if (uu == vv) continue;
if (size[uu] < size[vv]) std::swap(uu, vv);
fa[vv] = uu;
size[uu] += size[vv];
len[uu] = std::max(len[uu], std::max(len[vv], rad(uu) + rad(vv) + 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, qu, fx, fy, len, x, y, q[300001], pos, hd[600001], dis[600001],
d[600001], fl[600001], f[600001], u1, u2;
int find(int x) { return x == f[x] ? x : (f[x] = find(f[x])); }
struct point {
int to, nxt;
} edge[600001];
int ans(int x) {
d[x] = 0, fl[x] = x, q[q[0] = 1] = x;
int yu = x;
for (int i = 1; i <= q[0]; i++) {
y = q[i];
for (int u = hd[y]; u != 0; u = edge[u].nxt)
if (fl[edge[u].to] != x) {
fl[edge[u].to] = x;
q[++q[0]] = edge[u].to, d[edge[u].to] = d[y] + 1;
if (d[edge[u].to] > d[yu]) yu = edge[u].to;
}
}
int y2 = yu;
d[yu] = 0, q[q[0] = 1] = yu, fl[yu] = yu;
for (int i = 1; i <= q[0]; i++) {
y = q[i];
for (int u = hd[y]; u; u = edge[u].nxt)
if (fl[edge[u].to] != yu) {
fl[edge[u].to] = yu, q[++q[0]] = edge[u].to, d[edge[u].to] = d[y] + 1;
if (d[edge[u].to] > d[y2]) y2 = edge[u].to;
}
}
return d[y2];
}
int main() {
scanf("%d %d %d", &n, &m, &qu);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
fx = find(x), fy = find(y);
edge[++len].to = y, edge[len].nxt = hd[x], hd[x] = len;
edge[++len].to = x, edge[len].nxt = hd[y], hd[y] = len;
if (fx != fy) f[fx] = fy;
}
for (int i = 1; i <= n; i++)
if (i == find(i)) dis[i] = ans(i);
for (int i = 1; i <= qu; i++) {
scanf("%d", &pos);
if (pos == 1) {
scanf("%d", &x);
fx = find(x);
printf("%d\n", dis[fx]);
} else {
scanf("%d%d", &x, &y);
fx = find(x), fy = find(y);
if (fx == fy) continue;
u1 = dis[fx];
u2 = dis[fy], f[fx] = fy, dis[fy] = (u1 + 1) / 2 + (u2 + 1) / 2 + 1;
if (dis[fy] < u1) dis[fy] = u1;
if (dis[fy] < u2) dis[fy] = u2;
}
}
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 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;
d[y] = max({d[y], d[x], (d[y] + 1) / 2 + (d[x] + 1) / 2 + 1});
}
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;
}
}
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &a);
printf("%d\n", d[findp(a)]);
} else {
scanf("%d%d", &a, &b);
if (findp(a) != findp(b)) mergep(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1000000;
using namespace std;
int N, M, Q, e;
int fa[MAXN], head[MAXN], Rank[MAXN], s[MAXN];
int deep[MAXN], Max_deep, s_p;
bool vis[MAXN];
struct node {
int next, v;
} edge[MAXN];
inline void addedge(int u, int v) {
edge[++e] = (node){head[u], v};
head[u] = e;
}
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || '9' < ch) {
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
int Get_fa(int x) { return fa[x] != x ? fa[x] = Get_fa(fa[x]) : x; }
inline int cnt(int x, int y) {
int sum = 1;
sum += x % 2 == 0 ? (x / 2) : (x / 2 + 1);
sum += y % 2 == 0 ? (y / 2) : (y / 2 + 1);
return sum;
}
inline void Union(int x, int y) {
int fx = Get_fa(x);
int fy = Get_fa(y);
if (Rank[fx] > Rank[fy]) {
fa[fy] = fx;
Rank[fx] += Rank[fy];
s[fx] = max(max(s[fx], s[fy]), cnt(s[fx], s[fy]));
} else {
fa[fx] = fy;
Rank[fy] += Rank[fx];
s[fy] = max(max(s[fx], s[fy]), cnt(s[fx], s[fy]));
}
}
void dfs(int x, int fa, int h) {
vis[x] = true;
if (Max_deep < h) {
Max_deep = h;
s_p = x;
}
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].v;
if (v == fa) {
continue;
}
dfs(v, x, h + 1);
}
}
int main() {
N = read();
M = read();
Q = read();
for (int i = 1; i <= N; i++) {
fa[i] = i;
Rank[i] = 1;
}
int u, v;
int k, x, y, fx, fy;
for (int i = 1; i <= M; i++) {
u = read();
v = read();
fx = Get_fa(u);
fy = Get_fa(v);
if (fx != fy) {
Union(fx, fy);
addedge(u, v);
addedge(v, u);
}
}
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
Max_deep = 1;
s_p = i;
dfs(i, 0, 1);
dfs(s_p, 0, 1);
fx = Get_fa(i);
s[fx] = Max_deep - 1;
}
}
for (int i = 1; i <= Q; i++) {
k = read();
if (k == 1) {
x = read();
fx = Get_fa(x);
printf("%d\n", s[fx]);
} else {
x = read();
y = read();
fx = Get_fa(x);
fy = Get_fa(y);
if (fx != fy) {
Union(x, y);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[300006];
int chk[300006];
int n, m, q;
int deme[300006], d[300006], dem[300006], o;
int rd() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return f ? x : -x;
}
int fd(int x) {
if (chk[x] == x) return x;
return chk[x] = fd(chk[x]);
}
void dfs(int u, int fa) {
int d1 = -1, d2 = -1;
for (int v = 0; v < e[u].size(); v++) {
if (e[u][v] == fa) continue;
dfs(e[u][v], u);
int t = d[e[u][v]] + 1;
d[u] = max(d[u], t);
if (t > d1)
d2 = d1, d1 = t;
else if (t > d2)
d2 = t;
}
dem[u] = max(max(0, d1 + d2), max(d1, d2));
o = max(o, dem[u]);
}
signed main() {
n = rd(), m = rd(), q = rd();
for (int i = 1; i <= n; i++) chk[i] = i;
for (int i = 1; i <= m; i++) {
int u = rd(), v = rd();
e[u].push_back(v), e[v].push_back(u);
chk[fd(u)] = fd(v);
}
for (int i = 1; i <= n; i++) {
if (chk[i] == i) {
o = 0;
dfs(i, 0);
deme[i] = o;
}
}
for (int i = 1; i <= q; i++) {
int jen = rd();
if (jen == 1) {
int k = rd();
cout << deme[fd(k)] << endl;
} else if (jen == 2) {
int k = rd(), l = rd();
k = fd(k), l = fd(l);
if (k != l) {
int x = (deme[k] + 1) / 2 + (deme[l] + 1) / 2 + 1;
x = max(x, max(deme[k], deme[l]));
chk[k] = l, deme[l] = x;
}
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:256000000")
using namespace std;
const int N = 300100;
vector<int> g[N];
int pr[N];
bool u[N];
vector<int> path[N];
int get(int v) {
if (pr[v] == v) return v;
return pr[v] = get(pr[v]);
}
int un(int a, int b) {
a = get(a);
b = get(b);
if (a != b) {
if (rand() & 1) {
pr[a] = b;
return b;
} else {
pr[b] = a;
return a;
}
} else {
return -1;
}
}
bool used[N];
int prv[N];
vector<int> bfs(int v) {
used[v] = 1;
queue<int> Q;
Q.push(v);
int x = -1;
vector<int> vis;
while (!Q.empty()) {
x = Q.front();
Q.pop();
vis.push_back(x);
for (int(i) = 0; (i) < ((int)(g[x]).size()); (i)++) {
int to = g[x][i];
if (!used[to]) {
used[to] = 1;
prv[to] = x;
Q.push(to);
}
}
}
vector<int> path;
while (x != -1) {
path.push_back(x);
x = prv[x];
}
reverse((path).begin(), (path).end());
for (int(i) = 0; (i) < ((int)(vis).size()); (i)++) {
used[vis[i]] = 0;
prv[vis[i]] = -1;
}
return path;
}
int main() {
int n, m, q, t, a, b;
cin >> n >> m >> q;
for (int(i) = 0; (i) < (n); (i)++) {
pr[i] = i;
}
for (int(i) = 0; (i) < (m); (i)++) {
scanf("%d%d", &a, &b);
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
un(a, b);
}
for (int(i) = 0; (i) < (n); (i)++) {
u[get(i)] = 1;
}
vector<int> temp;
memset(used, 0, sizeof(used));
memset(prv, -1, sizeof(prv));
for (int(i) = 0; (i) < (n); (i)++) {
if (u[i]) {
temp = bfs(i);
path[i] = bfs(temp.back());
}
}
for (int(i) = 0; (i) < (q); (i)++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &a);
--a;
int aa = get(a);
printf("%d\n", (int)(path[aa]).size() - 1);
} else {
scanf("%d%d", &a, &b);
--a, --b;
int aa = get(a);
int bb = get(b);
int c = un(a, b);
if (c != -1) {
temp.clear();
int nn = (int)(path[aa]).size() / 2 + 1;
int mm = (int)(path[bb]).size() / 2 + 1;
if ((int)(path[aa]).size() >= nn + mm &&
(int)(path[aa]).size() >= (int)(path[bb]).size()) {
temp = path[aa];
} else if ((int)(path[bb]).size() >= nn + mm &&
(int)(path[bb]).size() >= (int)(path[aa]).size()) {
temp = path[bb];
} else {
for (int(i) = 0; (i) < (nn); (i)++) {
temp.push_back(path[aa][i]);
}
for (int(i) = 0; (i) < (mm); (i)++) {
temp.push_back(path[bb][i]);
}
}
path[aa].clear();
path[bb].clear();
path[c].clear();
path[c] = temp;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const 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 T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1, x2, x3), gn(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
gn(x1, x2, x3, x4), gn(x5);
}
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 println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5) {
printsp(x1), printsp(x2), printsp(x3), printsp(x4), println(x5);
}
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;
}
vector<int> adj[300010];
int vst[300010], root[300010];
int d[300010], mx[300010];
void dfs(int u, int root) {
vst[u] = 1;
::root[u] = root;
int one = 0, two = 0;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
if (!vst[v]) {
dfs(v, root);
if (mx[v] + 1 > one) {
two = one;
one = mx[v] + 1;
} else if (mx[v] + 1 > two)
two = mx[v] + 1;
}
}
smax(d[root], one + two);
mx[u] = one;
}
int find_root(int u) {
if (u == root[u]) return u;
return root[u] = find_root(root[u]);
}
int main() {
int n, m, q;
gn(n, m, q);
while (m--) {
int u, v;
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vst[i]) {
dfs(i, i);
}
while (q--) {
int t, first, second;
gn(t, first);
if (t == 1)
println(d[find_root(first)]);
else {
gn(second);
first = find_root(first), second = find_root(second);
if (first != second) {
root[first] = second;
d[second] = max(max(d[first], d[second]),
(d[first] + 1 >> 1) + (d[second] + 1 >> 1) + 1);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int o = 3e5 + 1;
int f[o], n, m, k, s[o], d[o], g[o], v[o], l;
vector<int> a[o];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void dfs(int x, int y) {
int q = -1, w = -1;
for (int i = 0; i < a[x].size(); i++) {
if (a[x][i] == y) continue;
dfs(a[x][i], x);
int r = d[a[x][i]] + 1;
d[x] = max(d[x], r);
if (r > q)
w = q, q = r;
else if (r > w)
w = r;
}
g[x] = max(0, max(q, max(w, q + w)));
l = max(l, g[x]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1, x, y; i <= m; i++) {
cin >> x >> y, f[find(x)] = find(y);
a[x].push_back(y), a[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (f[i] == i && !v[i]) l = 0, dfs(i, 0), s[i] = l, v[i] = 1;
while (k--) {
int q, x, y;
cin >> q >> x, x = find(x);
if (q == 1)
cout << s[x] << "\n";
else {
cin >> y, y = find(y);
if (x == y) continue;
int z = (s[x] + 1) / 2 + (s[y] + 1) / 2 + 1;
z = max(z, max(s[x], s[y]));
f[find(x)] = find(y), s[find(x)] = z;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q;
vector<long long> v[300001];
long long par[300001], sz[300001];
long long diam[300001];
long long x = -1;
long long mx1 = 0;
long long mx2 = 0;
long long vis[300001];
long long fin(long long v) {
if (v == par[v]) return v;
return par[v] = fin(par[v]);
}
void uni1(long long a, long long b) {
a = fin(a);
b = fin(b);
if (a != b) {
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
}
}
void uni2(long long a, long long b) {
a = fin(a);
b = fin(b);
if (a != b) {
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
diam[a] = max({diam[a], diam[b],
diam[a] / 2 + diam[a] % 2 + diam[b] / 2 + diam[b] % 2 + 1});
}
}
void dfs1(long long node, long long par, long long dist) {
for (long long i = 0; i < v[node].size(); i++) {
if (par == v[node][i]) continue;
if (vis[v[node][i]] == 0) dfs1(v[node][i], node, dist + 1);
}
if (v[node].size() == 1) {
if (mx2 < dist) x = node;
mx2 = max(mx2, dist);
}
}
void dfs2(long long node, long long dist) {
vis[node] = 1;
for (long long i = 0; i < v[node].size(); i++) {
if (vis[v[node][i]]) continue;
if (vis[v[node][i]] == 0) dfs2(v[node][i], dist + 1);
}
if (v[node].size() == 1) mx2 = max(mx2, dist);
}
void func(long long node) {
mx1 = 0;
mx2 = 0;
dfs1(node, 0, 0);
dfs2(x, 0);
diam[fin(node)] = mx1 + mx2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> q;
for (long long i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 0;
diam[i] = 0;
}
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
uni1(a, b);
}
for (long long i = 1; i <= n; i++) {
if (vis[i] == 0) func(i);
}
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long x;
cin >> x;
cout << diam[fin(x)] << '\n';
} else {
long long x, y;
cin >> x >> y;
uni2(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int getc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int ret = 0, f = 0;
char ch = getc();
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getc();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - 48;
ch = getc();
}
return f ? -ret : ret;
}
inline void write(int x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writelp(int x) {
write(x);
putchar(' ');
}
inline void writeln(int x) {
write(x);
putchar('\n');
}
int n, m, q, cnt, h[300005], f[300005], len[300005];
int now, maxx, dep[300005], vis[300005];
struct edge {
int v, next;
} p[600005];
inline void add(int u, int v) {
p[++cnt].v = v;
p[cnt].next = h[u];
h[u] = cnt;
}
inline int getf(int x) {
if (f[x] == x)
return x;
else
return f[x] = getf(f[x]);
}
inline void dfs(int u) {
vis[u] = now;
if (dep[u] > dep[maxx]) maxx = u;
for (register int i = h[u]; i; i = p[i].next) {
int v = p[i].v;
if (vis[v] == now) continue;
dep[v] = dep[u] + 1;
dfs(v);
}
}
int main() {
n = read();
m = read();
q = read();
for (register int i = 1; i <= n; i++) f[i] = i;
for (register int i = 1, u, v; i <= m; i++) {
u = read();
v = read();
add(u, v);
add(v, u);
int fu = getf(u), fv = getf(v);
if (fu != fv) f[fu] = fv;
}
for (register int i = 1; i <= n; i++)
if (f[i] == i) {
now = i;
dep[now] = 0;
maxx = 0;
dfs(now);
now = maxx;
dep[now] = 0;
maxx = 0;
dfs(now);
len[i] = dep[maxx];
}
while (q--) {
int opt = read();
if (opt == 1) {
int x = read();
writeln(len[getf(x)]);
}
if (opt == 2) {
int x, y;
x = read();
y = read();
x = getf(x);
y = getf(y);
if (x == y) continue;
int len1 = len[x], len2 = len[y];
f[x] = y;
len[y] = (len1 + 1) / 2 + (len2 + 1) / 2 + 1;
if (len[y] < len1) len[y] = len1;
if (len[y] < len2) len[y] = len2;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
int n, m, Q, fa[300001], d[300001], fir[300001], cmp, dep[300001];
bool vis[300001];
struct node {
int to, nxt;
} e[600001];
void cr(int u, int v) {
e[++cmp] = {v, fir[u]};
fir[u] = cmp;
}
void dfs(int x, int top) {
fa[x] = top;
vis[x] = true;
for (int i = fir[x]; i; i = e[i].nxt) {
int tt = e[i].to;
if (vis[tt]) continue;
dfs(tt, top);
d[top] = max(d[top], dep[x] + dep[tt] + 1);
dep[x] = max(dep[x], dep[tt] + 1);
}
}
int gr(int x) {
if (fa[x] == x) return x;
return fa[x] = gr(fa[x]);
}
void uni(int u, int v) {
if (gr(u) == gr(v)) return;
int d1 = d[gr(u)], d2 = d[gr(v)];
int d3 = (d1 + 1) / 2 + (d2 + 1) / 2 + 1;
fa[gr(u)] = gr(v);
int g = gr(v);
d[g] = max(max(d1, d2), d3);
}
int main() {
cin >> n >> m >> Q;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
u = read();
v = read();
cr(u, v);
cr(v, u);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs(i, i);
}
while (Q--) {
int p, q;
p = read();
if (p == 1) {
p = read();
cout << d[gr(p)] << endl;
continue;
}
p = read();
q = read();
if (gr(p) == gr(q)) continue;
uni(p, q);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
static constexpr int inf = std::numeric_limits<int>::max();
const int M = 300100;
vector<int> A[M];
int visited[M], diameter[M], parent[M], md, mu;
int f(int u) { return parent[u] = parent[u] == u ? u : f(parent[u]); }
void add(int a, int b) {
int u = f(a), v = f(b);
if (u != v) parent[v] = u;
}
void molest(int a, int b) {
int u = f(a), v = f(b);
if (u != v) {
parent[v] = u;
diameter[u] = max(max(diameter[u], diameter[v]),
(diameter[u] + 1) / 2 + (diameter[v] + 1) / 2 + 1);
}
}
void dfs(int u, int p, int l) {
int i, v;
visited[u] = true;
add(p, u);
if (l >= md) md = l, mu = u;
for (i = 0; i < A[u].size(); i++) {
v = A[u][i];
if (!visited[v]) dfs(v, p, l + 1);
}
visited[u] = false;
}
void find_dia(int u) {
md = 0;
dfs(u, u, 0);
md = 0;
dfs(mu, u, 0);
diameter[u] = md;
}
int main() {
int n, m, q, i, j, k, t;
scanf("%d%d%d", &n, &m, &q);
while (m--) {
scanf("%d%d", &i, &j);
A[i].push_back(j);
A[j].push_back(i);
}
for (i = 0; i < M; i++) parent[i] = i;
for (i = 1; i <= n; i++) {
if (f(i) == i) {
find_dia(i);
}
}
while (q--) {
int u, v;
scanf("%d", &t);
if (t == 1) {
scanf("%d", &u);
printf("%d\n", diameter[f(u)]);
} else {
scanf("%d%d", &u, &v);
molest(u, v);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace dsu {
vector<int> parent;
vector<int> depth;
vector<int> longest;
vector<int> deepest;
vector<int> size;
vector<int> batch;
int get_parent(int x);
void dfs(int root, vector<vector<int>> &adj) {
batch.push_back(root);
deepest[root] = 0;
longest[root] = 0;
vector<int> top(2, 0);
for (auto x : adj[root]) {
if (parent[x] == -1) {
parent[x] = get_parent(root);
depth[x] = depth[root] + 1;
dfs(x, adj);
longest[root] = max(longest[root], longest[x]);
if (top[0] > top[1]) {
top[1] = max(top[1], deepest[x] + 1);
} else {
top[0] = max(top[0], deepest[x] + 1);
}
deepest[root] = max(deepest[root], deepest[x] + 1);
}
}
longest[root] = max(longest[root], top[0] + top[1]);
}
void prepare(int n, vector<vector<int>> &adj) {
parent = vector<int>(n, -1);
depth = vector<int>(n, -1);
longest = vector<int>(n, -1);
deepest = vector<int>(n, -1);
size = vector<int>(n, -1);
vector<int> dist(n, -1);
for (int i = 0; i < n; i++) {
if (parent[i] == -1) {
parent[i] = i;
depth[i] = 0;
batch = vector<int>();
dfs(i, adj);
;
{ ; };
queue<int> q;
for (auto x : batch) {
dist[x] = -1;
if (adj[x].size() <= 1) {
;
q.push(x);
dist[x] = 0;
}
}
while (!q.empty()) {
int h = q.front();
q.pop();
for (auto x : adj[h]) {
if (dist[x] == -1) {
dist[x] = dist[h] + 1;
q.push(x);
}
}
}
int root = batch[0];
for (auto x : batch) {
if (dist[x] > dist[root]) {
root = x;
}
};
size[root] = batch.size();
for (auto x : batch) {
parent[x] = -1;
depth[x] = -1;
deepest[x] = -1;
longest[x] = -1;
}
parent[root] = root;
depth[root] = 0;
dfs(root, adj);
;
;
}
}
}
int get_parent(int x) {
if (x == parent[x]) {
return x;
}
return parent[x] = get_parent(parent[x]);
}
int longest_path(int x) { return longest[get_parent(x)]; }
void merge(int x, int y) {
int rootx = get_parent(x);
int rooty = get_parent(y);
if (rootx == rooty) {
return;
}
if (longest[rootx] > longest[rooty]) {
swap(rootx, rooty);
};
;
;
;
;
parent[rootx] = rooty;
longest[rooty] = max(max(longest[rooty], longest[rootx]),
(int)(ceil(longest[rootx] / 2.0)) + 1 +
(int)(ceil(longest[rooty] / 2.0)));
;
deepest[rooty] = max(deepest[rooty], deepest[rootx] + 1);
;
size[rooty] += size[rootx];
;
}
} // namespace dsu
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<vector<int>> adj(n);
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
dsu::prepare(n, adj);
if (n == 150000) {
}
while (q--) {
int t, x, y;
cin >> t;
if (t == 1) {
cin >> x;
x--;
cout << dsu::longest_path(x) << '\n';
} else {
cin >> x >> y;
x--, y--;
dsu::merge(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 300005;
int n, m, queries, now;
vector<int> g[Maxn];
int par[Maxn], d[Maxn];
inline int fnd(int x) { return x == par[x] ? x : par[x] = fnd(par[x]); }
void dfs(int u, int fa) {
par[u] = fa;
for (auto &v : g[u]) {
if (par[v]) continue;
dfs(v, fa);
now = max(now, d[u] + d[v] + 1);
d[u] = max(d[u], d[v] + 1);
}
}
int main(int argc, const char *argv[]) {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(12);
cin >> n >> m >> queries;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!par[i]) now = 0, dfs(i, i), d[i] = now;
while (queries--) {
int op, x;
cin >> op >> x;
if (op == 1)
cout << d[fnd(x)] << endl;
else {
int y;
cin >> y;
x = fnd(x), y = fnd(y);
if (x != y)
d[par[y] = x] =
max((d[x] + 1 >> 1) + (d[y] + 1 >> 1) + 1, max(d[x], d[y]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 10;
const int M = (int)1e7 + 10;
char ans[M];
int n, m, q, sz;
vector<int> g[N];
int parent[N], rang[N], diametr[N];
bool used[N];
pair<int, int> mx;
void dfs(int v, int prev = -1, int h = 0) {
mx = max(mx, make_pair(h, v));
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == prev) continue;
dfs(to, v, h + 1);
}
}
int get_tree_diametr(int v) {
mx = make_pair(-1, -1);
dfs(v);
v = mx.second;
mx = make_pair(-1, -1);
dfs(v);
return mx.first;
}
void make_set(int v) {
parent[v] = v;
rang[v] = 0;
diametr[v] = 0;
}
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void union_set1(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rang[a] < rang[b]) swap(a, b);
parent[b] = a;
if (rang[a] == rang[b]) rang[a]++;
}
}
void union_set2(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rang[a] < rang[b]) swap(a, b);
parent[b] = a;
if (rang[a] == rang[b]) rang[a]++;
diametr[a] = max(diametr[a],
max(diametr[b], diametr[a] / 2 + diametr[b] / 2 +
diametr[a] % 2 + diametr[b] % 2 + 1));
}
}
void to_str(int x) {
if (x == 0) {
ans[sz++] = '0';
ans[sz++] = '\n';
return;
}
int pp = sz;
while (x > 0) {
ans[sz++] += (x % 10 + '0');
x /= 10;
}
reverse(ans + pp, ans + sz);
ans[sz++] = '\n';
}
int main() {
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 x, y;
scanf("%d%d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
union_set1(x, y);
}
for (int i = 0; i < n; ++i) {
int s = find_set(i);
if (used[s]) continue;
used[s] = true;
diametr[s] = get_tree_diametr(i);
}
while (q--) {
int tp;
scanf("%d", &tp);
switch (tp) {
case 1: {
int x;
scanf("%d", &x);
x--;
to_str(diametr[find_set(x)]);
break;
}
case 2: {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
union_set2(x, y);
}
}
}
puts(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > forest(300005);
vector<int> dsu(300005);
vector<int> longest(300005);
vector<pair<int, int> > branches(300005);
int parent(int u) {
if (dsu[u] != u) dsu[u] = parent(dsu[u]);
return dsu[u];
}
int visit(int u, int m) {
int sz = forest[u].size();
dsu[u] = m;
int ret = 0;
for (int i = 0; i < sz; i++) {
int v = forest[u][i];
if (dsu[v] != 0) continue;
ret = max(ret, visit(v, m));
int b = 1 + branches[v].first;
if (b > branches[u].first) swap(b, branches[u].first);
if (b > branches[u].second) swap(b, branches[u].second);
}
return max(ret, branches[u].first + branches[u].second);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
dsu[i] = 0;
longest[i] = 0;
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
forest[a].push_back(b);
forest[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!dsu[i]) longest[i] = visit(i, i);
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
x = parent(x);
printf("%d\n", longest[x]);
} else {
int a, b;
scanf("%d%d", &a, &b);
a = parent(a);
b = parent(b);
if (a == b) continue;
int temp = (longest[a] + 1) / 2 + (longest[b] + 1) / 2 + 1;
temp = max(temp, longest[b]);
temp = max(temp, longest[a]);
dsu[a] = b;
longest[b] = temp;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
int n;
int pai[maxn], depth[maxn], depth2[maxn];
int find(int x) {
if (pai[x] == x) return x;
return pai[x] = find(pai[x]);
}
void join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (depth[x] < depth[y]) swap(x, y);
pai[y] = x;
if (depth[x] == depth[y])
depth2[x] = depth[x]++;
else
depth2[x] = max(depth2[x], depth[y] + 1);
}
vector<int> g[maxn];
bool mark[maxn];
int dist[maxn];
int bfs(int s) {
queue<int> q;
q.push(s);
int last;
while (!q.empty()) {
int u = q.front();
mark[u] = 1;
last = u;
q.pop();
for (auto v : g[u]) {
if (mark[v]) continue;
q.push(v);
}
}
return last;
}
int bfs2(int s) {
queue<int> q;
q.push(s);
int last;
while (!q.empty()) {
int u = q.front();
last = u;
q.pop();
for (auto v : g[u]) {
if (v == pai[u]) continue;
dist[v] = dist[u] + 1;
pai[v] = u;
q.push(v);
}
}
return last;
}
void init() {
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
int last = bfs(i);
pai[last] = last;
int other = bfs2(last);
depth[last] = (dist[other] + 1) / 2;
depth2[last] = dist[other] / 2;
}
}
}
int main() {
int m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = (0); i < (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
init();
while (q--) {
int t, a, b;
scanf("%d %d", &t, &a);
if (t == 1) {
printf("%d\n", depth[find(a)] + depth2[find(a)]);
} else {
scanf("%d", &b);
join(a, b);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[300005];
bool vis[300005];
int p[300005];
int val[300005];
int dp[2][300005];
int res = 0;
int root(int a) { return p[a] == a ? a : (p[a] = root(p[a])); }
void merge(int a, int b) {
a = root(a), b = root(b);
if (a != b) p[a] = b;
}
void dfs(int u, int p) {
vis[u] = 1;
dp[0][u] = 1;
vector<int> sz;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v]) continue;
dfs(v, u);
sz.push_back(dp[0][v]);
}
sort(sz.begin(), sz.end());
if (sz.size() >= 1) dp[0][u] = max(dp[0][u], sz[sz.size() - 1] + 1);
if (sz.size() >= 2)
dp[1][u] = max(dp[1][u], sz[sz.size() - 1] + sz[sz.size() - 2] + 1);
res = max(res, dp[0][u]);
res = max(res, dp[1][u]);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
merge(a, b);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
res = 0;
dfs(i, 0);
val[root(i)] = res - 1;
}
for (int i = 1; i <= q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
printf("%d\n", val[root(x)]);
} else {
int x, y;
scanf("%d%d", &x, &y);
if (root(x) == root(y)) continue;
int v1 = val[root(x)], v2 = val[root(y)];
merge(x, y);
val[root(x)] = max(max(v1, v2), (v1 + 1) / 2 + (v2 + 1) / 2 + 1);
}
}
}
|
#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>
using namespace std;
const long long mod = 1e9 + 7;
template <typename Arg1>
void pr(Arg1&& arg1) {
cout << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void pr(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
pr(args...);
}
template <typename Arg1>
void rd(Arg1& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void rd(Arg1& arg1, Args&... args) {
cin >> arg1;
rd(args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& p) {
out << p.first << " " << p.second;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
for (T i : v) {
out << i << " ";
}
return out;
}
template <typename Arg1>
void deb(const char* name, Arg1&& arg1) {
cout << name << " = " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void deb(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " = " << arg1;
deb(comma, args...);
}
const long long mxn = 300500;
long long parent[mxn], dia[mxn];
vector<vector<long long> > g;
long long mxv, mxi;
void init() {
for (long long i = 0; i < mxn; ++i) {
parent[i] = i;
dia[i] = 0;
}
}
long long find(long long u) {
if (parent[u] == u) {
return u;
}
return parent[u] = find(parent[u]);
}
void uni(long long u, long long v) {
u = find(u);
v = find(v);
if (u == v) return;
parent[u] = v;
}
void uni2(long long u, long long v) {
u = find(u);
v = find(v);
if (u == v) return;
parent[u] = v;
dia[v] = ((dia[u] > dia[v] ? dia[u] : dia[v]) >
((dia[u] + 1) / 2) + ((dia[v] + 1) / 2) + 1
? (dia[u] > dia[v] ? dia[u] : dia[v])
: ((dia[u] + 1) / 2) + ((dia[v] + 1) / 2) + 1);
}
void dfs(long long cur, long long par, long long dep) {
if (dep > mxi) {
mxi = dep;
mxv = cur;
}
for (long long i : g[cur]) {
if (i != par) {
dfs(i, cur, dep + 1);
}
}
}
long long Dia(long long u) {
mxi = -1;
dfs(u, 0, 0);
mxi = -1;
dfs(mxv, 0, 0);
return mxi;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, q;
cin >> n >> m >> q;
init();
g = vector<vector<long long> >(n + 1, vector<long long>());
for (long long i = 0; i < m; ++i) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
uni(u, v);
}
vector<long long> vis(n + 1, 0);
for (long long i = 0; i < n; ++i) {
long long pp = find(i);
if (!vis[pp]) {
dia[pp] = Dia(pp);
vis[pp] = 1;
}
}
while (q--) {
long long tp, x, y;
cin >> tp;
if (tp == 1) {
cin >> x;
cout << dia[find(x)] << '\n';
} else {
cin >> x >> y;
uni2(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long exponent, long long modulus) {
if (base == 0 && exponent == 0) return 0;
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
int a[3 * 100004];
int Rank[3 * 100004];
int n, i, m, x, y;
vector<vector<int> > Adj(3 * 100004);
int find(int x) {
if (a[x] == x)
return x;
else {
int u = find(a[x]);
a[x] = u;
return u;
}
}
void unii(int x, int y) {
int ff = x;
int gg = y;
if (Rank[ff] > Rank[gg]) {
a[ff] = gg;
} else if (Rank[ff] < Rank[gg])
a[gg] = ff;
else {
a[ff] = gg;
Rank[gg]++;
}
}
bool visit[3 * 100004];
bool visit1[3 * 100004];
int Dis[3 * 100004];
int Comp[3 * 100004];
int best[3 * 100004];
inline void ReadInput(void) {}
int Max_Dis = -1;
int Com = 1;
vector<int> tmp;
int Con;
void dfs(int node, int lev) {
tmp.push_back(node);
visit[node] = true;
Dis[node] = lev;
Comp[node] = Com;
if (Max_Dis < Dis[node]) {
Con = node;
Max_Dis = Dis[node];
}
for (int i = (0); i < (Adj[node].size()); i++) {
if (!visit[Adj[node][i]]) {
dfs(Adj[node][i], lev + 1);
}
}
}
void dfs1(int node, int lev) {
tmp.push_back(node);
visit1[node] = true;
Dis[node] = lev;
Comp[node] = Com;
if (Max_Dis < Dis[node]) {
Con = node;
Max_Dis = Dis[node];
}
for (int i = (0); i < (Adj[node].size()); i++) {
if (!visit1[Adj[node][i]]) {
dfs1(Adj[node][i], lev + 1);
}
}
}
void pre() {
fill(visit, visit + 3 * 100004, false);
fill(visit1, visit1 + 3 * 100004, false);
for (int i = 0; i < n; i++) {
tmp.clear();
if (!visit[i]) {
Max_Dis = -1;
dfs(i, 0);
dfs1(Con, 0);
best[Com] = Max_Dis;
Com++;
}
}
}
inline void solve(void) {
for (int i = (0); i < (3 * 100004 - 1); i++) {
a[i] = i;
Rank[i] = 0;
}
int q;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (int i = (0); i < (m); i++) {
scanf("%d", &x);
scanf("%d", &y);
x--;
y--;
Adj[x].push_back(y);
Adj[y].push_back(x);
}
pre();
int tell;
while (q--) {
scanf("%d", &tell);
if (tell == 2) {
scanf("%d", &x);
scanf("%d", &y);
x--;
y--;
Comp[x] = find(Comp[x]);
Comp[y] = find(Comp[y]);
int c1 = Comp[x];
int c2 = Comp[y];
if (c1 == c2) continue;
int d1 = best[Comp[x]];
int d2 = best[Comp[y]];
if (d1 % 2 == 0)
d1 /= 2;
else
d1 = d1 / 2 + 1;
if (d2 % 2 == 0)
d2 /= 2;
else
d2 = d2 / 2 + 1;
int make =
((best[Comp[x]]) > (best[Comp[y]]) ? best[Comp[x]] : best[Comp[y]]);
make = ((d1 + 1 + d2) > (make) ? d1 + 1 + d2 : make);
if (best[Comp[x]] == 1 and best[Comp[y]] == 2) make = 3;
if (best[Comp[x]] == 2 and best[Comp[y]] == 1) make = 3;
if (best[Comp[x]] == 1 and best[Comp[y]] == 1) make = 3;
unii(Comp[x], Comp[y]);
best[find(Comp[y])] = make;
}
if (tell == 1) {
scanf("%d", &x);
x--;
x = find(Comp[x]);
printf("%d\n", best[x]);
}
}
}
int main(int argc, const char* argv[]) {
ReadInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
int n, m, q;
int fa[maxn], Ans[maxn];
int find(int i) { return fa[i] == i ? i : fa[i] = find(fa[i]); }
vector<int> G[maxn], V;
queue<int> Q;
int dis[maxn], vi[maxn];
int solve(int s) {
V.clear();
V.push_back(s);
Q.push(s);
dis[s] = 1;
vi[s] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto v : G[u])
if (!vi[v]) {
dis[v] = dis[u] + 1;
Q.push(v);
V.push_back(v);
vi[v] = 1;
}
}
int u = s;
for (auto i : V)
if (dis[i] > dis[u]) u = i;
for (auto i : V) dis[i] = 0;
Q.push(u);
dis[u] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto v : G[u])
if (!dis[v]) {
dis[v] = dis[u] + 1;
Q.push(v);
}
}
int v = u;
for (auto i : V)
if (dis[i] > dis[v]) v = i;
for (auto i : V) vi[i] = 0;
return dis[v] - 1;
}
void Work() {
while (q--) {
int opt, x, y;
scanf("%d", &opt);
if (opt == 1) {
scanf("%d", &x);
printf("%d\n", Ans[find(x)]);
} else {
scanf("%d%d", &x, &y);
x = find(x);
y = find(y);
if (find(x) == find(y)) continue;
fa[x] = y;
Ans[y] =
max(max(Ans[x], Ans[y]), (Ans[x] + 1) / 2 + (Ans[y] + 1) / 2 + 1);
}
}
}
void Init() {
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);
fa[find(u)] = find(v);
}
for (int i = 1; i <= n; i++)
if (find(i) == i) Ans[i] = solve(i);
}
int main() {
Init();
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600005;
int v[N], nxt[N], fir[N], n, m, f[N], dis[N], dep[N], p, maxn, idx, q, vis[N],
vis2[N];
void add(int x, int y) {
v[++idx] = y;
nxt[idx] = fir[x];
fir[x] = idx;
}
void init() {
for (int i = 1; i <= n; i++) f[i] = i;
}
int find(int x) {
if (f[x] == x)
return x;
else {
f[x] = find(f[x]);
return f[x];
}
}
void merge(int a, int b) {
int x = find(a);
int y = find(b);
f[x] = y;
}
void dfs(int x, int fa, int len) {
if (len > maxn) {
maxn = len;
p = x;
}
for (int i = fir[x]; i; i = nxt[i]) {
int to = v[i];
if (to == fa) continue;
dfs(to, x, len + 1);
}
}
int main() {
cin >> n >> m >> q;
init();
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
merge(x, y);
}
for (int i = 1; i <= n; i++) {
int x = find(i);
if (vis2[x]) continue;
maxn = -1;
dfs(x, 0, 0);
maxn = -1;
dfs(p, 0, 0);
vis2[x] = 1;
dis[x] = maxn;
}
for (int i = 1; i <= q; i++) {
int opt, x, y;
scanf("%d", &opt);
if (opt == 1) {
scanf("%d", &x);
cout << dis[find(x)] << endl;
} else {
scanf("%d%d", &x, &y);
if (find(x) == find(y))
continue;
else {
dis[find(y)] =
max(max((dis[find(x)] + 1) / 2 + (dis[find(y)] + 1) / 2 + 1,
dis[find(x)]),
dis[find(y)]);
merge(x, y);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int t, next;
} e[2 * 300100];
int ek = 0;
int n, m, q;
int first[300100] = {}, l[300100] = {}, dep[300100], mdep = 0;
int ds[300100];
bool vis[300100];
void addEdge(int a, int b) {
e[++ek].t = a;
e[ek].next = first[b];
first[b] = ek;
e[++ek].t = b;
e[ek].next = first[a];
first[a] = ek;
}
int find(int x) {
if (ds[x] == x) return x;
int tmp = find(ds[x]);
return ds[x] = tmp;
}
void uni(int f, int t) { ds[find(f)] = find(t); }
void dfs(int x, int f, int r) {
vis[x] = 1;
for (int it = first[x]; it > 0; it = e[it].next) {
int u = e[it].t;
if (u == f) continue;
dep[u] = dep[x] + 1;
dfs(u, x, r);
}
if (dep[x] > dep[mdep]) mdep = x;
uni(x, r);
}
int main(int argc, const char *argv[]) {
int a, b, op, x, y;
int k;
memset(vis, 0, sizeof(vis));
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
addEdge(a, b);
}
for (int i = 1; i <= n; i++) ds[i] = i;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
dep[i] = 0;
mdep = i;
dep[mdep] = 0;
dfs(i, -1, i);
dep[mdep] = 0;
dfs(mdep, -1, i);
l[find(i)] = dep[mdep];
}
for (int i = 1; i <= q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &x);
printf("%d\n", l[find(x)]);
} else {
scanf("%d%d", &x, &y);
if (find(x) == find(y)) continue;
if (l[find(x)] < l[find(y)]) swap(x, y);
int tmp = l[find(x)] % 2 == 0 ? l[find(x)] / 2 : l[find(x)] / 2 + 1;
tmp += l[find(y)] % 2 == 0 ? l[find(y)] / 2 : l[find(y)] / 2 + 1;
tmp += 1;
l[find(x)] = max(l[find(x)], tmp);
uni(y, x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[300005];
int l[300005];
int r[300005];
bool u2[2][300006];
int d2[2][300005];
int p[300005];
vector<int> vis;
vector<int> g[300005];
int getPar(int v) { return par[v] = (v == par[v] ? v : getPar(par[v])); }
void uni(int a, int b) {
a = getPar(a), b = getPar(b);
if (a == b) return;
if (max(l[a], r[a]) < max(l[b], r[b])) swap(a, b);
par[b] = a;
int la = max(l[a], r[a]);
int ra = max(min(l[a], r[a]), max(l[b], r[b]) + 1);
l[a] = la, r[a] = ra;
}
int bfs(int s, bool* u, int* d) {
vis.clear();
queue<int> q;
q.push(s);
u[s] = 1;
int last = s;
while (q.size() > 0) {
int v = q.front();
q.pop();
last = v;
vis.push_back(v);
for (int i = 0; i < g[v].size(); i++) {
if (!u[g[v][i]]) {
u[g[v][i]] = 1;
q.push(g[v][i]);
d[g[v][i]] = d[v] + 1;
p[g[v][i]] = v;
}
}
}
return last;
}
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);
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 1; i <= n; i++) {
if (!u2[0][i]) {
int last = bfs(i, u2[0], d2[0]);
int last2 = bfs(last, u2[1], d2[1]);
int len = d2[1][last2];
int v = last2;
while (v != last && d2[1][v] != len / 2) v = p[v];
l[v] = len / 2;
r[v] = len - len / 2;
for (int i = 0; i < vis.size(); i++) par[vis[i]] = v;
}
}
for (int i = 0; i < q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int x;
scanf("%d", &x);
x = getPar(x);
printf("%d\n", l[x] + r[x]);
} else {
int x, y;
scanf("%d%d", &x, &y);
uni(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int MOD = 1000000;
const int N = 3e5 + 15;
const int maxn = 2000 + 15;
const int INF = (1 << 30) - 1;
const int letter = 130;
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, q, head[N], tot = 0, father[N], dis[N], aim, vis[N];
struct edges {
int to, next;
} e[N << 1];
queue<pair<int, int>> que;
void addedge(int u, int v) {
e[tot].to = v;
e[tot].next = head[u];
head[u] = tot++;
}
int Find(int x) {
if (x == father[x]) return x;
return father[x] = Find(father[x]);
}
void init(int n) {
memset(head, -1, sizeof(head)), tot = 0;
for (int i = 1; i <= n; i++) father[i] = i, dis[i] = -1;
memset(vis, 0, sizeof(vis));
}
int bfs(int f, int num) {
while (!que.empty()) que.pop();
int ans = 0;
que.push(make_pair(f, 0));
vis[f] = num;
int x, to, val;
while (!que.empty()) {
x = que.front().first, val = que.front().second;
que.pop();
for (int i = head[x]; i != -1; i = e[i].next) {
to = e[i].to;
if (vis[to] != num) {
vis[to] = num;
ans = max(ans, val + 1);
que.push(make_pair(to, val + 1));
aim = to;
}
}
}
return ans;
}
int main() {
n = read(), m = read(), q = read();
int x, y, xx, yy, id;
init(n);
for (int i = 0; i < m; i++) {
x = read(), y = read();
xx = Find(x), yy = Find(y);
if (xx != yy) {
father[xx] = yy;
}
addedge(x, y);
addedge(y, x);
}
for (int i = 1; i <= n; i++) {
xx = Find(i);
if (dis[xx] == -1) {
bfs(xx, 1);
dis[xx] = bfs(aim, 2);
}
}
for (int i = 0; i < q; i++) {
id = read(), x = read();
if (id == 1) {
printf("%d\n", dis[Find(x)]);
} else {
y = read();
xx = Find(x), yy = Find(y);
if (xx == yy) continue;
if (dis[xx] > dis[yy]) swap(xx, yy);
father[xx] = yy;
dis[yy] = max(dis[yy], 1 + dis[yy] / 2 + dis[xx] / 2 +
(dis[yy] % 2 ? 1 : 0) + (dis[xx] % 2 ? 1 : 0));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[300010];
bool vst[300010];
int dp[300010][2];
int root[300010];
int cnt[300010];
int dst[300010];
int find_root(int u) {
if (root[u] == u) return u;
return root[u] = find_root(root[u]);
}
void reunion(int u, int v) {
u = find_root(u);
v = find_root(v);
if (u == v) return;
if (cnt[u] < cnt[v]) swap(u, v);
cnt[u] += cnt[v];
root[v] = u;
dst[u] = max(dst[u], (dst[u] + 1) / 2 + (dst[v] + 1) / 2 + 1);
dst[u] = max(dst[u], dst[v]);
}
int val;
void dfs(int u, int fa = 0) {
vst[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
dfs(v, u);
}
vector<int> vt;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
vt.push_back(dp[v][0]);
}
sort(vt.begin(), vt.end());
reverse(vt.begin(), vt.end());
if (vt.size()) dp[u][0] = vt[0] + 1;
if (vt.size() > 1) dp[u][1] = vt[1] + 1;
val = max(val, dp[u][0] + dp[u][1]);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) root[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);
reunion(u, v);
}
for (int i = 1; i <= n; i++) {
if (!vst[i]) {
val = 0;
dfs(i);
int fa = find_root(i);
dst[fa] = val;
}
}
while (q--) {
int ok;
scanf("%d", &ok);
if (ok == 2) {
int u, v;
scanf("%d%d", &u, &v);
reunion(u, v);
} else {
int u;
scanf("%d", &u);
u = find_root(u);
printf("%d\n", dst[u]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void MP() {
ios::sync_with_stdio(false);
cin.tie(0);
}
const long long MAX = (long long)3e5 + 15;
const long long MAX2 = 25;
const long long inf = (long long)2e17 + 9;
const long double EPS = 1e-5;
const long long sigma = 128;
const long long delta = (long long)1e6 + 3;
const long long MAXB = (1 * 20);
inline bool gt(long long a, long long i) { return (a >> i) & 1; }
const long long MOD = (long long)1e9 + 7;
const long long P = (long long)1e9;
mt19937_64 rnd(time(0));
long long p[MAX], len[MAX], f[MAX];
void __init(long long a) {
p[a] = a;
f[a] = len[a] = 1;
}
long long find_set(long long a) {
return p[a] == a ? a : p[a] = find_set(p[a]);
}
bool OK = false;
void union_set(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
p[b] = a;
len[a] += len[b];
if (OK) f[a] = max({(f[a] + 1) / 2 + (f[b] + 1) / 2 + 1, f[a], f[b]});
}
vector<long long> g[MAX];
long long cnt[MAX];
long long tmr = 0;
long long find_diametr(long long a) {
a = find_set(a);
queue<long long> q;
q.push(a);
++tmr;
long long lv;
while (!q.empty()) {
long long v = q.front();
q.pop();
cnt[v] = tmr;
lv = v;
for (long long to : g[v]) {
if (cnt[to] != tmr) {
q.push(to);
}
}
}
queue<pair<long long, long long> > qs;
qs.push({lv, 0});
lv = 0;
++tmr;
while (!qs.empty()) {
long long v = qs.front().first;
lv = qs.front().second + 1;
qs.pop();
cnt[v] = tmr;
for (long long to : g[v]) {
if (cnt[to] != tmr) {
qs.push({to, lv});
}
}
}
return lv;
}
void solve() {
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 0; i < n; ++i) __init(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_set(a, b);
}
for (long long i = 0; i < n; ++i) {
if (!cnt[i]) {
f[find_set(i)] = find_diametr(i) - 1;
}
}
OK = true;
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long x;
cin >> x;
cout << (f[find_set(--x)]) << '\n';
} else {
long long a, b;
cin >> a >> b;
union_set(--a, --b);
}
}
}
signed main() {
MP();
solve();
}
|
#include <bits/stdc++.h>
const int N = (int)3e5 + 228;
using namespace std;
int n, m, q, pr[N], d[N], sz[N];
vector<int> g[N];
void build() {
for (int i = 1; i <= n; i++) pr[i] = i, sz[i] = 1, d[i] = 0;
}
int get(int v) {
if (pr[v] == v) return v;
return pr[v] = get(pr[v]);
}
void merge(int v, int u) {
v = get(v), u = get(u);
if (v == u) return;
if (sz[v] > sz[u]) {
d[v] = max({d[v], d[u], (d[v] + 1) / 2 + (d[u] + 1) / 2 + 1});
sz[v] += sz[u];
pr[u] = v;
} else {
d[u] = max({d[v], d[u], (d[v] + 1) / 2 + (d[u] + 1) / 2 + 1});
pr[v] = u;
sz[u] += sz[v];
}
}
void dfs(int v, int depth, int pr, int& res, int& u) {
if (depth > res) res = depth, u = v;
for (auto to : g[v]) {
if (to == pr) continue;
dfs(to, depth + 1, v, res, u);
}
}
int getDiag(int v) {
int res = 0, u = v;
dfs(v, 0, -1, res, u);
res = 0, v = u;
dfs(v, 0, -1, res, u);
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
build();
for (int i = 1; i <= m; i++) {
int v, u;
scanf("%d%d", &v, &u);
merge(v, u);
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 1; i <= n; i++)
if (pr[i] == i) d[i] = getDiag(i);
for (int i = 1; i <= q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int v;
scanf("%d", &v);
v = get(v);
printf("%d\n", d[v]);
} else {
int v, u;
scanf("%d%d", &v, &u);
merge(v, u);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e6 + 10;
struct edge {
int ver, nxt;
} e[MAXN];
int n, m, q, f[MAXN], maxn, dis[MAXN], st;
int cnt, head[MAXN];
bool vis[MAXN], vis2[MAXN];
void add(int u, int v) {
e[++cnt].ver = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
f[x] = y;
}
void dfs(int u, int val) {
int i;
if (maxn < val) {
maxn = val;
st = u;
}
for (i = head[u]; i; i = e[i].nxt) {
int v = e[i].ver;
if (!vis[v]) {
vis[v] = true;
dfs(v, val + 1);
}
}
vis[u] = false;
}
void dfs2(int u, int val) {
int i;
if (maxn < val) maxn = val;
for (i = head[u]; i; i = e[i].nxt) {
int v = e[i].ver;
if (!vis[v]) {
vis[v] = true;
dfs2(v, val + 1);
}
}
vis[u] = false;
}
int main() {
int i;
scanf("%d %d %d", &n, &m, &q);
for (i = 1; i <= n; i++) f[i] = i;
for (i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
add(u, v);
add(v, u);
merge(u, v);
}
for (i = 1; i <= n; i++) {
int u = find(i);
if (vis2[u]) continue;
maxn = -1;
vis[u] = true;
dfs(u, 0);
maxn = -1;
vis[st] = true;
dfs2(st, 0);
vis2[u] = true;
dis[u] = maxn;
}
for (i = 1; i <= q; i++) {
int op, u, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d", &u);
u = find(u);
printf("%d\n", dis[u]);
} else {
scanf("%d %d", &u, &v);
u = find(u);
v = find(v);
if (u == v) continue;
dis[v] =
max(max((dis[u] + 1) / 2 + (dis[v] + 1) / 2 + 1, dis[u]), dis[v]);
merge(u, v);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 300005;
using namespace std;
int pre[maxn], dis[maxn], len[maxn];
vector<int> G[maxn];
void add(int u, int v) { G[u].push_back(v); }
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
int S, ffa;
void dfs(int u, int fa) {
pre[u] = ffa;
dis[u] = dis[fa] + 1;
if (dis[u] > dis[S]) S = u;
for (auto x : G[u]) {
if (x == fa) continue;
dfs(x, u);
}
}
void solve(int x) {
ffa = x, S = 0;
dfs(x, 0);
dfs(S, 0);
len[x] = dis[S] - 1;
}
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) pre[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!dis[i]) {
solve(i);
}
}
while (q--) {
int op, u, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d", &u);
printf("%d\n", len[find(u)]);
} else {
scanf("%d %d", &u, &v);
int fx = find(u);
int fy = find(v);
if (fx == fy) continue;
pre[fx] = fy;
int ans =
max(max(len[fx], len[fy]), (len[fx] + 1) / 2 + (len[fy] + 1) / 2 + 1);
len[fy] = ans;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const long double DEL = 1e-12;
const int mod = 1000000007;
const int LIM = 100005;
int fpow(int x, int n) {
int res = 1;
while (n) {
if (n & 1) {
res = res * x % mod;
}
x = x * x % mod;
n >>= 1;
}
return res;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sieve(int n) {
bool prime[5 * LIM];
memset(prime, true, sizeof(prime));
int rootn = (int)sqrt(n);
for (int p = 2; p <= rootn; p++)
if (prime[p] == true)
for (int i = p * p; i <= n; i += p) prime[i] = false;
prime[1] = 0;
}
int cnt, sum, mid, mx, mn, a[3 * LIM];
int n, m, d, q, t, i, j, k, l, r, x, y, z;
bool f, f1, f2;
string s;
vector<vector<int>> v(3 * LIM);
vector<bool> vis(3 * LIM);
int boss, corner;
vector<int> ans(3 * LIM);
void dfs(int i, int len, int par) {
vis[i] = 1;
a[i] = boss;
if (len > l) {
corner = i;
l = len;
}
for (auto j : v[i]) {
if (j != par) {
dfs(j, (len + 1), i);
}
}
}
int bossof(int i) {
while (i != a[i]) {
a[i] = a[a[i]];
i = a[i];
}
return i;
}
void unite(int x, int y) {
x = bossof(x);
y = bossof(y);
ans[x] = max(max(ans[x], ans[y]), 1 + (ans[x] + 1) / 2 + (ans[y] + 1) / 2);
a[y] = x;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
while (m--) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for ((i) = 1; (i) <= (n); (i)++) {
if (!vis[i]) {
boss = i;
l = -1;
dfs(i, 0, 0);
l = -1;
dfs(corner, 0, 0);
ans[i] = l;
}
}
while (q--) {
cin >> z;
if (z == 1) {
cin >> x;
cout << ans[bossof(x)];
cout << "\n";
} else {
cin >> x >> y;
if (bossof(x) != bossof(y)) {
unite(x, y);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = 50000000;
const int maxn = 300010;
int rnk[maxn], parent[maxn], diameter[maxn], seen[maxn], dist[maxn], n;
vector<int> adj[maxn], vis;
int find(int x) {
if (parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
void merge(int x, int y) {
int rx, ry, d1, d2, d;
rx = find(x);
ry = find(y);
if (rx == ry) return;
d1 = diameter[rx];
d2 = diameter[ry];
d = max(d1, max(d2, (d1 + 1) / 2 + (d2 + 1) / 2 + 1));
if (rnk[rx] < rnk[ry]) {
parent[rx] = ry;
diameter[ry] = d;
} else if (rnk[ry] < rnk[rx]) {
parent[ry] = rx;
diameter[rx] = d;
} else {
parent[ry] = rx;
rnk[rx]++;
diameter[rx] = d;
}
}
void dfs(int cur, int p, int d) {
dist[cur] = d;
seen[cur] = 1;
vis.push_back(cur);
for (auto it : adj[cur]) {
if (it != p) dfs(it, cur, d + 1);
}
}
int find_diameter(int src) {
int j, ind, mxd;
vis.clear();
dfs(src, 0, 0);
mxd = 0;
ind = src;
for (auto i : vis) {
if (dist[i] > mxd) {
mxd = dist[i];
ind = i;
}
dist[i] = inf;
}
dfs(ind, 0, 0);
mxd = 0;
for (auto i : vis) {
if (dist[i] > mxd) mxd = dist[i];
}
return mxd;
}
int main() {
int t, m, q, i, u, v;
scanf("%d%d%d", &n, &m, &q);
for (i = 1; i <= n; i++) parent[i] = i;
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
merge(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (i = 1; i <= n; i++) {
if (!seen[i]) {
v = find(i);
diameter[v] = find_diameter(i);
}
}
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &u);
v = find(u);
printf("%d\n", diameter[v]);
} else {
scanf("%d%d", &u, &v);
merge(u, v);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void MP() {
ios::sync_with_stdio(false);
cin.tie(0);
}
const long long MAX = (long long)3e5 + 15;
const long long MAX2 = 25;
const long long inf = (long long)2e17 + 9;
const long double EPS = 1e-5;
const long long sigma = 128;
const long long delta = (long long)1e6 + 3;
const long long MAXB = (1 * 20);
inline bool gt(long long a, long long i) { return (a >> i) & 1; }
const long long MOD = (long long)1e9 + 7;
const long long P = (long long)1e9;
mt19937_64 rnd(time(0));
long long p[MAX], len[MAX], f[MAX];
void __init(long long a) {
p[a] = a;
f[a] = len[a] = 1;
}
long long find_set(long long a) {
return p[a] == a ? a : p[a] = find_set(p[a]);
}
bool OK = false;
void union_set(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
if (len[a] < len[b]) swap(a, b);
p[b] = a;
len[a] += len[b];
if (OK) f[a] = max({(f[a] + 1) / 2 + (f[b] + 1) / 2 + 1, f[a], f[b]});
}
vector<long long> g[MAX];
long long cnt[MAX];
long long tmr = 0;
long long find_diametr(long long a) {
a = find_set(a);
queue<long long> q;
q.push(a);
++tmr;
long long lv;
while (!q.empty()) {
long long v = q.front();
q.pop();
cnt[v] = tmr;
lv = v;
for (long long to : g[v]) {
if (cnt[to] != tmr) {
q.push(to);
}
}
}
queue<pair<long long, long long> > qs;
qs.push({lv, 0});
lv = 0;
++tmr;
while (!qs.empty()) {
long long v = qs.front().first;
lv = qs.front().second + 1;
qs.pop();
cnt[v] = tmr;
for (long long to : g[v]) {
if (cnt[to] != tmr) {
qs.push({to, lv});
}
}
}
return lv;
}
void solve() {
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 0; i < n; ++i) __init(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_set(a, b);
}
for (long long i = 0; i < n; ++i) {
if (!cnt[i]) {
f[find_set(i)] = find_diametr(i) - 1;
}
}
OK = true;
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long x;
cin >> x;
cout << (f[find_set(--x)]) << '\n';
} else {
long long a, b;
cin >> a >> b;
union_set(--a, --b);
}
}
}
signed main() {
MP();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
bool v[N];
int n, m, q, f[N], x, y, d[N], M, g[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, int f) {
v[k] = true;
for (int i = 0; i < a[k].size(); i++)
if (a[k][i] != f) {
d[a[k][i]] = d[k] + 1;
if (d[a[k][i]] > d[M]) M = a[k][i];
D(a[k][i], k);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) f[i] = i;
while (m-- && cin >> x >> y) {
a[x].push_back(y), a[y].push_back(x), x = F(x), y = F(y);
if (x != y) f[y] = x;
}
for (int i = 1; i <= n; i++)
if (!v[i]) d[i] = 0, M = i, D(i, 0), d[M] = 0, D(M, 0), g[F(i)] = d[M];
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 n, m, q, Root, Max, City;
vector<int> c[300010];
int R[300010], LP[300010], ok[300010];
void DFS(int u, int lv, int m) {
R[u] = Root;
if (lv > Max) {
Max = lv;
City = u;
}
ok[u] = m + 1;
for (int i = 0; i < (int)c[u].size(); i++) {
int v = c[u][i];
if (ok[v] <= m) DFS(v, lv + 1, m);
}
}
int Getroot(int x) { return (x == R[x]) ? x : (R[x] = Getroot(R[x])); }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
c[a].push_back(b);
c[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (!ok[i]) {
Root = i;
Max = -1;
DFS(i, 0, 0);
Max = -1;
DFS(City, 0, 1);
LP[i] = Max;
}
for (int i = 1; i <= q; i++) {
int type, x, y;
scanf("%d", &type);
if (type == 1) {
scanf("%d", &x);
printf("%d\n", LP[Getroot(x)]);
} else {
scanf("%d%d", &x, &y);
x = Getroot(x);
y = Getroot(y);
if (x == y) continue;
int l = max(LP[x], LP[y]);
R[x] = y;
LP[y] = max((LP[y] + 1) / 2 + (LP[x] + 1) / 2 + 1, l);
}
}
return 0;
}
|
#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];
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;
}
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;
n = nextInt();
m = nextInt();
q = nextInt();
for (int i = 1; i <= n; ++i) par[i] = i;
while (m--) {
int a, b;
a = nextInt();
b = nextInt();
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;
c = nextInt();
a = nextInt();
if (c == 1)
printf("%d\n", diameter[find_set(a)]);
else {
b = nextInt();
__union(a, b);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long N = 3e5 + 7;
long long par[N], dp[N], p, l;
vector<long long> di[N];
long long root(long long x) {
if (x == par[x]) return x;
return par[x] = root(par[x]);
}
inline void unite(long long x, long long y) {
x = root(x);
y = root(y);
par[y] = x;
}
inline void dfs(long long v, long long parent = -1, long long dis = 0) {
if (parent == -1) l = 0;
if (dis >= l) p = v, l = dis;
for (auto u : di[v])
if (u != parent) dfs(u, v, dis + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, q, i, j, v, u, t;
cin >> n >> m >> q;
for (i = 0; i < n; i++) par[i] = i;
for (i = 0; i < m; i++) {
cin >> v >> u;
v--, u--;
di[v].push_back(u);
di[u].push_back(v);
unite(v, u);
}
for (i = 0; i < n; i++)
if (root(i) == i) dfs(i), dfs(p), dp[i] = l;
while (q--) {
cin >> t;
if (t == 1) {
cin >> v;
v--;
cout << dp[root(v)] << '\n';
} else {
cin >> v >> u;
v--, u--;
v = root(v);
u = root(u);
if (v == u) continue;
unite(v, u);
dp[v] = max(max(dp[v], dp[u]), ((dp[v] + 1) / 2) + ((dp[u] + 1) / 2) + 1);
}
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 300007;
struct Star {
int y, nx;
} E[MX << 1];
int H[MX], ecnt;
void add(int x, int y) {
ecnt++, E[ecnt].y = y, E[ecnt].nx = H[x], H[x] = ecnt;
}
int N, M, Q;
int D, Dx;
void dfs(int x, int f, int d) {
if (D < d) D = d, Dx = x;
for (int i = H[x]; i; i = E[i].nx)
if (E[i].y != f) dfs(E[i].y, x, d + 1);
}
void find(int x) {
D = -1, dfs(x, 0, 0);
D = -1, dfs(Dx, 0, 0);
}
struct Bcj {
int f[MX], d[MX], sz[MX];
void init() {
for (int i = (1); i <= (N); i++) f[i] = i, sz[i] = 1;
}
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void uset(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
f[x] = y, sz[y] += sz[x];
d[y] = max(max(d[x], d[y]), (d[x] + 1) / 2 + (d[y] + 1) / 2 + 1);
}
} bcj;
int main() {
scanf("%d%d%d", &N, &M, &Q);
int a, b, c;
bcj.init();
for (int i = (1); i <= (M); i++) {
scanf("%d%d", &a, &b);
add(a, b), add(b, a), bcj.uset(a, b);
}
for (int i = (1); i <= (N); i++)
if (bcj.f[i] == i) find(i), bcj.d[i] = D;
for (int i = (1); i <= (Q); i++) {
scanf("%d%d", &a, &b);
if (a == 1)
printf("%d\n", bcj.d[bcj.find(b)]);
else
scanf("%d", &c), bcj.uset(b, c);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300005];
int par[300005];
int dia[300005];
int no;
int vis[2][300005];
int root(int b) {
while (b != par[b]) {
par[b] = par[par[b]];
b = par[b];
}
return b;
}
void un(int c, int b) {
if (root(c) != root(b)) {
par[root(c)] = par[root(b)];
}
}
int ed;
int flg = 0;
int mx;
int bst;
void dfs(int a, int b, int dep) {
mx = max(mx, dep);
vis[b][a] = 1;
if (dep > bst) {
bst = dep, ed = a;
}
for (auto j : v[a]) {
if (!vis[b][j]) {
vis[b][j] = 1;
dfs(j, b, dep + 1);
}
}
if (flg == 0) {
flg = 1;
ed = a;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) par[i] = i;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
un(a, b);
v[a].emplace_back(b);
v[b].emplace_back(a);
}
for (int i = 1; i <= n; i++) {
if (!vis[0][i]) {
mx = 0, bst = -1, ed = -1;
dfs(i, 0, 0);
mx = 0, bst = -1;
dfs(ed, 1, 0);
flg = 0;
dia[root(i)] = mx;
mx = 0;
}
}
int c;
for (int i = 0; i < q; i++) {
cin >> a;
if (a == 1) {
cin >> b;
cout << dia[root(b)] << "\n";
} else {
cin >> b >> c;
if (root(b) != root(c)) {
int f = dia[root(b)];
int h = dia[root(c)];
double s = ceil(f / 2.0);
double x = ceil(h / 2.0);
int g = max(f, max(h, ((int)s + (int)x + 1)));
un(b, c);
dia[root(b)] = g;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[300008], sz[300008], lpath[300008];
int n, m, q;
vector<int> v[300008];
void init() {
for (int i = 0; i < 300008; i++) {
parent[i] = i;
sz[i] = 1;
lpath[i] = 0;
}
}
int find(int i) {
if (i == parent[i]) return i;
return parent[i] = find(parent[i]);
}
inline void Union(int x, int y) {
int xpar = find(x);
int ypar = find(y);
if (xpar == ypar) return;
if (sz[ypar] > sz[xpar]) swap(xpar, ypar);
parent[ypar] = xpar;
sz[xpar] += sz[ypar];
lpath[xpar] = max((lpath[xpar] + 1) / 2 + (lpath[ypar] + 1) / 2 + 1,
max(lpath[xpar], lpath[ypar]));
}
int NN, DD, vis[300008];
void dfs(int u, int p, int d) {
if (d >= DD) {
NN = u;
DD = d;
}
vis[u] = 1;
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i];
if (x == p) continue;
vis[x] = 1;
dfs(x, u, d + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
init();
cin >> n >> m >> q;
while (m--) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
Union(a, b);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
DD = 0;
dfs(i, 0, 0);
DD = 0;
dfs(NN, 0, 0);
lpath[find(i)] = DD;
}
while (q--) {
int ty, a, b;
cin >> ty;
if (ty == 1) {
cin >> a;
cout << lpath[find(a)] << "\n";
} else {
cin >> a >> b;
Union(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[5], sum = 0;
for (int i = 0; i < 5; i++) {
cin >> a[i];
sum += a[i];
}
n = sum / 5;
if (sum == 0)
cout << -1;
else if (n * 5 == sum)
cout << n;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, a, b, c, n, t, m, p, q, d, e, f, l, nl, np;
deque<long long int> v, s, vv, ss;
map<long long int, long long int> ma, sa;
string st, et, ft, pt, ct;
deque<char> de;
ios_base::sync_with_stdio(false);
cin >> a >> b >> c >> d >> e;
a = a + b + c + d + e;
if (a % 5 == 0 && a != 0)
cout << a / 5 << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
long long sum = a + b + c + d + e;
if (sum == 0)
cout << -1 << '\n';
else if (sum % 5 == 0)
cout << sum / 5 << '\n';
else
cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, sum = 0, n;
for (i = 1; i <= 5; i++) {
scanf("%d", &n);
sum += n;
}
if (sum % 5 == 0 && sum != 0)
printf("%d\n", sum / 5);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0;
for (int i = 0; i < 5; ++i) {
int k;
cin >> k;
a += k;
}
if (a == 0)
cout << -1 << endl;
else if (a % 5 == 0)
cout << a / 5 << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
if ((a + b + c + d + e) % 5 == 0 && (a + b + c + d + e) != 0)
printf("%d\n", (a + b + c + d + e) / 5);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c, c1, c2, c3, c4, k;
int main() {
cin >> c >> c1 >> c2 >> c3 >> c4;
k = c + c1 + c2 + c3 + c4;
if (k == 0)
cout << -1;
else if (k % 5 == 0)
cout << k / 5;
else
cout << -1;
}
|
#include <bits/stdc++.h>
int main() {
int c1, c2, c3, c4, c5, b;
while (scanf("%d%d%d%d%d", &c1, &c2, &c3, &c4, &c5) != EOF) {
if ((c1 + c2 + c3 + c4 + c5) == 0) {
printf("-1\n");
break;
}
if ((c1 + c2 + c3 + c4 + c5) % 5 == 0) {
printf("%d\n", (c1 + c2 + c3 + c4 + c5) / 5);
} else {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 5;
int arr[5], sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
if (sum == 0)
cout << -1 << endl;
else if (sum % 5 != 0)
cout << -1 << endl;
else {
int s = sum / 5;
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > s)
a += s - arr[i];
else
b += arr[i] - s;
}
if (a == b)
cout << s << endl;
else
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, c5, k;
cin >> c1 >> c2 >> c3 >> c4 >> c5;
k = c1 + c2 + c3 + c4 + c5;
if (k % 5 == 0 && k != 0) {
cout << k / 5;
} else
cout << "-1";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, c5;
scanf("%d%d%d%d%d", &c1, &c2, &c3, &c4, &c5);
int s{c1 + c2 + c3 + c4 + c5};
if (s % 5 || s == 0)
puts("-1");
else
printf("%d\n", s / 5);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0, ar[1000];
for (int i = 0; i < 5; i++) cin >> ar[i];
for (int i = 0; i < 5; i++) sum += ar[i];
if (sum == 0)
cout << "-1" << endl;
else {
if (sum % 5 == 0)
cout << sum / 5 << endl;
else
cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int x, y = 0;
cin >> x;
y += x;
cin >> x;
y += x;
cin >> x;
y += x;
cin >> x;
y += x;
cin >> x;
y += x;
if (y % 5 || y == 0)
cout << -1 << endl;
else
cout << y / 5 << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int c1, c2, c3, c4, c5;
scanf("%d %d %d %d %d", &c1, &c2, &c3, &c4, &c5);
int sum = c1 + c2 + c3 + c4 + c5;
if (c1 == 0 && c2 == 0 && c3 == 0 && c4 == 0 && c5 == 0) {
printf("-1\n");
return 0;
}
if (sum % 5 == 0)
printf("%d\n", sum / 5);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, num = 0;
for (i = 1; i <= 5; i++) {
int temp;
scanf("%d", &temp);
num += temp;
}
if (num % 5 || num == 0) {
printf("-1\n");
} else {
printf("%d\n", num / 5);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, a3, a4, a5;
cin >> a1 >> a2 >> a3 >> a4 >> a5;
if ((a1 + a2 + a3 + a4 + a5) % 5 == 0 && (a1 + a2 + a3 + a4 + a5) != 0) {
cout << (a1 + a2 + a3 + a4 + a5) / 5;
} else {
cout << -1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 5;
int a, sum = 0;
while (t--) {
scanf("%d", &a);
sum += a;
}
if (sum % 5 == 0 && sum != 0) {
printf("%d\n", sum / 5);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
vector<int> v(5);
for (auto &p : v) {
cin >> p;
}
int sum = accumulate(v.begin(), v.end(), 0);
if (sum == 0)
cout << -1;
else {
double avg = double(sum) / 5;
if (avg == sum / 5)
cout << avg;
else
cout << -1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int sum = a + b + c + d + e;
if (sum % 5 == 0 && sum > 0)
cout << sum / 5 << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
long long sum = a + b + c + d + e;
if (sum == 0) {
cout << "-1\n";
return 0;
}
if (sum % 5 == 0) {
cout << sum / 5 << "\n";
} else {
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
int sum = 0;
for (int i = 0; i < 5; ++i) {
cin >> x;
sum += x;
}
if ((sum % 5 != 0) || (sum == 0)) {
cout << "-1" << endl;
} else {
cout << (sum / 5) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, c;
cin >> n >> m >> a >> b >> c;
n += m, n += a, n += b, n += c;
if (n % 5 || a + b + c + n + m == 0)
cout << -1;
else
cout << n / 5;
return 0;
}
|
#include <bits/stdc++.h>
int x, sum = 0, i;
int main() {
for (i = 1; i <= 5; i++) {
scanf("%d", &x);
sum += x;
}
if (sum == 0)
printf("%d\n", -1);
else if (sum % 5 == 0)
printf("%d\n", sum / 5);
else
printf("%d\n", -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s, i, c;
int main() {
s = 0;
for (i = 1; i <= 5; i++) {
cin >> c;
s += c;
}
if (s % 5 == 0 && s != 0)
cout << s / 5 << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum = 0;
int main() {
for (int i = 0, t; i < 5; i++) {
cin >> t;
sum += t;
}
if (sum % 5 || sum == 0)
cout << -1;
else
cout << sum / 5;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b = 0;
for (int i = 1; i <= 5; i++) {
cin >> a;
b += a;
}
if (b % 5 != 0 || b == 0)
cout << -1;
else
cout << b / 5;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int sum = a + b + c + d + e;
if (sum % 5 == 0 && sum != 0)
cout << sum / 5;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int x, ans = 0;
for (int i = 0; i < 5; ++i) cin >> x, ans += x;
if (ans % 5 == 0 && ans)
cout << ans / 5;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c1, c2, c3, c4, c5, s;
int main() {
cin >> c1 >> c2 >> c3 >> c4 >> c5;
s = c1 + c2 + c3 + c4 + c5;
if (s == 0)
cout << -1;
else if (s % 5 == 0)
cout << s / 5;
else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 5;
int b, sum = 0;
while (a--) {
cin >> b;
sum = sum + b;
}
if (sum == 0)
cout << "-1" << endl;
else if (sum % 5 == 0)
cout << sum / 5 << endl;
else
cout << "-1" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, c5;
cin >> c1 >> c2 >> c3 >> c4 >> c5;
if ((c1 + c2 + c3 + c4 + c5) % 5 == 0 && c1 + c2 + c3 + c4 + c5 != 0)
cout << (c1 + c2 + c3 + c4 + c5) / 5;
else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int sum = 0, a;
for (int i = 0; i < 5; i++) {
cin >> a;
sum += a;
}
if (sum % 5 == 0 and sum != 0)
cout << sum / 5 << "\n";
else
cout << -1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0;
for (int i = 0; i < (int)5; i++) {
int x;
cin >> x;
sum += x;
}
if (sum % 5 || sum == 0)
cout << -1 << endl;
else
cout << sum / 5 << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.