solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
bool SR(int &_x) { return scanf("%d", &_x) == 1; }
bool SR(long long &_x) { return scanf("%lld", &_x) == 1; }
bool SR(double &_x) { return scanf("%lf", &_x) == 1; }
bool SR(char *_s) { return scanf("%s", _s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &_x, T &..._tail) {
return SR(_x) && RI(_tail...);
}
void SP(const int _x) { printf("%d", _x); }
void SP(const long long _x) { printf("%lld", _x); }
void SP(const double _x) { printf("%.16lf", _x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I _x, const T... _tail) {
SP(_x);
if (sizeof...(_tail)) putchar(' ');
PL(_tail...);
}
const int maxn = 1e5 + 5;
const int MOD = 1e9 + 9;
struct T {
int a, b;
T() : a(0), b(0) {}
T(int _a, int _b) : a(_a), b(_b) {}
int f(const int &x) const { return x < MOD ? x : x - MOD; }
T operator+(const T &t) const { return T(f(a + t.a), f(b + t.b)); }
T operator-(const T &t) const {
return T(f(a + MOD - t.a), f(b + MOD - t.b));
}
T operator*(const T &t) const {
return T(1LL * a * t.a % MOD, 1LL * b * t.b % MOD);
}
bool operator<(const T &t) const { return tie(a, b) < tie(t.a, t.b); }
bool operator==(const T &t) const { return tie(a, b) == tie(t.a, t.b); }
} bas{maxn * 2 + 7, maxn * 2 + 11}, bp[maxn];
int n;
vector<int> edge[maxn];
void read() {
RI(n);
for (int i = 0; i < int(n - 1); i++) {
int a, b;
RI(a, b);
edge[a].push_back(b);
edge[b].push_back(a);
}
}
struct H {
map<T, int> mp;
T id(const T &i) {
if (!mp.count(i)) {
int siz = mp.size() + 1;
mp[i] = siz;
return T(siz, siz);
}
int res = mp[i];
return T(res, res);
}
} h;
int dfs1(int u, int p, int &root, int &dp) {
int siz = 1, my = 0;
for (int v : edge[u])
if (v != p) {
int sub = dfs1(v, u, root, dp);
siz += sub;
my = max(my, sub);
}
my = max(my, n - siz);
if (my < dp) dp = my, root = u;
return siz;
}
int siz[maxn];
int dfs2(int u, int p) {
siz[u] = 1;
for (int v : edge[u])
if (v != p) siz[u] += dfs2(v, u);
return siz[u];
}
T subh[maxn];
void dfs3(int u, int p) {
if (siz[u] == 1) {
subh[u] = h.id(T(0, 0));
return;
}
for (int v : edge[u])
if (v != p) dfs3(v, u);
sort((edge[u]).begin(), (edge[u]).end(), [&](int a, int b) {
return tie(siz[a], subh[a]) < tie(siz[b], subh[b]);
});
assert(siz[u] == n || edge[u].back() == p);
T cur(0, 0);
for (int v : edge[u])
if (v != p) cur = cur * bas + subh[v];
cur = h.id(cur);
subh[u] = cur;
}
T parh[maxn];
vector<T> kh[maxn];
void dfs4(int u, int p, const T &w) {
if (siz[u] == n) {
const int z = ((int)(edge[u]).size());
kh[u].resize(z + 1);
kh[u][0] = T(0, 0);
for (int i = (1); i <= int(z); i++)
kh[u][i] = kh[u][i - 1] * bas + subh[edge[u][i - 1]];
for (int i = (1); i <= int(z); i++) {
T cur = kh[u].back(), pw = bp[z - i];
cur = cur - kh[u][i] * pw;
cur = cur + kh[u][i - 1] * pw;
cur = h.id(cur);
dfs4(edge[u][i - 1], u, cur);
}
return;
}
assert(siz[u] == n || edge[u].back() == p);
parh[u] = w;
const int z = ((int)(edge[u]).size()) - 1;
kh[u].resize(z + 1);
kh[u][0] = T(0, 0);
for (int i = (1); i <= int(z); i++)
kh[u][i] = kh[u][i - 1] * bas + subh[edge[u][i - 1]];
for (int i = (1); i <= int(z); i++) {
T cur = kh[u].back(), pw = bp[z - i];
cur = cur - kh[u][i] * pw;
cur = cur + kh[u][i - 1] * pw;
cur = cur * bas + w;
cur = h.id(cur);
dfs4(edge[u][i - 1], u, cur);
}
}
void build() {
bp[0] = T(1, 1);
for (int i = (1); i <= int(maxn - 1); i++) bp[i] = bp[i - 1] * bas;
int root = -1;
{
int dp = maxn;
dfs1(1, 0, root, dp);
}
assert(root != -1);
dfs2(root, 0);
dfs3(root, 0);
dfs4(root, 0, T(0, 0));
}
struct Q {
map<T, int> cnt;
void add(const T &i) { cnt[i]++; }
void del(const T &i) {
if (--cnt[i] == 0) cnt.erase(i);
}
int size() const { return ((int)(cnt).size()); }
} q;
void dfs5(int u, int p, int &ans, int &dp) {
;
if (siz[u] == n) {
const int z = ((int)(edge[u]).size());
for (int i = (1); i <= int(z); i++) {
const int v = edge[u][i - 1];
q.del(subh[v]);
q.add(parh[v]);
dfs5(v, u, ans, dp);
q.add(subh[v]);
q.del(parh[v]);
}
return;
}
if (((int)(q).size()) > dp) dp = ((int)(q).size()), ans = u;
const int z = ((int)(edge[u]).size()) - 1;
for (int i = (1); i <= int(z); i++) {
const int v = edge[u][i - 1];
q.del(subh[v]);
q.add(parh[v]);
dfs5(v, u, ans, dp);
q.add(subh[v]);
q.del(parh[v]);
}
}
void sol() {
int root = max_element(siz + 1, siz + n + 1) - siz;
for (int i = (1); i <= int(n); i++)
if (i != root) q.add(subh[i]);
int ans = root, dp = ((int)(q).size());
dfs5(root, 0, ans, dp);
PL(ans);
}
int main() {
read();
build();
sol();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, head[N], cnt, base1, base2, base3, dfn[N], idx, idfn[N], sz[N], fa[N];
int d[N];
unsigned long long hx[N], s[N];
struct edge {
int to, nxt;
} e[N << 1];
struct data {
unsigned long long val;
int sz, l, r;
inline bool operator<(const data& rhs) const {
return val == rhs.val ? (sz == rhs.sz ? l < rhs.l : sz < rhs.sz)
: val < rhs.val;
}
};
vector<data> vec;
void dfs(int now) {
hx[now] = 0;
idfn[dfn[now] = ++idx] = now;
sz[now] = 1;
unsigned long long sum = 0;
for (int i = head[now]; i; i = e[i].nxt)
if (!dfn[e[i].to]) {
fa[e[i].to] = now;
dfs(e[i].to);
sz[now] += sz[e[i].to];
hx[now] ^= hx[e[i].to] * base3 + base1;
sum += hx[e[i].to];
}
hx[now] ^= (unsigned long long)sz[now] * base2 + 1;
hx[now] += sum;
s[now] = sum;
int l = dfn[now], r = dfn[now] + sz[now];
vec.push_back((data){hx[now], sz[now], 1, l - 1});
vec.push_back((data){hx[now], sz[now], r, n});
}
void dfs2(int now) {
unsigned long long vx = hx[now],
nx = (hx[now] - s[now]) ^
((unsigned long long)sz[now] * base2 + 1);
for (int i = head[now]; i; i = e[i].nxt)
if (dfn[now] < dfn[e[i].to]) {
hx[now] = nx ^ (hx[e[i].to] * base3 + base1);
if (fa[now]) hx[now] ^= hx[fa[now]] * base3 + base1;
hx[now] ^= (unsigned long long)(n - sz[e[i].to]) * base2 + 1;
hx[now] += s[now] - hx[e[i].to] + hx[fa[now]];
vec.push_back((data){hx[now], n - sz[e[i].to], dfn[e[i].to],
dfn[e[i].to] + sz[e[i].to] - 1});
dfs2(e[i].to);
}
hx[now] = vx;
}
int main() {
srand(time(0));
base1 = rand() % 20000 + 10000, base2 = rand() % 30000 + 23333,
base3 = rand() % 1919810 + 114514;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[++cnt] = (edge){v, head[u]}, head[u] = cnt;
e[++cnt] = (edge){u, head[v]}, head[v] = cnt;
}
dfs(1);
dfs2(1);
sort(vec.begin(), vec.end());
data nw = vec[0];
for (int i = 1; i <= vec.size(); ++i)
if (i == vec.size() || nw.val != vec[i].val || nw.sz != vec[i].sz ||
nw.r < vec[i].l) {
++d[nw.l], --d[nw.r + 1];
nw = vec[i];
} else
nw.r = vec[i].r;
for (int i = 1; i <= n; ++i) d[i] += d[i - 1];
printf("%d\n", idfn[max_element(d + 1, d + n + 1) - d]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, sz[maxn], G, Gs;
int C[maxn << 1], Pre;
unsigned long long H[maxn << 1];
int ecnt, pt[maxn << 1], nt[maxn << 1], hd[maxn];
unsigned long long wt[maxn << 1];
void ins(int u, int v) {
pt[++ecnt] = v;
nt[ecnt] = hd[u];
hd[u] = ecnt;
}
void Max(int &x, int y) {
if (x < y) x = y;
}
void Dfs(int x, int f) {
int i, mx = 0;
sz[x] = 1;
for (i = hd[x]; i; i = nt[i])
if (pt[i] != f) {
Dfs(pt[i], x);
Max(mx, sz[pt[i]]);
sz[x] += sz[pt[i]];
}
Max(mx, n - sz[x]);
if (!G || mx < Gs) Gs = mx, G = x;
}
unsigned long long Sol(int x, int f) {
int i, tot;
vector<unsigned long long> hs;
for (i = hd[x]; i; i = nt[i])
if (pt[i] != f) {
if (!wt[i]) wt[i] = Sol(pt[i], x);
hs.push_back(wt[i]);
}
tot = hs.size();
sort(hs.begin(), hs.end());
unsigned long long tmp = 20170217;
for (i = 0; i < tot; i++) tmp = (tmp * 55555 + hs[i]) ^ 233333333;
return tmp;
}
void dfs0(int x, int f) {
int i;
for (i = hd[x]; i; i = nt[i])
if (pt[i] != f) {
if ((C[wt[i]]++) == 0) Pre++;
dfs0(pt[i], x);
}
}
int Ans, Rt;
void dfs1(int x, int f) {
int i;
if (Pre > Ans) Ans = Pre, Rt = x;
for (i = hd[x]; i; i = nt[i])
if (pt[i] != f) {
++Pre;
if ((--C[wt[i]]) == 0) Pre--;
dfs1(pt[i], x);
--Pre;
if ((C[wt[i]]++) == 0) Pre++;
}
}
int main() {
int i, u, v, tot = 0;
scanf("%d", &n);
for (ecnt = i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
ins(u, v);
ins(v, u);
}
Dfs(1, 0);
Sol(G, 0);
for (i = 1; i <= ecnt; ++i)
if (wt[i]) H[++tot] = wt[i];
sort(H + 1, H + tot + 1);
tot = unique(H + 1, H + ecnt + 1) - H - 1;
for (i = 1; i <= ecnt; i++)
if (wt[i]) wt[i] = lower_bound(H + 1, H + tot + 1, wt[i]) - H;
dfs0(G, 0);
Ans = -1;
dfs1(G, 0);
printf("%d\n", Rt);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve(bool);
void precalc();
clock_t start;
int testNumber = 1;
bool todo = true;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve(true);
++testNumber;
}
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
void precalc() {}
const long long C = 100500;
long long pr[2] = {234211911, 23423541};
long long mods[2] = {1000000007, 1000000009};
long long powers[2][C];
class Treap {
public:
typedef struct _node {
long long key;
long long cnt;
long long prior;
long long val[2];
_node* l;
_node* r;
_node(long long key) : key(key), l(nullptr), r(nullptr), cnt(1) {
prior = (rand() << 16) | rand();
val[0] = (key + 1);
val[1] = (key + 1);
}
void push() {}
void recalc() {
cnt = 1 + Cnt(l) + Cnt(r);
for (long long w = 0; w < 2; ++w) {
val[w] = powers[w][Cnt(r)] * (key + 1) % mods[w];
if (l) {
val[w] += powers[w][Cnt(r) + 1] * l->val[w];
}
if (r) {
val[w] += r->val[w];
}
val[w] %= mods[w];
}
}
long long get_hash() { return (val[0] * 1LL << 32) | val[1]; }
static long long Cnt(_node* v) {
if (!v) return 0;
return v->cnt;
}
} * node;
static long long Cnt(node v) {
if (!v) return 0;
return v->cnt;
}
node root;
size_t Size;
node merge(node l, node r) {
if (!l) return r;
if (!r) return l;
if (l->prior < r->prior) {
l->push();
l->r = merge(l->r, r);
l->recalc();
return l;
} else {
r->push();
r->l = merge(l, r->l);
r->recalc();
return r;
}
}
void split(node v, long long key, node& l, node& r) {
l = r = nullptr;
if (!v) return;
v->push();
if (v->key < key) {
l = v;
split(l->r, key, l->r, r);
l->recalc();
} else {
r = v;
split(r->l, key, l, r->l);
r->recalc();
}
}
void splitCnt(node v, long long key, node& l, node& r) {
l = r = nullptr;
if (!v) return;
v->push();
long long lef = Cnt(v->l) + 1;
if (key >= lef) {
l = v;
splitCnt(l->r, key - lef, l->r, r);
l->recalc();
} else {
r = v;
splitCnt(r->l, key, l, r->l);
r->recalc();
}
}
public:
Treap() {
root = nullptr;
Size = 0;
}
size_t size() const { return Size; }
void insert(long long key) {
node l = nullptr, r = nullptr;
split(root, key, l, r);
++Size;
root = merge(merge(l, new _node(key)), r);
}
void erase(long long key) {
node l, m, r;
split(root, key, l, m);
splitCnt(m, 1, m, r);
root = merge(l, r);
--Size;
}
long long get_hash() {
if (!root) {
return 0;
}
return root->get_hash() ^ ((long long)Size * (1LL << 32)) ^ (long long)Size;
}
};
vector<vector<long long>> g;
long long best_ans = 0;
long long best_v = -1;
map<long long, long long> trees;
map<long long, long long> cnt;
vector<long long> down;
vector<long long> subtree;
long long dfs1(long long v, long long p) {
subtree[v] = 1;
Treap children;
for (long long to : g[v]) {
if (to == p) {
continue;
}
long long child = dfs1(to, v);
children.insert(child);
subtree[v] += subtree[to];
}
long long cur = children.get_hash() ^ subtree[v];
if (!trees.count(cur)) {
long long id = (long long)trees.size();
trees[cur] = id;
}
cur = trees[cur];
++cnt[cur];
down[v] = cur;
return cur;
}
vector<vector<long long>> hashes;
void dec(long long cur) {
--cnt[cur];
if (cnt[cur] == 0) {
cnt.erase(cur);
}
}
void inc(long long cur) { ++cnt[cur]; }
long long n;
void dfs2(long long v, long long p, long long up) {
long long cand = (long long)cnt.size() + 1;
if (best_ans < cand || best_ans == cand && v < best_v) {
best_ans = cand;
best_v = v;
}
Treap cur;
if (up != -1) {
cur.insert(up);
}
for (long long to : g[v]) {
if (to == p) {
continue;
}
cur.insert(down[to]);
}
for (long long to : g[v]) {
if (to == p) {
continue;
}
dec(down[to]);
cur.erase(down[to]);
long long now = cur.get_hash() ^ (n - subtree[to]);
long long id;
if (!trees.count(now)) {
id = (long long)trees.size();
trees[now] = id;
} else {
id = trees[now];
}
inc(id);
dfs2(to, v, id);
cur.insert(down[to]);
inc(down[to]);
dec(id);
}
}
void solve(bool read) {
for (long long w = 0; w < 2; ++w) {
powers[w][0] = 1;
for (long long i = 1; i < C; ++i) {
powers[w][i] = powers[w][i - 1] * pr[w] % mods[w];
}
}
cin >> n;
g.resize(n);
for (long long i = 1; i < n; ++i) {
long long a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
down.resize(n);
subtree.resize(n);
dfs1(0, 0);
hashes.resize(n);
dec(down[0]);
dfs2(0, 0, -1);
cout << best_v + 1 << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long p = 179;
const long long mod = 1791791791l;
const int maxn = 1e6 + 179;
vector<vector<int> > tree;
vector<vector<long long> > frw_hash;
vector<vector<long long> > rev_hash;
vector<int> num;
void get_all(int v, int par, unordered_map<long long, int>& ums) {
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]++;
get_all(u, v, ums);
}
i++;
}
}
void dfs(int v, int par, unordered_map<long long, int>& ums) {
num[v] = ums.size();
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]--;
if (ums[frw_hash[v][i]] == 0) ums.erase(frw_hash[v][i]);
ums[rev_hash[v][i]]++;
dfs(u, v, ums);
ums[rev_hash[v][i]]--;
if (ums[rev_hash[v][i]] == 0) ums.erase(rev_hash[v][i]);
ums[frw_hash[v][i]]++;
}
i++;
}
}
int main() {
long long ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) ppows[i] = (ppows[i - 1] * p) % mod;
int n;
cin >> n;
tree.resize(n);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
tree[u].push_back(v);
tree[v].push_back(u);
edges.push_back(make_pair(u, v));
edges.push_back(make_pair(v, u));
}
map<pair<int, int>, int> index;
for (int i = 0; i < 2 * n - 2; ++i) index[edges[i]] = i;
vector<int> sz_of(edges.size(), -1), out(n, 0);
vector<long long> hash_of(edges.size(), -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (tree[i].size() == 1) {
hash_of[index[make_pair(tree[i][0], i)]] = ('(' * p + ')') % mod;
out[tree[i][0]]++;
sz_of[index[make_pair(tree[i][0], i)]] = 1;
q.push(index[make_pair(tree[i][0], i)]);
}
}
vector<bool> fulloutcalc(n, false), mostoutcalc(n, false);
while (!q.empty()) {
int a = q.front();
q.pop();
int v = edges[a].first;
if (out[v] == tree[v].size() - 1) {
if (mostoutcalc[v]) continue;
mostoutcalc[v] = true;
int u = -1;
vector<long long> known_outer_hashes;
vector<int> known_subtree_sizes;
for (int w : tree[v]) {
if (hash_of[index[make_pair(v, w)]] == -1)
u = w;
else {
known_outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
known_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
}
vector<int> ind(known_outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return known_outer_hashes[i] < known_outer_hashes[j];
});
vector<int> szs;
vector<long long> sorted_outer_hashes;
for (int i = 0; i < known_outer_hashes.size(); ++i) {
sorted_outer_hashes.push_back(known_outer_hashes[ind[i]]);
szs.push_back(known_subtree_sizes[ind[i]]);
}
int i = index[make_pair(u, v)];
if (hash_of[i] != -1) {
continue;
}
hash_of[i] = '(';
sz_of[i] = 1;
for (int j = 0; j < sorted_outer_hashes.size(); ++j) {
hash_of[i] = (hash_of[i] * ppows[2 * szs[j]]) % mod;
hash_of[i] = (hash_of[i] + sorted_outer_hashes[j]) % mod;
sz_of[i] += szs[j];
}
hash_of[i] = (hash_of[i] * p + ')') % mod;
out[u]++;
q.push(i);
continue;
}
if (out[v] != tree[v].size()) continue;
if (fulloutcalc[v]) continue;
fulloutcalc[v] = true;
vector<long long> outer_hashes;
vector<int> outer_subtree_sizes;
for (int w : tree[v]) {
outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
outer_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
vector<int> ind(outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return outer_hashes[i] < outer_hashes[j];
});
vector<long long> sorted_outer_hashes;
vector<int> szs;
for (int i = 0; i < outer_hashes.size(); ++i) {
sorted_outer_hashes.push_back(outer_hashes[ind[i]]);
szs.push_back(outer_subtree_sizes[ind[i]]);
}
vector<long long> pref_hh(sorted_outer_hashes.size() + 1, 0);
pref_hh[0] = '(';
for (int i = 1; i < sorted_outer_hashes.size(); ++i) {
pref_hh[i] = (pref_hh[i - 1] * ppows[2 * szs[i - 1]] +
sorted_outer_hashes[i - 1]) %
mod;
}
vector<long long> suf_hh(sorted_outer_hashes.size() + 2, 0);
vector<int> suf_sz(sorted_outer_hashes.size() + 2, 0);
suf_hh.back() = ')';
for (int i = sorted_outer_hashes.size(); i > 1; i--) {
suf_hh[i] = (suf_hh[i + 1] +
sorted_outer_hashes[i - 1] * ppows[2 * suf_sz[i + 1] + 1]) %
mod;
suf_sz[i] = suf_sz[i + 1] + szs[i - 1];
}
for (int i = 0; i < sorted_outer_hashes.size(); ++i) {
int u = tree[v][ind[i]];
if (hash_of[index[make_pair(u, v)]] == -1) {
sz_of[index[make_pair(u, v)]] = n - sz_of[index[make_pair(v, u)]];
hash_of[index[make_pair(u, v)]] =
(pref_hh[i] * ppows[2 * suf_sz[i + 2] + 1] + suf_hh[i + 2]) % mod;
out[u]++;
q.push(index[make_pair(u, v)]);
}
}
}
frw_hash.resize(n);
rev_hash.resize(n);
num.resize(n);
for (int i = 0; i < n; ++i) {
for (int v : tree[i]) {
frw_hash[i].push_back(hash_of[index[make_pair(i, v)]]);
rev_hash[i].push_back(hash_of[index[make_pair(v, i)]]);
}
}
unordered_map<long long, int> ump;
get_all(0, -1, ump);
dfs(0, -1, ump);
cout << distance(num.begin(), max_element(num.begin(), num.end())) + 1
<< endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int inf = 2e5;
int read() {
int x = 0, f = 1, ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return x * f;
}
struct edge {
int to, nxt;
} e[200005];
int head[200005], k = 0;
void add(int u, int v) {
e[k] = {v, head[u]};
head[u] = k++;
}
int n, ans1, ans2, tot = 0;
map<int, int> mp;
void ist(int x) {
if (!mp[x]) ++tot;
++mp[x];
}
void dlt(int x) {
--mp[x];
if (!mp[x]) --tot;
}
int hs[200005], size[200005];
void dfs1(int u, int fa, int eg) {
size[eg] = 1;
for (int i = head[u], v; ~i; i = e[i].nxt) {
v = e[i].to;
if (v == fa) continue;
dfs1(v, u, i);
hs[eg] = (1ll * hs[eg] + hs[i]) % mod;
size[eg] += size[i];
}
hs[eg] =
(1ll * hs[eg] * size[eg] % mod + 1ll * size[eg] * size[eg] % mod) % mod;
ist(hs[eg]);
}
void dfs2(int u, int fa) {
register int sum = 0;
for (int i = head[u], v; ~i; i = e[i].nxt) sum = (1ll * sum + hs[i]) % mod;
for (int i = head[u], v; ~i; i = e[i].nxt) {
v = e[i].to;
size[i ^ 1] = n - size[i];
hs[i ^ 1] = (1ll * size[i ^ 1] * (sum - hs[i] + mod) % mod +
1ll * size[i ^ 1] * size[i ^ 1]) %
mod;
if (v != fa) dfs2(v, u);
}
}
void slv(int u, int fa) {
for (int i = head[u], v; ~i; i = e[i].nxt) {
v = e[i].to;
if (v == fa) continue;
dlt(hs[i]), ist(hs[i ^ 1]);
if (tot > ans1) ans1 = tot, ans2 = v;
slv(v, u);
dlt(hs[i ^ 1]), ist(hs[i]);
}
}
signed main() {
n = read();
memset(head, -1, sizeof head);
for (int i = 1, u, v; i < n; ++i)
u = read(), v = read(), add(u, v), add(v, u);
dfs1(1, 0, inf);
dfs2(1, 0);
ans1 = tot, ans2 = 1;
slv(1, 0);
printf("%d\n", ans2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void pr(int x);
void pr(const char* x);
void ps();
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts);
int n, a, b;
vector<pair<int, int> > edges;
vector<int> adj[210000];
unsigned long long t[210000];
int size[210000];
int order[210000];
unsigned long long ad[210000];
multiset<unsigned long long> allt;
int curcnt;
int ans, ani;
int dfs(int v, int p) {
int tam = 1;
for (int e : adj[v]) {
int dest;
if (e >= n - 1)
dest = edges[e - (n - 1)].first;
else
dest = edges[e].second;
if (dest != p) {
size[e] = dfs(dest, v);
tam += size[e];
}
}
return tam;
}
unsigned long long get_seq(int e) {
int v, rev;
if (e >= (n - 1)) {
v = edges[e - (n - 1)].first;
rev = e - (n - 1);
} else {
v = edges[e].second;
rev = e + (n - 1);
}
return ad[v] - t[rev];
}
bool comps(int a, int b) { return size[a] < size[b]; }
void add(unsigned long long t) {
if (allt.find(t) == allt.end()) curcnt++;
allt.insert(t);
}
void rem(unsigned long long t) {
allt.erase(allt.find(t));
if (allt.find(t) == allt.end()) curcnt--;
}
void odfs(int v, int p) {
for (int e : adj[v]) {
int dest;
if (e >= n - 1)
dest = edges[e - (n - 1)].first;
else
dest = edges[e].second;
if (dest != p) {
add(t[e]);
odfs(dest, v);
}
}
}
void ddfs(int v, int p) {
if (curcnt > ans) {
ans = curcnt;
ani = v;
}
for (int e : adj[v]) {
int dest, ote;
if (e >= n - 1) {
dest = edges[e - (n - 1)].first;
ote = e - (n - 1);
} else {
dest = edges[e].second;
ote = e + (n - 1);
}
if (dest != p) {
rem(t[e]);
add(t[ote]);
ddfs(dest, v);
rem(t[ote]);
add(t[e]);
}
}
}
void solve() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<unsigned long long> dist;
memset(size, -1, sizeof(size));
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
a--;
b--;
edges.push_back({a, b});
adj[a].push_back(i);
adj[b].push_back((n - 1) + i);
}
dfs(0, -1);
for (int i = 0; i < n - 1; i++) {
if (size[i] == -1)
size[i] = n - size[(n - 1) + i];
else
size[(n - 1) + i] = n - size[i];
}
for (int i = 0; i < 2 * (n - 1); i++) {
order[i] = i;
}
sort(order, order + 2 * (n - 1), comps);
int cur = 0;
while (cur < 2 * (n - 1)) {
int st = cur;
int th = size[order[cur]];
while (cur < 2 * (n - 1) && size[order[cur]] == th) cur++;
vector<pair<unsigned long long, int> > seqs;
for (int k = st; k < cur; k++) {
seqs.push_back(make_pair(get_seq(order[k]), order[k]));
}
sort(seqs.begin(), seqs.end());
unsigned long long cur_t = 0;
for (int k = 0; k < seqs.size(); k++) {
if (k == 0 || seqs[k].first != seqs[k - 1].first) {
cur_t = dist(rng);
}
t[seqs[k].second] = cur_t;
int e = seqs[k].second, p;
if (e >= (n - 1))
p = edges[e - (n - 1)].second;
else
p = edges[e].first;
ad[p] += t[e];
}
}
odfs(0, -1);
ddfs(0, -1);
ps(ani + 1);
}
int main() { solve(); }
void pr(int x) { printf("%d", x); }
void pr(const char* x) { printf("%s", x); }
void ps() { pr("\n"); }
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(" ");
ps(ts...);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int MAXM = MAXN - 1;
const int MAXID = 2 * MAXN;
int n;
int ghead[MAXN], gnxt[2 * MAXM], gto[2 * MAXM];
map<vector<int>, int> mp;
int id[MAXN], parid[MAXN], nid;
void dfs1(int at, int par) {
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
dfs1(to, at);
}
vector<int> cur;
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
cur.push_back(id[to]);
}
sort(cur.begin(), cur.end());
if (!mp.count(cur)) mp[cur] = nid++;
id[at] = mp[cur];
}
int tmp[MAXID];
void dfs2(int at, int par) {
vector<int> cur;
if (par != -1) cur.push_back(parid[at]);
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
cur.push_back(id[to]);
}
sort(cur.begin(), cur.end());
if (((int)(cur).size()) != 0) {
int other = cur.back();
bool diff = true;
cur.pop_back();
for (int i = ((int)(cur).size()); i >= 0; --i) {
if (diff) {
if (!mp.count(cur)) mp[cur] = nid++;
tmp[other] = mp[cur];
}
if (i >= 1) diff = cur[i - 1] != other, swap(cur[i - 1], other);
}
}
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
parid[to] = tmp[id[to]];
}
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
dfs2(to, at);
}
}
int cnt[MAXID], cntdiff, retdiff, ret;
void mod(int x, int by) {
int c = cnt[x] >= 1 ? 1 : 0;
cnt[x] += by;
c -= cnt[x] >= 1 ? 1 : 0;
cntdiff -= c;
}
void dfs3(int at, int par) {
if (par != -1) mod(id[at], +1);
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
dfs3(to, at);
}
}
void dfs4(int at, int par) {
if (cntdiff > retdiff) retdiff = cntdiff, ret = at;
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (to == par) continue;
mod(id[to], -1);
mod(parid[to], +1);
dfs4(to, at);
mod(id[to], +1);
mod(parid[to], -1);
}
}
int solve() {
mp = map<vector<int>, int>();
nid = 0;
dfs1(0, -1);
parid[0] = -1;
dfs2(0, -1);
memset(cnt, 0, sizeof(cnt));
cntdiff = 0;
dfs3(0, -1);
ret = -1, retdiff = -1;
dfs4(0, -1);
return ret;
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) ghead[i] = -1;
for (int i = (0); i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
gnxt[2 * i + 0] = ghead[a];
ghead[a] = 2 * i + 0;
gto[2 * i + 0] = b;
gnxt[2 * i + 1] = ghead[b];
ghead[b] = 2 * i + 1;
gto[2 * i + 1] = a;
}
int ret = solve();
printf("%d\n", ret + 1);
}
void gen() {
n = MAXN;
for (int i = (0); i < (n); ++i) ghead[i] = -1;
for (int i = (0); i < (n - 1); ++i) {
int a = 0, b = i + 1;
gnxt[2 * i + 0] = ghead[a];
ghead[a] = 2 * i + 0;
gto[2 * i + 0] = b;
gnxt[2 * i + 1] = ghead[b];
ghead[b] = 2 * i + 1;
gto[2 * i + 1] = a;
}
solve();
printf("done (%d,%d)\n", ret, retdiff);
}
int main() {
run();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<unsigned long long, int> P;
unsigned long long H[100005], size[100005];
int n, cnt, sum, ans, root;
int head[100005], to[200005], Next[200005];
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 << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void add(int u, int v) {
to[++cnt] = v;
Next[cnt] = head[u];
head[u] = cnt;
}
void DP1(int u, int fa) {
H[u] = 233;
size[u] = 1;
for (register int i = head[u]; i; i = Next[i]) {
int v = to[i];
if (v != fa) {
DP1(v, u);
size[u] += size[v];
H[u] = H[u] + size[v] * H[v] * 19240817;
}
}
++P[H[u]];
sum += (P[H[u]] == 1);
return;
}
void DP2(int u, int fa) {
if (sum >= ans) {
root = u;
ans = sum;
}
for (register int i = head[u]; i; i = Next[i]) {
int v = to[i];
if (v != fa) {
--P[H[u]];
sum -= (P[H[u]] == 0);
--P[H[v]];
sum -= (P[H[v]] == 0);
H[u] -= size[v] * H[v] * 19240817;
size[u] -= size[v];
H[v] += size[u] * H[u] * 19240817;
size[v] += size[u];
++P[H[u]];
sum += (P[H[u]] == 1);
++P[H[v]];
sum += (P[H[v]] == 1);
DP2(v, u);
--P[H[u]];
sum -= (P[H[u]] == 0);
--P[H[v]];
sum -= (P[H[v]] == 0);
size[v] -= size[u];
H[v] -= size[u] * H[u] * 19240817;
size[u] += size[v];
H[u] += size[v] * H[v] * 19240817;
++P[H[u]];
sum += (P[H[u]] == 1);
++P[H[v]];
sum += (P[H[v]] == 1);
}
}
return;
}
int main() {
n = read();
for (register int i = 2; i <= n; ++i) {
int u, v;
u = read();
v = read();
add(u, v);
add(v, u);
}
DP1(1, 0);
DP2(1, 0);
printf("%d\n", root);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)3e5 + 10;
const int inf = (int)1e9 + 5;
const long long llinf = (long long)1e18 + 5;
const double pi = acos(-1.0);
vector<int> g[maxn];
vector<int> z[maxn];
map<pair<long long, long long>, int> have;
int num[maxn];
int cur = 1;
long long h[maxn];
long long pw[maxn];
long long pw2[maxn];
long long mod, mod2, base, base2, inv, inv2;
long long binpow(long long x, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = (ret * x) % mod;
x = (x * x) % mod;
n /= 2;
}
return ret;
}
int cnt[maxn];
int all;
void add(int x, int d) {
if (x == 0) return;
if (cnt[x] == 0 && d == 1) all++;
if (cnt[x] == 1 && d == -1) all--;
cnt[x] += d;
}
void dfs(int v, int par = -1) {
if (par != -1) g[v].erase(find((g[v]).begin(), (g[v]).end(), par));
for (int x : g[v]) {
dfs(x, v);
z[v].push_back(num[x]);
}
sort((z[v]).begin(), (z[v]).end());
long long HASH = 0, HASH2 = 0;
for (int i = (0); i < (z[v].size()); i++) {
HASH += z[v][i] * pw[i];
HASH %= mod;
HASH2 += z[v][i] * pw2[i];
HASH2 %= mod2;
}
if (!have.count(make_pair(HASH, HASH2))) have[make_pair(HASH, HASH2)] = cur++;
num[v] = have[make_pair(HASH, HASH2)];
add(num[v], +1);
}
void print() {
for (int i = (0); i < (30); i++)
if (cnt[i]) cout << i << ",";
cout << endl;
}
int ans = -1;
int res;
void dfs2(int v, int X) {
vector<pair<int, int> > t;
for (int x : g[v]) t.push_back(make_pair(num[x], x));
if (X != 0) t.push_back(make_pair(X, -1));
sort((t).begin(), (t).end());
vector<long long> HASH(t.size()), HASH2(t.size());
for (int i = (0); i < (t.size()); i++) {
HASH[i] += t[i].first * pw[i];
HASH2[i] += t[i].first * pw2[i];
if (i > 0) HASH[i] += HASH[i - 1], HASH2[i] += HASH2[i - 1];
HASH[i] %= mod;
HASH2[i] %= mod2;
}
if (!have.count(make_pair(HASH.back(), HASH2.back())))
have[make_pair(HASH.back(), HASH2.back())] = cur++;
add(X, +1);
add(num[v], -1);
add(have[make_pair(HASH.back(), HASH2.back())], +1);
if (umax(ans, all)) {
res = v;
}
add(have[make_pair(HASH.back(), HASH2.back())], -1);
for (int i = (0); i < (t.size()); i++) {
if (t[i].second == -1) continue;
long long H1 =
(i == 0 ? 0 : HASH[i - 1]) + (i + 1 < t.size() ? HASH[i + 1] : 0) * inv;
H1 %= mod;
long long H2 = (i == 0 ? 0 : HASH2[i - 1]) +
(i + 1 < t.size() ? HASH2[i + 1] : 0) * inv2;
H2 %= mod;
if (!have.count(make_pair(H1, H2))) have[make_pair(H1, H2)] = cur++;
dfs2(t[i].second, have[make_pair(H1, H2)]);
}
add(X, -1);
add(num[v], +1);
}
bool prime(long long x) {
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
int main() {
mod = gen() % 2000000000;
mod2 = gen() % 2000000000;
base = 300000 + gen() % 100000;
base2 = 300000 + gen() % 100000;
while (!prime(mod)) mod++;
while (!prime(mod2)) mod2++;
while (!prime(base)) base++;
while (!prime(base2)) base2++;
inv = binpow(base, mod - 2, mod);
inv2 = binpow(base2, mod2 - 2, mod2);
pw[0] = pw2[0] = 1;
for (int i = (1); i < (maxn); i++) {
pw[i] = (pw[i - 1] * base) % mod;
pw2[i] = (pw2[i - 1] * base2) % mod2;
}
int n = getint<int>();
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int i = (0); i < (n - 1); i++) {
int x = getint<int>();
int y = getint<int>();
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, -1);
dfs2(1, 0);
cout << res << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int MAXN = 400001;
const long long h1 = 1000003;
const long long h2 = 424243;
long long hashes[MAXN];
long long in[MAXN];
long long d[MAXN];
long long s[MAXN];
int an[MAXN];
int szv;
vector<int> g[MAXN];
int cnts[MAXN];
int cur;
int ans = 0;
int ansv;
void lower(long long &x) { x = lower_bound(in, in + szv, x) - in; }
void change(int i, int j) {
if (cnts[i] == 1) {
cur--;
}
cnts[i]--;
if (cnts[j] == 0) {
cur++;
}
cnts[j]++;
}
void dfs1(int u, int pr = -1) {
d[u] = 0;
for (auto h : g[u]) {
if (h != pr) {
dfs1(h, u);
d[u] += d[h] * h1;
}
}
d[u] ^= h2;
}
void dfs2(int u, int pr = -1) {
hashes[u] = d[u] ^ h2;
if (pr != -1) {
hashes[u] += s[u] * h1;
}
hashes[u] ^= h2;
for (auto h : g[u]) {
if (h != pr) {
s[h] = ((hashes[u] ^ h2) - d[h] * h1) ^ h2;
dfs2(h, u);
}
}
}
void dfs3(int u, int pr) {
if (pr != -1) {
change(hashes[pr], s[u]);
change(d[u], hashes[u]);
}
if (cur > ans) {
ans = cur, ansv = u;
}
an[u] = cur;
for (auto h : g[u]) {
if (h != pr) {
dfs3(h, u);
}
}
if (pr != -1) {
change(s[u], hashes[pr]);
change(hashes[u], d[u]);
}
}
int main() {
int n = readInt();
for (int i = 0; i < n - 1; i++) {
int a = readInt(), b = readInt();
g[a].push_back(b);
g[b].push_back(a);
}
dfs1(1);
dfs2(1);
for (int i = 1; i <= n; i++) {
in[i * 3 - 3] = d[i];
in[i * 3 - 2] = hashes[i];
in[i * 3 - 1] = s[i];
}
sort(in, in + 3 * n);
memset(cnts, 0, sizeof(cnts));
szv = unique(in, in + 3 * n) - in;
cur = 1;
for (int i = 1; i <= n; i++) {
lower(d[i]);
lower(hashes[i]);
lower(s[i]);
}
cnts[hashes[1]] = n;
for (int i = 2; i <= n; i++) {
change(hashes[1], d[i]);
}
dfs3(1, 1);
writeInt(ansv, '\n');
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
unsigned long long read() {
unsigned long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
unsigned long long n, fa[200005], now[200005], ans, maxn, cnt, p;
unsigned long long val[200005], f[200005];
vector<unsigned long long> G[200005];
map<unsigned long long, unsigned long long> mp;
unsigned long long get_rnd() {
return (unsigned long long)(rand() + 1) * 2333 +
(unsigned long long)(rand() + 1) * 19260817 +
(unsigned long long)((rand() + 1231) << 28);
}
void ins(unsigned long long x) {
if (!now[x]) ++ans;
++now[x];
}
void del(unsigned long long x) {
--now[x];
if (!now[x]) --ans;
}
unsigned long long get(unsigned long long x) {
if (mp[x]) return mp[x];
mp[x] = ++cnt;
return mp[x];
}
void dfs1(unsigned long long x, unsigned long long fa) {
unsigned long long siz = G[x].size();
unsigned long long Hash = 0;
for (unsigned long long i = 0; i < siz; i++) {
unsigned long long v = G[x][i];
if (v != fa) dfs1(v, x), Hash += val[f[v]];
}
f[x] = get(Hash);
ins(f[x]);
}
void dfs2(unsigned long long x, unsigned long long fa, unsigned long long ffa) {
del(f[x]);
if (ans + 1 > maxn) maxn = ans + 1, p = x;
unsigned long long siz = G[x].size();
unsigned long long Hash = 0;
for (unsigned long long i = 0; i < siz; i++)
if (G[x][i] != fa) Hash += val[f[G[x][i]]];
Hash += val[ffa];
for (unsigned long long i = 0; i < siz; i++) {
unsigned long long v = G[x][i];
if (v == fa) continue;
unsigned long long s = Hash - val[f[v]];
ins(get(s));
dfs2(v, x, get(s));
del(get(s));
}
ins(f[x]);
}
signed main() {
n = read();
for (unsigned long long i = 1; i <= n * 2; i++) val[i] = get_rnd();
for (unsigned long long i = 1; i < n; i++) {
unsigned long long x = read(), y = read();
G[x].push_back(y);
G[y].push_back(x);
}
for (unsigned long long i = 1; i <= n; i++) reverse(G[i].begin(), G[i].end());
dfs1(1, 0);
dfs2(1, 0, 0);
cout << p << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
vector<int> edge[maxn];
map<unsigned long long, int> all;
unsigned long long myhash[maxn];
int name[maxn];
int num_down[maxn];
int ans;
int tot;
int finnum;
unsigned long long seed[maxn];
int who;
unsigned long long make() {
return (unsigned long long)rand() << 48 | (unsigned long long)rand() << 32 |
(unsigned long long)rand() << 16 | (unsigned long long)rand();
}
int get_id(unsigned long long x) {
if (all[x] == 0) {
all[x] = tot;
tot++;
}
return all[x];
}
void dfs(int node, int pre) {
int len = edge[node].size();
myhash[node] = seed[0];
for (int i = 0; i < len; ++i) {
if (edge[node][i] == pre) continue;
dfs(edge[node][i], node);
myhash[node] += seed[name[edge[node][i]]];
}
int me = get_id(myhash[node]);
num_down[me]++;
name[node] = me;
}
unsigned long long head[maxn];
int as[maxn];
void dfs2(int node, int pre) {
int len = edge[node].size();
unsigned long long tmp = myhash[node];
num_down[name[node]]--;
if (num_down[name[node]] == 0) finnum--;
if (finnum > ans) {
ans = finnum;
who = node;
}
if (pre) tmp += seed[head[node]];
for (int i = 0; i < len; ++i) {
if (edge[node][i] == pre) continue;
unsigned long long test = tmp - seed[name[edge[node][i]]];
int me = get_id(test);
head[edge[node][i]] = me;
if (num_down[me] == 0) finnum++;
num_down[me]++;
dfs2(edge[node][i], node);
num_down[me]--;
if (num_down[me] == 0) finnum--;
}
if (num_down[name[node]] == 0) finnum++;
num_down[name[node]]++;
}
int main() {
int n;
srand(time(NULL));
scanf("%d", &n);
tot = 1;
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
edge[a].push_back(b);
edge[b].push_back(a);
}
for (int i = 0; i < maxn; ++i) seed[i] = make();
dfs(1, 0);
ans = 0;
who = 1;
finnum = tot - 1;
dfs2(1, 0);
printf("%d\n", who);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, sz[100005], mx[100005], ct;
vector<int> v[100005];
void fct(int id, int pv) {
sz[id] = 1;
for (int i = (0); i <= ((int)v[id].size() - 1); i++) {
int to = v[id][i];
if (to == pv) continue;
fct(to, id);
sz[id] += sz[to];
mx[id] = max(mx[id], sz[to]);
}
if (mx[id] * 2 <= n && (n - sz[id]) * 2 <= n) {
if (ct == 0) ct = id;
}
return;
}
void dfs(int id, int pv) {
sz[id] = 1;
for (int i = (0); i <= ((int)v[id].size() - 1); i++) {
int to = v[id][i];
if (to == pv) continue;
dfs(to, id);
sz[id] += sz[to];
}
return;
}
int m[3] = {1000000007, 1000000009, 1000000011};
int po[3][200005];
struct R {
int s[3], len;
bool operator<(const R &k) const {
for (int i = (0); i <= (2); i++)
if (s[i] != k.s[i]) return s[i] < k.s[i];
return false;
}
bool operator==(const R &k) const {
for (int i = (0); i <= (2); i++)
if (s[i] != k.s[i]) return false;
if (len != k.len) return false;
return true;
}
void add(int x) {
for (int i = (0); i <= (2); i++) {
s[i] += x;
if (s[i] >= m[i]) s[i] -= m[i];
}
}
void add(R u) {
for (int i = (0); i <= (2); i++) {
s[i] += u.s[i];
if (s[i] >= m[i]) s[i] -= m[i];
}
}
};
R h[100005];
vector<R> calc[100005];
int ans, av, cv;
void dfs2(int id, int pv) {
for (int i = (0); i <= ((int)v[id].size() - 1); i++) {
int to = v[id][i];
if (to == pv) continue;
dfs2(to, id);
calc[id].push_back(h[to]);
}
sort(calc[id].begin(), calc[id].end());
h[id].len = 2 * sz[id];
int clen = 1;
for (int i = (0); i <= ((int)calc[id].size() - 1); i++) {
for (int j = (0); j <= (2); j++) {
h[id].s[j] = (h[id].s[j] + 1LL * calc[id][i].s[j] * po[j][clen]) % m[j];
}
clen += calc[id][i].len;
}
for (int j = (0); j <= (2); j++) {
h[id].s[j] = (h[id].s[j] + po[j][clen]) % m[j];
}
return;
}
map<R, int> M;
void dfs3(int id, int pv) {
if (cv > av) {
av = cv;
ans = id;
}
for (int i = (0); i <= ((int)v[id].size() - 1); i++) {
int to = v[id][i];
if (to == pv) continue;
cv++;
M[h[to]]--;
if (M[h[to]] == 0) cv--;
dfs3(to, id);
cv--;
if (M[h[to]] == 0) cv++;
M[h[to]]++;
}
}
int main() {
for (int i = (0); i <= (2); i++) {
po[i][0] = 1;
for (int j = (1); j <= (200000); j++) {
po[i][j] = po[i][j - 1] * 2;
if (po[i][j] >= m[i]) po[i][j] -= m[i];
}
}
scanf("%d", &n);
for (int i = (2); i <= (n); i++) {
int a, b;
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
fct(1, 0);
dfs(ct, 0);
dfs2(ct, 0);
for (int i = (1); i <= (n); i++) {
if (!M.count(h[i])) {
cv++;
M[h[i]] = 1;
} else
M[h[i]]++;
}
ans = 1;
av = cv;
dfs3(ct, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int base = 100003;
using namespace std;
struct edge {
int to, next;
} G[maxn << 1];
int head[maxn], tot, tol, num[maxn << 1], id[maxn], ansv, ansnum, cnt;
map<unsigned long long, int> mp;
vector<int> vec[maxn];
vector<unsigned long long> sum[maxn];
unsigned long long p[maxn], h[maxn];
void init() {
memset(head, -1, sizeof(head));
tot = tol = 0;
}
void addedge(int u, int v) {
G[tot] = edge{v, head[u]};
head[u] = tot++;
}
int getid(unsigned long long x) {
if (mp.find(x) != mp.end()) return mp[x];
mp[x] = ++tol;
return tol;
}
void setid(int u) {
h[u] = 0;
if (!vec[u].empty()) {
sort(vec[u].begin(), vec[u].end());
sum[u].clear();
sum[u].push_back(vec[u][0]);
h[u] = vec[u][0];
for (int i = 1; i < vec[u].size(); ++i) {
h[u] = h[u] * base + vec[u][i];
sum[u].push_back(h[u]);
}
}
id[u] = getid(h[u]);
}
void add(int x) {
++num[x];
if (num[x] == 1) ++cnt;
}
void sub(int x) {
--num[x];
if (num[x] == 0) --cnt;
}
void dfs1(int u, int fa) {
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
dfs1(v, u);
vec[u].push_back(id[v]);
}
setid(u);
++num[id[u]];
}
void dfs2(int u, int fa) {
if (cnt > ansnum) {
ansv = u;
ansnum = cnt;
}
int sz = vec[u].size();
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
int pos = lower_bound(vec[u].begin(), vec[u].end(), id[v]) - vec[u].begin();
unsigned long long t = 0;
if (pos > 0) t += sum[u][pos - 1] * p[sz - pos - 1];
if (pos < sz - 1) t += sum[u].back() - sum[u][pos] * p[sz - pos - 1];
int tmp1 = getid(t), tmp2 = id[v];
vec[v].push_back(tmp1);
setid(v);
add(tmp1), add(id[v]), sub(id[u]), sub(tmp2);
dfs2(v, u);
add(id[u]), add(tmp2), sub(tmp1), sub(id[v]);
}
}
int main() {
p[0] = 1;
for (int i = 1; i < maxn; ++i) p[i] = p[i - 1] * base;
int n;
init();
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs1(1, 0);
ansnum = -1;
cnt = 0;
for (int i = 1; i <= tol; ++i)
if (num[i] > 0) ++cnt;
dfs2(1, 0);
printf("%d\n", ansv);
return 0;
}
| 10 | CPP |
#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);
}
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;
}
map<unsigned long long, int> mp;
int cur;
int get(unsigned long long first) {
if (mp.count(first)) return mp[first];
return mp[first] = ++cur;
}
unsigned long long val[100100 << 1];
int id[100100];
int cnt[100100 << 1], tot;
void add(int first) { tot += !cnt[first]++; }
void del(int first) { tot -= !--cnt[first]; }
unsigned long long sum[100100];
vector<int> adj[100100];
void dfs(int u, int f = 0) {
for (int v : adj[u]) {
if (v == f) continue;
dfs(v, u);
sum[u] += val[id[v]];
}
id[u] = get(sum[u]);
add(id[u]);
}
pair<int, int> ans;
void redfs(int u, int f = 0, int pre = 0) {
del(id[u]);
add(get(sum[u] + val[pre]));
smax(ans, pair<int, int>(tot, -u));
del(get(sum[u] + val[pre]));
for (int v : adj[u]) {
if (v == f) continue;
unsigned long long pp = sum[u] + val[pre] - val[id[v]];
add(get(pp));
redfs(v, u, get(pp));
del(get(pp));
}
add(id[u]);
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i < n << 1; i++)
val[i] = ((unsigned long long)rand() << 40) +
((unsigned long long)rand() << 20) + (unsigned long long)rand();
dfs(1);
redfs(1);
cout << -ans.second << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
vector<int> mp[100005];
int hs[100005], cnt;
unordered_map<int, int> idm;
int p3(int x) { return (long long)x * x % 1000000007 * x % 1000000007; }
void dfs(int x, int pa) {
hs[x] = 321239;
for (int c : mp[x])
if (c != pa) {
dfs(c, x);
addmod(hs[x], p3(hs[c]));
}
if (x != 1) {
if (idm.find(hs[x]) == idm.end()) cnt++;
idm[hs[x]]++;
}
}
int ans, mx;
void dfs2(int x, int pa, int H) {
idm[hs[x]]--;
if (idm[hs[x]] == 0) cnt--;
idm[H]++;
if (idm[H] == 1) cnt++;
if (cnt > mx) {
mx = cnt;
ans = x;
}
for (int c : mp[x])
if (c != pa) {
dfs2(c, x,
((long long)hs[x] + p3(H) - p3(hs[c]) + 1000000007) % 1000000007);
}
idm[H]--;
if (idm[H] == 0) cnt--;
idm[hs[x]]++;
if (idm[hs[x]] == 1) cnt++;
}
void fmain(int tid) {
scanf("%d", &n);
for (int i = 0, u, v; i < n - 1; i++) {
scanf("%d%d", &u, &v);
mp[u].push_back(v);
mp[v].push_back(u);
};
dfs(1, 0);
ans = 1;
mx = cnt;
for (int c : mp[1]) {
dfs2(c, 1, (hs[1] - p3(hs[c]) + 1000000007) % 1000000007);
}
printf("%d\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > tree;
vector<vector<long long> > frw_hash;
vector<vector<long long> > rev_hash;
vector<int> num;
const long long p = 179;
const long long mod = 1791791791l;
const int maxn = 1e6 + 179;
void get_all(int v, int par, unordered_map<long long, int>& ums) {
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]++;
get_all(u, v, ums);
}
i++;
}
}
void dfs(int v, int par, unordered_map<long long, int>& ums) {
num[v] = ums.size();
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]--;
if (ums[frw_hash[v][i]] == 0) ums.erase(frw_hash[v][i]);
ums[rev_hash[v][i]]++;
dfs(u, v, ums);
ums[rev_hash[v][i]]--;
if (ums[rev_hash[v][i]] == 0) ums.erase(rev_hash[v][i]);
ums[frw_hash[v][i]]++;
}
i++;
}
}
int main() {
long long ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) ppows[i] = (ppows[i - 1] * p) % mod;
int n;
cin >> n;
tree.resize(n);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
tree[u].push_back(v);
tree[v].push_back(u);
edges.push_back(make_pair(u, v));
edges.push_back(make_pair(v, u));
}
map<pair<int, int>, int> index;
for (int i = 0; i < 2 * n - 2; ++i) index[edges[i]] = i;
vector<long long> rem_hh(edges.size(), -1);
vector<int> sz_of(edges.size(), -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (tree[i].size() == 1) {
rem_hh[index[make_pair(tree[i][0], i)]] = ('(' * p + ')') % mod;
sz_of[index[make_pair(tree[i][0], i)]] = 1;
q.push(index[make_pair(tree[i][0], i)]);
}
}
vector<long long> hash_of(edges.size(), -1);
vector<int> out(n, 0);
while (!q.empty()) {
int a = q.front();
q.pop();
if (hash_of[a] != -1) continue;
hash_of[a] = rem_hh[a];
int v = edges[a].first;
out[v]++;
if (out[v] == tree[v].size() - 1) {
int u = -1;
vector<long long> known_outer_hashes;
vector<int> known_subtree_sizes;
for (int w : tree[v]) {
if (hash_of[index[make_pair(v, w)]] == -1)
u = w;
else {
known_outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
known_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
}
vector<int> ind(known_outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return known_outer_hashes[i] < known_outer_hashes[j];
});
vector<int> szs;
vector<long long> next_hh;
for (int i = 0; i < known_outer_hashes.size(); ++i) {
next_hh.push_back(known_outer_hashes[ind[i]]);
szs.push_back(known_subtree_sizes[ind[i]]);
}
int i = index[make_pair(u, v)];
rem_hh[i] = '(';
sz_of[i] = 1;
for (int j = 0; j < next_hh.size(); ++j) {
rem_hh[i] = (rem_hh[i] * ppows[2 * szs[j]]) % mod;
rem_hh[i] = (rem_hh[i] + next_hh[j]) % mod;
sz_of[i] += szs[j];
}
rem_hh[i] = (rem_hh[i] * p + ')') % mod;
q.push(i);
continue;
}
if (out[v] != tree[v].size()) continue;
vector<long long> outer_hashes;
vector<int> outer_subtree_sizes;
for (int w : tree[v]) {
outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
outer_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
vector<int> ind(outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return outer_hashes[i] < outer_hashes[j];
});
vector<long long> next_hh;
vector<int> szs;
for (int i = 0; i < outer_hashes.size(); ++i) {
next_hh.push_back(outer_hashes[ind[i]]);
szs.push_back(outer_subtree_sizes[ind[i]]);
}
vector<long long> pref_hh(next_hh.size() + 1, 0);
pref_hh[0] = '(';
for (int i = 1; i < next_hh.size() + 1; ++i) {
pref_hh[i] =
(pref_hh[i - 1] * ppows[2 * szs[i - 1]] + next_hh[i - 1]) % mod;
}
pref_hh.push_back((pref_hh.back() * p + ')') % mod);
vector<long long> suf_hh(next_hh.size() + 2, 0);
vector<int> suf_sz(next_hh.size() + 2, 0);
suf_hh.back() = ')';
for (int i = next_hh.size(); i > 0; i--) {
suf_hh[i] =
(suf_hh[i + 1] + next_hh[i - 1] * ppows[2 * suf_sz[i + 1] + 1]) % mod;
suf_sz[i] = suf_sz[i + 1] + szs[i - 1];
}
suf_hh[0] = (suf_hh[1] + '(' * ppows[2 * suf_sz[1] + 1]) % mod;
suf_sz[0] = suf_sz[1];
for (int i = 0; i < next_hh.size(); ++i) {
int u = tree[v][ind[i]];
if (rem_hh[index[make_pair(u, v)]] == -1) {
sz_of[index[make_pair(u, v)]] = n - sz_of[index[make_pair(v, u)]];
rem_hh[index[make_pair(u, v)]] =
(pref_hh[i] * ppows[2 * suf_sz[i + 2] + 1] + suf_hh[i + 2]) % mod;
q.push(index[make_pair(u, v)]);
}
}
}
frw_hash.resize(n);
rev_hash.resize(n);
num.resize(n);
for (int i = 0; i < n; ++i) {
for (int v : tree[i]) {
frw_hash[i].push_back(hash_of[index[make_pair(i, v)]]);
rev_hash[i].push_back(hash_of[index[make_pair(v, i)]]);
}
}
unordered_map<long long, int> ump;
get_all(0, -1, ump);
dfs(0, -1, ump);
cout << distance(num.begin(), max_element(num.begin(), num.end())) + 1
<< endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10;
const long long Base = 373;
const long long Mod = 1e9 + 7;
map<long long, long long> e;
vector<long long> vertex[MAXN];
long long h[MAXN];
long long f[MAXN];
long long ans[MAXN];
long long total = 0;
long long pw(long long x, long long n) {
if (n == 0) {
return 1;
}
long long w = pw(x, n / 2);
w *= w;
w %= Mod;
if (n & 1) {
w *= x;
w %= Mod;
}
return w;
}
void pre_dfs(long long v, long long par = -1) {
h[v] = 1;
for (long long i = 0; i < vertex[v].size(); i++) {
if (vertex[v][i] != par) {
pre_dfs(vertex[v][i], v);
h[v] += pw(Base, h[vertex[v][i]]);
h[v] %= Mod;
}
}
}
void main_dfs(long long v, long long par = -1) {
ans[v] = total;
for (long long i = 0; i < vertex[v].size(); i++) {
if (vertex[v][i] != par) {
long long k = f[v] - pw(Base, h[vertex[v][i]]) + Mod;
k %= Mod;
f[vertex[v][i]] = h[vertex[v][i]] + pw(Base, k);
f[vertex[v][i]] %= Mod;
e[k]++;
total += (e[k] == 1);
e[f[vertex[v][i]]]++;
total += (e[f[vertex[v][i]]] == 1);
e[f[v]]--;
total -= (e[f[v]] == 0);
e[h[vertex[v][i]]]--;
total -= (e[h[vertex[v][i]]] == 0);
main_dfs(vertex[v][i], v);
e[k]--;
total -= (e[k] == 0);
e[f[vertex[v][i]]]--;
total -= (e[f[vertex[v][i]]] == 0);
e[f[v]]++;
total += (e[f[v]] == 1);
e[h[vertex[v][i]]]++;
total += (e[h[vertex[v][i]]] == 1);
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < (n - 1); i++) {
long long v, u;
cin >> v >> u;
vertex[v].push_back(u);
vertex[u].push_back(v);
}
pre_dfs(1);
for (long long i = 1; i <= n; i++) {
e[h[i]]++;
total += (e[h[i]] == 1);
}
f[1] = h[1];
main_dfs(1);
pair<long long, long long> res = make_pair(0, 0);
for (long long i = 1; i <= n; i++) {
res = max(res, make_pair(ans[i], i));
}
cout << res.second;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const int N = 100010;
vector<int> m[N];
int n, u[N], d[N], p[N];
pair<double, double> h[N];
void dfs(int i) {
u[i] = 1;
for (auto j : m[i])
if (!u[j]) {
d[j] = d[i] + 1;
p[j] = i;
dfs(j);
}
}
int fndlong(int i) {
for (int j = 0; j < n; u[j] = 0, j++)
;
int bj = 0;
d[i] = 0;
dfs(i);
for (int j = 0; j < n; j++)
if (d[j] > d[bj]) bj = j;
return bj;
}
void insv(int i, int j) {
m[i].erase(find(m[i].begin(), m[i].end(), j));
m[j].erase(find(m[j].begin(), m[j].end(), i));
m[i].push_back(n);
m[j].push_back(n);
m[n].push_back(i);
m[n].push_back(j);
}
map<pair<double, double>, int> w;
void dfs2(int i) {
u[i] = 1;
vector<pair<double, double> > d;
for (auto j : m[i])
if (!u[j]) {
dfs2(j);
d.push_back(h[j]);
}
sort(d.begin(), d.end());
h[i] = {0, 0};
for (auto x : d) {
h[i].first += cos(x.first + 1);
h[i].second += sin(x.second + 1);
}
w[h[i]]++;
}
void dfs3(int i) {
u[i] = 1;
p[i] = -1;
d[i] = 0;
for (auto j : m[i])
if (!u[j]) {
dfs3(j);
if (d[j] > d[i]) {
d[i] = d[j];
p[i] = j;
}
}
d[i] += w[h[i]] > 1;
}
int main() {
int i, j, k;
scanf("%d", &n);
for (k = n - 1; k--;
scanf("%d%d", &i, &j), i--, j--, m[i].push_back(j), m[j].push_back(i))
;
i = fndlong(0);
i = fndlong(i);
j = fndlong(i);
int l = 0;
for (k = j; k != i; l++, k = p[k])
;
int c = l / 2;
for (k = j; c > 0; c--, k = p[k])
;
c = k;
if (l % 2) {
insv(c, p[c]);
c = n;
n++;
}
for (i = 0; i < n; u[i] = 0, i++)
;
dfs2(c);
for (i = 0; i < n; u[i] = 0, i++)
;
dfs3(c);
for (i = c; p[i] != -1; i = p[i])
;
printf("%d\n", i + 1);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[100002];
const int h_num = 2;
long long int B[] = {1011235817, 1011235817, 1011235817, 987654347, 1011235817,
1021328611, 987654347, 1011235817, 1000000007};
struct HASH {
vector<long long int> val;
bool emp;
HASH(int v_ = 0) {
val.assign(h_num, 0);
emp = false;
for (int i = 0; i < h_num; i++) {
val[i] = v_;
}
}
vector<long long int> get() { return val; }
};
HASH R[100002];
HASH operator*(const HASH &a, const HASH &b) {
if (a.emp) {
return b;
}
if (b.emp) {
return a;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] * b.val[i];
if (r.val[i] >= B[i]) r.val[i] %= B[i];
}
return r;
}
HASH operator+(const HASH &a, HASH &b) {
if (a.emp) {
return a;
}
if (b.emp) {
return b;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] + b.val[i];
if (r.val[i] >= B[i]) {
r.val[i] %= B[i];
}
}
return r;
}
HASH h[100002];
map<vector<long long int>, int> tmp;
int dep[100002];
inline void dfs(int b, int pr = -1) {
vector<HASH> vv;
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
dfs(v[b][i], b);
dep[b] = max(dep[b], dep[v[b][i]] + 1);
}
}
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
vv.push_back(h[v[b][i]] + R[dep[b]]);
}
}
if (vv.size() == 0) {
h[b] = HASH(1);
return;
}
HASH sum = vv[0];
for (int i = 1; i < vv.size(); i++) {
sum = sum * vv[i];
}
h[b] = sum;
return;
}
int maxt;
int idd;
inline void dfs2(int b, int pr, map<vector<long long int>, int> &mp, HASH par2,
int par_dep) {
par_dep++;
mp[h[b].get()]--;
if (mp[h[b].get()] == 0) {
mp.erase(h[b].get());
}
vector<HASH> vv[2];
vector<HASH> im1[2];
vector<HASH> im2[2];
vector<int> H;
H.push_back(par_dep);
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
H.push_back(dep[v[b][i]] + 1);
}
}
sort(H.begin(), H.end(), greater<int>());
if (H.size() == 1) {
H.push_back(H.back());
}
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
for (int j = 0; j < 2; j++) {
vv[j].push_back(h[v[b][i]] + R[H[j]]);
}
}
}
for (int j = 0; j < 2; j++) {
im1[j] = im2[j] = vv[j];
}
for (int j = 0; j < 2; j++) {
for (int i = 1; i < im1[j].size(); i++) {
im1[j][i] = im1[j][i] * im1[j][i - 1];
}
for (int i = (int)(im2[j].size()) - 2; i >= 0; i--) {
im2[j][i] = im2[j][i] * im2[j][i + 1];
}
}
HASH par[2];
par[0] = par2 + R[H[0]];
par[1] = par2 + R[H[1]];
HASH cur[2];
cur[0] = par[0];
cur[1] = par[1];
for (int j = 0; j < 2; j++) {
if (im1[j].size()) {
cur[j] = cur[j] * im1[j].back();
}
}
mp[cur[0].get()]++;
if (maxt < mp.size()) {
maxt = mp.size();
idd = b;
}
if (maxt == mp.size()) {
idd = min(idd, b);
}
mp[cur[0].get()]--;
if (mp[cur[0].get()] == 0) {
mp.erase(cur[0].get());
}
int id = -1;
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] == pr) continue;
id++;
HASH go;
go.emp = true;
int flag = 0;
if (H[0] == dep[v[b][i]] + 1) {
flag++;
}
if (id) {
go = go * im1[flag][id - 1];
}
if (id + 1 < im2[flag].size()) {
go = go * im2[flag][id + 1];
}
go = go * par[flag];
if (go.emp == true) {
go = HASH(1);
}
mp[go.get()]++;
dfs2(v[b][i], b, mp, go, H[flag]);
mp[go.get()]--;
if (mp[go.get()] == 0LL) {
mp.erase(go.get());
}
}
mp[h[b].get()]++;
}
bool use[5000000];
vector<int> pr;
int main() {
for (int i = 2; i < 5000000; i++) {
if (use[i] == false) {
for (int j = i * 2; j < 5000000; j += i) {
use[j] = true;
}
pr.push_back(i);
}
}
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
srand(time(NULL));
for (int i = 0; i < 100002; i++) {
for (int j = 0; j < h_num; j++) {
R[i].val[j] = rand() % B[0];
}
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
int root = 0;
dfs(root);
for (int i = 0; i < n; i++) {
tmp[h[i].get()]++;
}
HASH f;
f.emp = true;
dfs2(root, -1, tmp, f, -1);
cout << idd + 1 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
map<unsigned long long, unsigned long long> hmp;
unsigned long long get(unsigned long long x) {
if (hmp.count(x)) return hmp[x];
return hmp[x] = (1ull * rand()) << 40 | (1ull * rand()) << 20 | rand();
}
vector<int> g[N];
unsigned long long f[N], h[N];
void dfs1(int u, int p) {
for (int v : g[u])
if (v != p) dfs1(v, u), f[u] += f[v];
f[u] = get(f[u]);
}
void dfs2(int u, int p, unsigned long long x) {
h[u] = x;
for (int v : g[u])
if (v != p) x += f[v];
for (int v : g[u])
if (v != p) dfs2(v, u, get(x - f[v]));
}
map<unsigned long long, int> cnt;
int cur;
void add(unsigned long long x) { cur += (cnt[x]++) == 0; }
void sub(unsigned long long x) { cur -= (--cnt[x]) == 0; }
int ans[N];
void dfs3(int u, int p) {
ans[u] = cur;
for (int v : g[u])
if (v != p) {
sub(f[v]), add(h[v]);
dfs3(v, u);
add(f[v]), sub(h[v]);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v), g[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0, 0);
for (int i = 2; i <= n; i++) add(f[i]);
dfs3(1, 0);
int x = 1;
for (int i = 1; i <= n; i++)
if (ans[i] > ans[x]) x = i;
cout << x << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<vector<int>, int> f;
vector<int> v[100010];
int sz[100010], tp[100010], cnt, gas[100010];
int n, a, b, cur, ans, val, mx;
void dfs_size(int x, int pre) {
sz[x] = 1;
for (auto y : v[x])
if (pre != y) {
dfs_size(y, x);
sz[x] += sz[y];
}
}
void find_cur() {
bool fg = true;
while (fg) {
fg = false;
for (auto y : v[cur])
if (sz[y] < sz[cur]) {
if (sz[y] * 2 >= n) {
cur = y;
fg = true;
break;
}
}
}
}
void dfs_type(int x, int pre) {
vector<int> tmp;
for (auto y : v[x])
if (pre != y) {
dfs_type(y, x);
tmp.push_back(tp[y]);
}
sort(tmp.begin(), tmp.end());
int tt = f[tmp];
if (tt)
tp[x] = tt;
else
f[tmp] = tp[x] = ++cnt;
}
void dfs_find(int x, int pre, int val) {
if (gas[tp[x]] > 1) val++;
if (val > mx) {
ans = x, mx = val;
}
for (auto y : v[x])
if (y != pre) {
dfs_find(y, x, val);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &b);
a--, b--;
v[a].push_back(b);
v[b].push_back(a);
}
dfs_size(0, -1);
find_cur();
dfs_type(cur, -1);
for (int i = 0; i < n; i++) gas[tp[i]]++;
dfs_find(cur, -1, 0);
printf("%d\n", ans + 1);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int base = 100003;
using namespace std;
struct edge {
int to, next;
} G[maxn << 1];
int head[maxn], tot, tol, num[maxn << 1], id[maxn], ansv, ansnum, cnt;
map<unsigned long long, int> mp;
vector<int> vec[maxn];
vector<unsigned long long> sum[maxn];
unsigned long long p[maxn], h[maxn];
void init() {
memset(head, -1, sizeof(head));
tot = tol = 0;
}
void addedge(int u, int v) {
G[tot] = edge{v, head[u]};
head[u] = tot++;
}
int getid(unsigned long long x) {
if (mp.find(x) != mp.end()) return mp[x];
mp.insert(pair<unsigned long long, int>(x, ++tol));
return tol;
}
void setid(int u) {
h[u] = 0;
if (!vec[u].empty()) {
sort(vec[u].begin(), vec[u].end());
sum[u].clear();
sum[u].push_back(vec[u][0]);
h[u] = vec[u][0];
for (int i = 1; i < vec[u].size(); ++i) {
h[u] = h[u] * base + vec[u][i];
sum[u].push_back(h[u]);
}
}
id[u] = getid(h[u]);
}
void add(int x) {
++num[x];
if (num[x] == 1) ++cnt;
}
void sub(int x) {
--num[x];
if (num[x] == 0) --cnt;
}
void dfs1(int u, int fa) {
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
dfs1(v, u);
vec[u].push_back(id[v]);
}
setid(u);
++num[id[u]];
}
void dfs2(int u, int fa) {
if (cnt > ansnum) {
ansv = u;
ansnum = cnt;
}
int sz = vec[u].size();
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
int pos = lower_bound(vec[u].begin(), vec[u].end(), id[v]) - vec[u].begin();
unsigned long long t = 0;
if (pos > 0) t += sum[u][pos - 1] * p[sz - pos - 1];
if (pos < sz - 1) t += sum[u].back() - sum[u][pos] * p[sz - pos - 1];
int tmp1 = getid(t), tmp2 = id[v];
vec[v].push_back(tmp1);
setid(v);
add(tmp1), add(id[v]), sub(id[u]), sub(tmp2);
dfs2(v, u);
add(id[u]), add(tmp2), sub(tmp1), sub(id[v]);
}
}
int main() {
p[0] = 1;
for (int i = 1; i < maxn; ++i) p[i] = p[i - 1] * base;
int n;
init();
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs1(1, 0);
ansnum = -1;
cnt = 0;
for (int i = 1; i <= tol; ++i)
if (num[i] > 0) ++cnt;
dfs2(1, 0);
printf("%d\n", ansv);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = pair<int, int>;
const ll p = 179;
const ll mod = 1791791791l;
const int maxn = 1e6 + 179;
struct TreeData {
TreeData(ll h, int s) : hash(h), size(s) {}
ll hash;
int size;
bool operator<(const TreeData& td) const { return hash < td.hash; }
};
int n;
vector<vector<int>> nbrs;
vector<Edge> edges;
map<Edge, ll> hash_of;
void Load() {
scanf("%d", &n);
nbrs.resize(n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
nbrs[a].push_back(b);
nbrs[b].push_back(a);
edges.push_back({a, b});
edges.push_back({b, a});
}
}
void CollectHashes(int v, int fromv, unordered_map<ll, int>* curhashes) {
for (int i = 0; i < nbrs[v].size(); ++i) {
if (nbrs[v][i] != fromv) {
Edge e(v, nbrs[v][i]);
ll val = hash_of[e];
(*curhashes)[val]++;
CollectHashes(nbrs[v][i], v, curhashes);
}
}
}
void EulerTourDFS(int v, int fromv, unordered_map<ll, int>* curhashes, int* ans,
int* maxhashes) {
Edge e(v, fromv);
Edge ef(fromv, v);
if (fromv != -1) {
(*curhashes)[hash_of[ef]]--;
if ((*curhashes)[hash_of[ef]] == 0) {
curhashes->erase(hash_of[ef]);
}
(*curhashes)[hash_of[e]]++;
}
if (curhashes->size() > *maxhashes) {
*maxhashes = curhashes->size();
*ans = v;
}
for (int i = 0; i < nbrs[v].size(); ++i) {
if (nbrs[v][i] != fromv) {
EulerTourDFS(nbrs[v][i], v, curhashes, ans, maxhashes);
}
}
(*curhashes)[hash_of[ef]]++;
(*curhashes)[hash_of[e]]--;
if ((*curhashes)[hash_of[e]] == 0) {
curhashes->erase(hash_of[e]);
}
}
void Solve() {
ll ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) {
ppows[i] = (ppows[i - 1] * p) % mod;
}
queue<Edge> q;
map<Edge, int> size_of;
vector<int> out(n, 0);
for (int i = 0; i < edges.size(); ++i) {
if (nbrs[edges[i].second].size() == 1) {
hash_of[edges[i]] = '(' * p + ')';
size_of[edges[i]] = 1;
out[edges[i].first]++;
q.push(edges[i]);
}
}
vector<bool> fulloutcalc(n, false);
vector<bool> mostoutcalc(n, false);
while (!q.empty()) {
Edge e = q.front();
q.pop();
int v = e.first;
if (out[v] == nbrs[v].size() - 1) {
if (mostoutcalc[v]) continue;
mostoutcalc[v] = true;
int u;
vector<TreeData> known;
for (int i = 0; i < nbrs[v].size(); ++i) {
if (hash_of.count({v, nbrs[v][i]}) == 0) {
u = nbrs[v][i];
continue;
}
known.push_back({hash_of[{v, nbrs[v][i]}], size_of[{v, nbrs[v][i]}]});
}
sort((known).begin(), (known).end());
Edge ne = {u, v};
int size = 1;
hash_of[ne] = '(';
for (int i = 0; i < known.size(); ++i) {
hash_of[ne] = (hash_of[ne] * ppows[2 * known[i].size]) % mod;
hash_of[ne] = (hash_of[ne] + known[i].hash) % mod;
size += known[i].size;
}
hash_of[ne] = (hash_of[ne] * p + ')') % mod;
size_of[ne] = size;
out[u]++;
q.push(ne);
continue;
}
if (out[v] != nbrs[v].size()) {
continue;
}
if (fulloutcalc[v]) continue;
fulloutcalc[v] = true;
vector<int> sorted_indices(nbrs[v].size(), 0);
iota((sorted_indices).begin(), (sorted_indices).end(), 0);
sort((sorted_indices).begin(), (sorted_indices).end(),
[v](const ll a, const ll b) {
Edge e1(v, nbrs[v][a]);
Edge e2(v, nbrs[v][b]);
return hash_of[e1] < hash_of[e2];
});
vector<ll> pref(nbrs[v].size(), 0), suf(nbrs[v].size(), 0),
suf_sz(nbrs[v].size(), 0);
pref[0] = '(';
for (int i = 1; i < nbrs[v].size(); ++i) {
pref[i] = (pref[i - 1] *
ppows[2 * size_of[{v, nbrs[v][sorted_indices[i - 1]]}]]) %
mod;
pref[i] = (pref[i] + hash_of[{v, nbrs[v][sorted_indices[i - 1]]}]) % mod;
}
suf[nbrs[v].size() - 1] = ')';
suf_sz[nbrs[v].size() - 1] = 0;
for (int i = nbrs[v].size() - 2; i >= 0; --i) {
suf[i] = (suf[i + 1] + hash_of[{v, nbrs[v][sorted_indices[i + 1]]}] *
ppows[2 * suf_sz[i + 1] + 1]) %
mod;
Edge e(v, nbrs[v][sorted_indices[i + 1]]);
suf_sz[i] = suf_sz[i + 1] + size_of[e];
}
for (int i = 0; i < nbrs[v].size(); ++i) {
Edge e(nbrs[v][sorted_indices[i]], v);
Edge ef(v, nbrs[v][sorted_indices[i]]);
if (hash_of[e] == 0) {
hash_of[e] = (pref[i] * ppows[2 * suf_sz[i] + 1]) % mod;
hash_of[e] = (hash_of[e] + suf[i]) % mod;
size_of[e] = n - size_of[ef];
out[nbrs[v][sorted_indices[i]]]++;
q.push({nbrs[v][sorted_indices[i]], v});
}
}
}
unordered_map<ll, int> curhashes;
CollectHashes(0, -1, &curhashes);
int ans = curhashes.size(), maxhashes = 0;
EulerTourDFS(0, -1, &curhashes, &ans, &maxhashes);
printf("%d\n", ans + 1);
}
int main() {
Load();
Solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int y, nex;
} a[2 * 110000];
struct node1 {
int y;
int d;
} A[110000];
int n, fir[110000], len, num, ans, mx, cnt;
int f[110000], g[110000], cf[110000], siz[110000];
map<pair<int, int>, int> ma;
vector<int> v[110000], p[110000], s[110000];
void ins(int x, int y) {
a[++len].y = y;
a[len].nex = fir[x];
fir[x] = len;
}
void change(int x, int y, int d) {
pair<int, int> t = make_pair(x, y);
if (ma.count(t) == 0) ma[t] = 0;
if (ma[t]) cnt--;
ma[t] += d;
if (ma[t]) cnt++;
}
bool cmp(node1 x, node1 y) {
if (x.d < y.d) return 1;
return 0;
}
void dfs(int x, int fa) {
siz[x] = 1;
for (int k = fir[x]; k; k = a[k].nex) {
int y = a[k].y;
if (y == fa) continue;
dfs(y, x);
siz[x] += siz[y];
}
num = 0;
for (int k = fir[x]; k; k = a[k].nex) {
int y = a[k].y;
if (y == fa) continue;
A[++num].d = f[y];
}
sort(A + 1, A + num + 1, cmp);
for (int i = 1; i <= num; i++) f[x] += A[i].d * cf[i];
f[x] += siz[x];
}
void dp(int x, int fa) {
change(f[x], siz[x], -1);
num = 0;
for (int k = fir[x]; k; k = a[k].nex) {
int y = a[k].y;
A[++num].y = y;
if (y != fa)
A[num].d = f[y];
else
A[num].d = g[y];
}
sort(A + 1, A + num + 1, cmp);
for (int i = 0; i <= num + 1; i++)
v[x].push_back(0), p[x].push_back(0), s[x].push_back(0);
for (int i = 1; i <= num; i++)
v[x][i] = A[i].y, p[x][i] = p[x][i - 1] + A[i].d * cf[i];
for (int i = num; i >= 1; i--) s[x][i] = s[x][i + 1] * 1000000007 + A[i].d;
int h = p[x][num] + n;
change(h, n, 1);
if (cnt > mx) {
mx = cnt;
ans = x;
}
int tmp = num;
change(h, n, -1);
for (int i = 1; i <= tmp; i++) {
int y = v[x][i];
if (y == fa) continue;
g[x] = p[x][i - 1] + s[x][i + 1] * cf[i] + n - siz[y];
change(g[x], n - siz[y], 1);
dp(y, x);
change(g[x], n - siz[y], -1);
}
change(f[x], siz[x], 1);
}
int main() {
scanf("%d", &n);
cf[0] = 1;
for (int i = 1; i <= n; i++) cf[i] = cf[i - 1] * 1000000007;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ins(x, y);
ins(y, x);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) change(f[i], siz[i], 1);
dp(1, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD[] = {1000000007, 1000000009};
struct Hash {
int val[2];
Hash(int x = 0) { val[0] = val[1] = x; }
};
Hash operator+(const Hash &a, const Hash &b) {
Hash res;
for (int i = (0); i <= (1); ++i) res.val[i] = (a.val[i] + b.val[i]) % MOD[i];
return res;
}
Hash operator-(const Hash &a, const Hash &b) {
Hash res;
for (int i = (0); i <= (1); ++i)
res.val[i] = (a.val[i] + MOD[i] - b.val[i]) % MOD[i];
return res;
}
Hash operator*(const Hash &a, const Hash &b) {
Hash res;
for (int i = (0); i <= (1); ++i)
res.val[i] = ((long long)a.val[i] * b.val[i]) % MOD[i];
return res;
}
bool operator<(const Hash &a, const Hash &b) {
return make_pair(a.val[0], a.val[1]) < make_pair(b.val[0], b.val[1]);
}
bool operator==(const Hash &a, const Hash &b) {
for (int i = (0); i <= (1); ++i)
if (a.val[i] != b.val[i]) return false;
return true;
}
struct Task {
int n;
vector<vector<int> > g;
Task() {
cin >> n;
g = vector<vector<int> >(n);
for (int i = (1); i <= (n - 1); ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
}
vector<Hash> hashDown, hashUp;
void dfsDown(int v, int par) {
for (int u : g[v])
if (u != par) {
dfsDown(u, v);
hashDown[v] = hashDown[v] + hashDown[u] * hashDown[u] * hashDown[u];
}
}
void dfsUp(int v, int par) {
for (int u : g[v])
if (u != par) {
hashUp[u] = hashDown[v] - hashDown[u] * hashDown[u] * hashDown[u];
hashUp[u] = hashUp[u] + hashUp[v] * hashUp[v] * hashUp[v];
dfsUp(u, v);
}
}
int best, ans = -1;
map<Hash, int> cnt;
void change(Hash hsh, int chg) {
cnt[hsh] += chg;
if (chg == -1 && cnt[hsh] == 0) {
cnt.erase(hsh);
}
}
void dfsSolve(int v, int par) {
int here = cnt.size();
if (here > ans) {
ans = here;
best = v;
}
for (int u : g[v])
if (u != par) {
change(hashDown[u], -1);
change(hashUp[u], 1);
dfsSolve(u, v);
change(hashDown[u], 1);
change(hashUp[u], -1);
}
}
void solve() {
hashDown = vector<Hash>(n, 1);
hashUp = vector<Hash>(n);
dfsDown(0, -1);
dfsUp(0, -1);
for (int i = (1); i <= (n - 1); ++i) {
cnt[hashDown[i]]++;
}
dfsSolve(0, -1);
cout << 1 + best;
}
};
int main() {
ios_base::sync_with_stdio(0);
Task().solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& _p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& _V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& _S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& _M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const unsigned long long INF = 1000000100;
const long double EPS = 1e-9;
map<pair<unsigned long long, pair<unsigned long long, unsigned long long>>,
unsigned long long>
H;
vector<int> V[100100];
int n;
unsigned long long mH[100100];
int Odw[100100], diff;
pair<int, int> ans;
map<int, int> Ile;
unsigned long long S1[100100];
unsigned long long S2[100100];
unsigned long long S3[100100];
unsigned long long HASH(unsigned long long c, unsigned long long a,
unsigned long long b) {
return ((a ^ b) + (c * c * c) + 12344121) ^ 4372321658131;
if (H.find(make_pair(a, make_pair(b, c))) == H.end()) {
H[make_pair(a, make_pair(b, c))] = rand();
}
return H[make_pair(a, make_pair(b, c))];
}
void dfs(int a) {
Odw[a] = 1;
unsigned long long s1 = 4321478328667919ll;
unsigned long long s2 = 432781477312874ll;
unsigned long long s3 = 347582818888181ll;
for (int v : V[a]) {
if (Odw[v]) continue;
dfs(v);
s1 ^= mH[v];
s2 += mH[v] * mH[v];
s3 += mH[v] * mH[v] * mH[v];
}
mH[a] = HASH(s1, s2, s3);
S1[a] = s1;
S2[a] = s2;
S3[a] = s3;
}
int GW[100100];
void go(int a, unsigned long long gg) {
Ile[mH[a]]--;
if (Ile[mH[a]] == 0) diff--;
ans = max(ans, make_pair(diff, a));
if (0)
cerr << diff << " a:" << a << " "
<< "\n";
GW[a] = 1;
for (int v : V[a]) {
if (GW[v]) continue;
unsigned long long ns1 = (S1[a] ^ mH[v] ^ gg);
unsigned long long ns2 = (S2[a] - mH[v] * mH[v] + gg * gg);
unsigned long long ns3 = (S3[a] - mH[v] * mH[v] * mH[v] + gg * gg * gg);
int nh = HASH(ns1, ns2, ns3);
if (Ile[nh] == 0) diff++;
Ile[nh]++;
go(v, nh);
Ile[nh]--;
if (Ile[nh] == 0) diff--;
}
Ile[mH[a]]++;
if (Ile[mH[a]] == 1) diff++;
}
int main() {
srand(time(NULL));
scanf("%d", &n);
for (int(i) = (1); (i) < (n); (i)++) {
int a, b;
scanf("%d%d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
int root = 1;
dfs(root);
for (int(i) = (1); (i) <= (n); (i)++) {
Ile[mH[i]]++;
if (Ile[mH[i]] == 1) diff++;
}
go(root, 0);
cout << ans.second << endl;
;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100011;
const long long Hashstart = 0x129847DABCEF194LL, Index = 7,
Hashxor = 218979012481290125LL;
int now[maxn], pre[maxn << 1], son[maxn << 1], tot = 0;
void add(int a, int b) {
pre[++tot] = now[a];
now[a] = tot;
son[tot] = b;
}
void cc(int a, int b) {
add(a, b);
add(b, a);
}
int n;
void init() {
scanf("%d", &n);
for (int i = 1, a, b; i < n; ++i) scanf("%d%d", &a, &b), cc(a, b);
}
long long Down[maxn], Up[maxn];
void dfs1(int x, int fa) {
long long tmp = Hashstart;
for (int p = now[x]; p; p = pre[p])
if (son[p] != fa) {
dfs1(son[p], x);
tmp += Down[son[p]] * Index;
}
Down[x] = tmp ^ Hashxor;
}
void dfs2(int x, int fa) {
long long tmp = Down[x];
if (x != 1) {
tmp ^= Hashxor;
tmp += Up[x] * Index;
tmp ^= Hashxor;
}
for (int p = now[x]; p; p = pre[p])
if (son[p] != fa)
Up[son[p]] = ((tmp ^ Hashxor) - Down[son[p]] * Index) ^ Hashxor;
for (int p = now[x]; p; p = pre[p])
if (son[p] != fa) dfs2(son[p], x);
}
map<long long, int> S;
int ans1, ans2, sum;
void dfs3(int x, int fa) {
if (sum > ans2) ans1 = x, ans2 = sum;
for (int p = now[x]; p; p = pre[p])
if (son[p] != fa) {
if (--S[Down[son[p]]] == 0) --sum;
if (++S[Up[son[p]]] == 1) ++sum;
dfs3(son[p], x);
if (++S[Down[son[p]]] == 1) ++sum;
if (--S[Up[son[p]]] == 0) --sum;
}
}
void work() {
dfs1(1, 0);
Up[1] = 1;
dfs2(1, 0);
S.clear();
for (int i = 2; i <= n; ++i) ++S[Down[i]];
ans1 = 1;
sum = ans2 = S.size();
dfs3(1, 0);
printf("%d\n", ans1);
}
int main() {
init();
work();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int mod1 = 1e9 + 9;
int pwr(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
int pwr1(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod1;
a = (a * 1LL * a) % mod1;
b >>= 1;
}
return ans;
}
const int N = 1e5 + 5;
vector<int> g[N];
long long h[N], ph[N];
long long h1[N], ph1[N];
const long long P = 89512517;
const long long P1 = 75273453;
const int S1 = 986123;
const int S2 = 127836;
inline int max(int a, int b) { return ((a > b) ? a : b); }
void dfs(int u, int p) {
h[u] = S1;
h1[u] = S2;
for (int v : g[u]) {
if (v != p) {
dfs(v, u);
h[u] = (h[u] * (h[v] ^ P)) % mod;
h1[u] = (h1[u] * (h1[v] ^ P1)) % mod1;
}
}
}
void dfs1(int u, int p) {
long long val = h[u], val1 = h1[u];
if (p) {
val = (val * (ph[u] ^ P)) % mod;
val1 = (val1 * (ph1[u] ^ P1)) % mod1;
}
for (int v : g[u]) {
if (v != p) {
ph[v] = (val * pwr((h[v] ^ P) % mod, mod - 2)) % mod;
ph1[v] = (val1 * pwr1((h1[v] ^ P1) % mod1, mod1 - 2)) % mod1;
dfs1(v, u);
}
}
}
int ans = -1, best = 0;
map<pair<long long, long long>, int> s;
inline void add(pair<long long, long long> a) { s[a]++; }
inline void del(pair<long long, long long> a) {
s[a]--;
if (s[a] == 0) s.erase(a);
}
void dfs2(int u, int p) {
if (ans < (int)s.size()) {
ans = s.size(), best = u;
}
for (int v : g[u]) {
if (v != p) {
pair<long long, long long> a = {h[v], h1[v]}, b = {ph[v], ph1[v]};
del(a);
add(b);
dfs2(v, u);
add(a);
del(b);
}
}
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int root = 1;
dfs(root, 0);
dfs1(root, 0);
for (int i = 2; i <= n; i++) {
add({h[i], h1[i]});
}
dfs2(root, 0);
cout << best << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> E[101000], L[101000], Ch[101000];
int n, C[101000], D[101000], cnt, Num[101000];
int S[101000];
map<vector<int>, int> Map;
void DFS(int a, int pp) {
int i;
C[a] = 1;
for (i = 0; i < E[a].size(); i++) {
if (E[a][i] != pp) {
DFS(E[a][i], a);
C[a] += C[E[a][i]];
}
}
}
void DFS2(int a, int pp) {
int i;
for (i = 0; i < E[a].size(); i++) {
if (E[a][i] != pp) {
Ch[a].push_back(E[a][i]);
DFS2(E[a][i], a);
D[a] = max(D[a], D[E[a][i]] + 1);
}
}
}
void Ins(int a) {
vector<int> TP;
int i;
for (i = 0; i < Ch[a].size(); i++) {
TP.push_back(Num[Ch[a][i]]);
}
if (!TP.empty()) sort(TP.begin(), TP.end());
if (!Map[TP]) {
Map[TP] = ++cnt;
Num[a] = cnt;
} else
Num[a] = Map[TP];
}
int R, res, Ans;
void Do(int a, int c) {
S[Num[a]]--;
if (!S[Num[a]]) R--;
if (res < R + c) {
res = R + c;
Ans = a;
}
int i;
for (i = 0; i < Ch[a].size(); i++) {
Do(Ch[a][i], c + 1);
}
if (!S[Num[a]]) R++;
S[Num[a]]++;
}
int main() {
int i, a, b, j;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
E[a].push_back(b);
E[b].push_back(a);
}
DFS(1, 0);
int Mn = n + 1, x = -1;
for (i = 1; i <= n; i++) {
if (C[i] * 2 > n && Mn > C[i]) Mn = C[i], x = i;
}
DFS2(x, 0);
for (i = 1; i <= n; i++) L[D[i]].push_back(i);
for (i = 0; i < n; i++) {
Map.clear();
for (j = 0; j < L[i].size(); j++) {
Ins(L[i][j]);
}
}
for (i = 1; i <= n; i++) {
S[Num[i]]++;
}
R = cnt;
res = 0;
Do(x, 1);
printf("%d\n", Ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
const long long BASE = 181;
const long long MOD = 1000000009;
vector<int> g[1 + MAXN];
vector<pair<int, int> > edges;
queue<int> Queue;
map<pair<int, int>, int> number;
vector<long long> add[1 + MAXN], subtract[1 + MAXN];
long long code[2 * MAXN], value[2 * MAXN];
int nodes[2 * MAXN];
int degree[1 + MAXN];
long long power[10 * MAXN];
int answer[1 + MAXN];
struct Son {
long long code;
int nodes;
int index;
bool operator<(const Son &other) const { return code < other.code; }
};
unordered_map<long long, int> seen;
void Initialize(int node, int father) {
int i = 0;
for (auto &son : g[node]) {
if (son != father) {
seen[add[node][i]]++;
Initialize(son, node);
}
i++;
}
}
void DFS(int node, int father) {
answer[node] = seen.size();
int i = 0;
for (auto &son : g[node]) {
if (son != father) {
seen[add[node][i]]--;
if (seen[add[node][i]] == 0) seen.erase(add[node][i]);
seen[subtract[node][i]]++;
DFS(son, node);
seen[subtract[node][i]]--;
if (seen[subtract[node][i]] == 0) seen.erase(subtract[node][i]);
seen[add[node][i]]++;
}
i++;
}
}
int main() {
power[0] = 1;
for (int i = 1; i < 10 * MAXN; i++) power[i] = (power[i - 1] * BASE) % MOD;
int n;
cin >> n;
if (n == 1) {
cout << "1\n";
return 0;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
edges.push_back(make_pair(a, b));
edges.push_back(make_pair(b, a));
}
for (int i = 0; i < 2 * (n - 1); i++) number[edges[i]] = i;
memset(code, -1, sizeof(code));
memset(value, -1, sizeof(value));
memset(nodes, -1, sizeof(nodes));
for (int i = 1; i <= n; i++)
if (g[i].size() == 1) {
Queue.push(number[make_pair(g[i][0], i)]);
nodes[number[make_pair(g[i][0], i)]] = 1;
value[number[make_pair(g[i][0], i)]] = (73 * BASE + 97) % MOD;
}
while (!Queue.empty()) {
int edge = Queue.front();
Queue.pop();
if (code[edge] != -1) continue;
int node = edges[edge].first;
degree[node]++;
code[edge] = value[edge];
if (degree[node] == g[node].size() - 1) {
int dad;
vector<Son> sons;
int j = 0;
for (auto &son : g[node]) {
if (code[number[make_pair(node, son)]] == -1)
dad = son;
else
sons.push_back({code[number[make_pair(node, son)]],
nodes[number[make_pair(node, son)]], j});
j++;
}
sort(sons.begin(), sons.end());
int current = number[make_pair(dad, node)];
value[current] = 73;
nodes[current] = 1;
for (auto &son : sons) {
value[current] = (value[current] * power[2 * son.nodes]) % MOD;
value[current] = (value[current] + son.code) % MOD;
nodes[current] += son.nodes;
}
value[current] = (value[current] * BASE + 97) % MOD;
Queue.push(current);
} else if (degree[node] == g[node].size()) {
vector<Son> sons;
int j = 0;
for (auto &son : g[node]) {
sons.push_back({code[number[make_pair(node, son)]],
nodes[number[make_pair(node, son)]], j});
j++;
}
sort(sons.begin(), sons.end());
vector<long long> preffix(sons.size() + 1, 0);
preffix[0] = 73;
preffix[1] = (73 * BASE + sons[0].code) % MOD;
for (int i = 1; i <= sons.size(); i++)
preffix[i] =
(preffix[i - 1] * power[2 * sons[i - 1].nodes] + sons[i - 1].code) %
MOD;
preffix.push_back((preffix.back() * BASE + 97) % MOD);
vector<long long> suffix(sons.size() + 2, 0);
vector<int> suffixSize(sons.size() + 2, 0);
suffix.back() = 97;
for (int i = sons.size(); i > 0; i--) {
suffix[i] = (suffix[i + 1] +
sons[i - 1].code * power[2 * suffixSize[i + 1] + 1]) %
MOD;
suffixSize[i] = suffixSize[i + 1] + sons[i - 1].nodes;
}
suffix[0] = (suffix[1] + 73 * power[2 * suffixSize[1] + 1]) % MOD;
suffixSize[0] = suffixSize[1];
for (int i = 0; i < sons.size(); i++) {
int son = g[node][sons[i].index];
if (value[number[make_pair(son, node)]] == -1) {
nodes[number[make_pair(son, node)]] =
n - nodes[number[make_pair(node, son)]];
value[number[make_pair(son, node)]] =
(preffix[i] * power[2 * suffixSize[i + 2] + 1] + suffix[i + 2]) %
MOD;
Queue.push(number[make_pair(son, node)]);
}
}
}
}
for (int i = 1; i <= n; i++)
for (auto &son : g[i]) {
add[i].push_back(code[number[make_pair(i, son)]]);
subtract[i].push_back(code[number[make_pair(son, i)]]);
}
Initialize(1, 0);
DFS(1, 0);
int best = 0;
for (int i = 1; i <= n; i++)
if (answer[i] > answer[best]) best = i;
cout << best << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
int rnd[101010];
void pre() {
mt19937 mt(time(NULL));
uniform_int_distribution<int> uni(0, mod - 1);
for (int i = 0; i < 101010; i++) rnd[i] = uni(mt);
}
int modpow(int a, long long b) {
int ret = 1;
while (b > 0) {
if (b & 1) ret = 1LL * ret * a % mod;
a = 1LL * a * a % mod;
b >>= 1;
}
return ret;
}
int modinv(int a) { return modpow(a, mod - 2); }
map<int, int> hm;
int cnt = 0;
void add(int h) {
if (hm[h] == 0) cnt++;
hm[h]++;
}
void del(int h) {
assert(0 < hm[h]);
hm[h]--;
if (hm[h] == 0) cnt--;
}
int N;
vector<int> E[101010];
int D[101010];
int H[101010];
void dfs(int cur, int par) {
vector<int> hashs;
for (int to : E[cur])
if (to != par) {
dfs(to, cur);
hashs.push_back(H[to]);
D[cur] = max(D[cur], D[to] + 1);
}
int ret = 1;
for (int h : hashs) ret = (1LL * ret * ((h + rnd[D[cur]]) % mod)) % mod;
add(ret);
H[cur] = ret;
}
pair<int, int> ans;
void dfs2(int cur, int par) {
int bak = H[cur];
del(bak);
ans = max(ans, {cnt, cur});
vector<int> hei;
hei.push_back(0);
for (int to : E[cur]) hei.push_back(D[to] + 1);
sort(hei.begin(), hei.end(), greater<int>());
vector<int> hashs;
for (int to : E[cur]) hashs.push_back(H[to]);
int ha[2] = {1, 1};
for (int i = 0; i < 2; i++) {
int h = hei[i];
for (int hh : hashs) {
ha[i] = (1LL * ha[i] * ((hh + rnd[h]) % mod)) % mod;
}
}
for (int to : E[cur]) {
int idx = 0;
if (hei[0] == D[to] + 1) idx = 1;
int h = hei[idx];
int has = (1LL * ha[idx] * modinv((H[to] + rnd[h]) % mod)) % mod;
D[cur] = h;
H[cur] = has;
if (to == par) continue;
add(has);
dfs2(to, cur);
del(has);
}
add(bak);
}
int main() {
pre();
cin >> N;
for (int i = 0; i < N - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
E[a].push_back(b);
E[b].push_back(a);
}
dfs(1, 0);
dfs2(1, 0);
if (N == 1)
cout << 1 << endl;
else
cout << ans.second << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
int mul(int a, int b) { return (long long)a * b % MOD; }
const int MAXN = 1e5 + 10;
int n, power[MAXN << 1];
vector<int> g[MAXN];
void plant() {
power[0] = 1;
for (int i = 1; i <= 2 * n; i++) {
power[i] = fix(power[i - 1] + power[i - 1]);
}
}
map<int, array<int, 2>> FUCK[MAXN];
map<array<int, 2>, int> fr;
array<int, 2> join(array<int, 2> a, array<int, 2> b) {
return {a[0] + b[0], fix(a[1] + mul(power[a[0] << 1], b[1]))};
}
array<int, 2> wrap(array<int, 2> a) {
return {a[0] + 1, fix(mul(2, a[1]) + 1)};
}
void dfs_up(int u, int p) {
vector<array<int, 2>> ch;
for (int v : g[u]) {
if (v != p) {
dfs_up(v, u);
ch.push_back(FUCK[v][u]);
}
}
sort(ch.begin(), ch.end());
for (array<int, 2> a : ch) {
FUCK[u][p] = join(FUCK[u][p], a);
}
FUCK[u][p] = wrap(FUCK[u][p]);
++fr[FUCK[u][p]];
}
void dfs_down(int u, int p) {
vector<array<int, 2>> vec;
for (int v : g[u]) {
vec.push_back(FUCK[v][u]);
}
int deg = g[u].size();
vector<int> sec(deg);
iota(sec.begin(), sec.end(), 0);
sort(sec.begin(), sec.end(), [&](int i, int j) { return vec[i] < vec[j]; });
vector<array<int, 2>> pre(deg), suf(deg);
pre[0] = vec[sec[0]];
for (int i = 1; i < deg; i++) {
pre[i] = join(pre[i - 1], vec[sec[i]]);
}
suf[deg - 1] = vec[sec[deg - 1]];
for (int i = deg - 2; ~i; --i) {
suf[i] = join(vec[sec[i]], suf[i + 1]);
}
for (int i = 0; i < deg; i++) {
FUCK[u][g[u][sec[i]]] =
wrap(join(i ? pre[i - 1] : array<int, 2>(),
i + 1 < deg ? suf[i + 1] : array<int, 2>()));
}
FUCK[u][-1] = wrap(pre[deg - 1]);
for (int v : g[u]) {
if (v != p) {
dfs_down(v, u);
}
}
}
void remove(array<int, 2> a) {
if (--fr[a] == 0) {
fr.erase(a);
}
}
array<int, 2> ans;
void reroot(int u, int p) {
ans = max(ans, {(int)fr.size(), u});
for (int v : g[u]) {
if (v != p) {
remove(FUCK[u][-1]);
remove(FUCK[v][u]);
++fr[FUCK[u][v]];
++fr[FUCK[v][-1]];
reroot(v, u);
++fr[FUCK[u][-1]];
++fr[FUCK[v][u]];
remove(FUCK[u][v]);
remove(FUCK[v][-1]);
}
}
}
void solve() {
cin >> n;
if (n == 1) {
cout << 1 << endl;
return;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
plant();
dfs_up(0, -1);
dfs_down(0, -1);
reroot(0, -1);
cout << ans[1] + 1 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, cnt, dif, Max, tot, ans;
int Head[maxn], Num[maxn], f[maxn];
unsigned long long pow1[maxn], pow2[maxn], val[maxn];
unordered_map<unsigned long long, int> mp;
struct node {
int v, nxt;
} e[200005];
unsigned long long rnd() {
return (unsigned long long)(rand() + 1) * 19260817 +
(unsigned long long)(rand() + 1) * 2333 +
((unsigned long long)(rand() + 1231) << 58);
}
void addedge(int u, int v) {
e[cnt].v = v;
e[cnt].nxt = Head[u];
Head[u] = cnt++;
}
void ins(int x) {
if (!Num[x]) dif++;
Num[x]++;
}
void del(int x) {
Num[x]--;
if (!Num[x]) dif--;
}
void dfs(int x, int fa) {
unsigned long long sum = 0;
for (int i = Head[x]; i + 1; i = e[i].nxt) {
int y = e[i].v;
if (y == fa) continue;
dfs(y, x);
sum += val[f[y]];
}
f[x] = mp.count(sum) ? mp[sum] : mp[sum] = ++tot;
ins(f[x]);
}
void dfs2(int x, int fa, int c) {
del(f[x]);
if (dif + 1 > Max) {
Max = dif;
ans = x;
}
unsigned long long sum = 0;
for (int i = Head[x]; i + 1; i = e[i].nxt)
if (e[i].v != fa) sum += val[f[e[i].v]];
sum += val[c];
for (int i = Head[x]; i + 1; i = e[i].nxt) {
int y = e[i].v;
if (y == fa) continue;
unsigned long long t = sum - val[f[y]];
int tt = mp.count(t) ? mp[t] : mp[t] = ++tot;
ins(tt);
dfs2(y, x, tt);
del(tt);
}
ins(f[x]);
}
int main() {
scanf("%d", &n);
srand((unsigned)time(NULL));
for (int i = 1; i <= 2 * n; i++) val[i] = rnd();
memset(Head, -1, sizeof(Head));
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs(1, 0);
dfs2(1, 0, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
const int MOD = 1e9 + 7;
vector<int> G[MAXN];
int f[MAXN], g[MAXN], h[MAXN];
int n, sz[MAXN];
int cur, mx, ans;
map<int, int> d;
void dfs1(int u, int fa) {
sz[u] = 1;
f[u] = 0;
for (int v : G[u])
if (v != fa) {
dfs1(v, u);
sz[u] += sz[v];
f[u] = (f[u] + f[v]) % MOD;
}
f[u] = 1ll * sz[u] * (f[u] + sz[u]) % MOD;
}
void dfs2(int u, int fa) {
h[u] = g[u];
for (int v : G[u])
if (v != fa) h[u] = (h[u] + f[v]) % MOD;
for (int v : G[u])
if (v != fa) {
int c = n - sz[v];
g[v] = 1ll * c * (h[u] - f[v] + c + MOD) % MOD;
dfs2(v, u);
}
h[u] = 1ll * n * (h[u] + n) % MOD;
}
void dfs3(int u, int fa) {
if (cur > mx) mx = cur, ans = u;
int tmp = cur;
for (int v : G[u])
if (v != fa) {
if (--d[h[u]] == 0) cur--;
if (d[g[v]]++ == 0) cur++;
if (--d[f[v]] == 0) cur--;
if (d[h[v]]++ == 0) cur++;
dfs3(v, u);
++d[h[u]], --d[g[v]], ++d[f[v]], --d[h[v]];
cur = tmp;
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) reverse(G[i].begin(), G[i].end());
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++)
if (d[f[i]]++ == 0) cur++;
mx = cur, ans = 1;
dfs3(1, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long modpow(long long b, long long e, long long mod) {
long long ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
const int N = 100005;
int ans = 0, n, opt = 1;
vector<int> g[N];
long long subxor[N];
map<long long, int> hashset;
map<pair<long long, int>, long long> hashkeep;
long long first(long long x, int y) {
if (y) {
if (hashkeep.count({x, y})) return hashkeep[{x, y}];
return hashkeep[{x, y}] = rng();
}
return 0;
}
map<long long, int> childxor[N];
void reroot(int x, int y) {
hashset[subxor[x]]--;
hashset[subxor[y]]--;
if (hashset[subxor[x]] == 0) hashset.erase(subxor[x]);
if (hashset[subxor[y]] == 0) hashset.erase(subxor[y]);
subxor[y] ^= first(subxor[x], childxor[y][subxor[x]]) ^
first(subxor[x], childxor[y][subxor[x]] - 1);
childxor[y][subxor[x]]--;
subxor[x] ^= first(subxor[y], childxor[x][subxor[y]]) ^
first(subxor[y], childxor[x][subxor[y]] + 1);
childxor[x][subxor[y]]++;
hashset[subxor[x]]++;
hashset[subxor[y]]++;
}
void make(int x, int p = -1) {
for (auto w : g[x]) {
if (w == p) continue;
make(w, x);
childxor[x][subxor[w]]++;
}
for (auto w : childxor[x]) {
subxor[x] ^= first(w.first, w.second);
}
hashset[subxor[x]]++;
}
void dfs(int x, int p = -1) {
if ((int)(hashset).size() > ans) ans = (int)(hashset).size(), opt = x;
for (auto w : g[x]) {
if (w == p) continue;
reroot(w, x);
dfs(w, x);
reroot(x, w);
}
}
int32_t main() {
scanf("%d", &n);
for (int i = 0; i < (n - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
make(1);
dfs(1);
printf("%d\n", opt);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NN = 1e5 + 5, Mod = 1e9 + 7;
int Ad(int x, int y) { return ((x + y) >= Mod) ? (x + y - Mod) : (x + y); }
int Dc(int x, int y) { return ((x - y) < 0) ? (x - y + Mod) : (x - y); }
int Ml(int x, int y) { return (long long)x * y % Mod; }
int ksm(int x, int y) {
int ret = 1;
for (; y; y >>= 1, x = Ml(x, x))
if (y & 1) ret = Ml(ret, x);
return ret;
}
int N, head[NN], totE;
struct E {
int v, nxt;
E(int _v, int _nxt) : v(_v), nxt(_nxt) {}
E() : v(0), nxt(0) {}
} edge[NN << 1];
void AddE(int u, int v) {
edge[++totE] = E(v, head[u]);
head[u] = totE;
}
map<int, int> buc;
int cnt;
void Insert(int x) {
buc[x]++;
if (buc[x] == 1) ++cnt;
}
void Delete(int x) {
buc[x]--;
if (buc[x] == 0) --cnt;
}
int hsh[NN], siz[NN];
void Dfs1(int u, int fa) {
siz[u] = 1;
for (int p = head[u]; p; p = edge[p].nxt) {
int v = edge[p].v;
if (v != fa) {
Dfs1(v, u);
siz[u] += siz[v];
hsh[u] = Ad(hsh[u], hsh[v]);
}
}
hsh[u] = Ml(hsh[u], siz[u]);
hsh[u] = Ad(hsh[u], Ml(siz[u], siz[u]));
Insert(hsh[u]);
}
int ans, sl;
void Dfs2(int u, int fa) {
if (cnt > sl) {
ans = u;
sl = cnt;
}
for (int p = head[u]; p; p = edge[p].nxt) {
int v = edge[p].v;
if (v != fa) {
int tmp1 = hsh[u], tmp2 = hsh[v];
Delete(hsh[u]);
Delete(hsh[v]);
hsh[u] = Dc(hsh[u], Ml(siz[u], siz[u]));
hsh[u] = Dc(hsh[u], Ml(siz[u], hsh[v]));
hsh[u] = Ml(hsh[u], Ml(ksm(siz[u], Mod - 2), N - siz[v]));
hsh[u] = Ad(hsh[u], Ml(N - siz[v], N - siz[v]));
hsh[v] = Dc(hsh[v], Ml(siz[v], siz[v]));
hsh[v] = Ml(hsh[v], Ml(ksm(siz[v], Mod - 2), N));
hsh[v] = Ad(hsh[v], Ml(N, hsh[u]));
hsh[v] = Ad(hsh[v], Ml(N, N));
siz[u] = N - siz[v];
siz[v] = N;
int tmp3 = hsh[u], tmp4 = hsh[v];
Insert(hsh[u]);
Insert(hsh[v]);
Dfs2(v, u);
Insert(tmp1);
Insert(tmp2);
Delete(tmp3);
Delete(tmp4);
hsh[u] = tmp1;
hsh[v] = tmp2;
siz[v] = N - siz[u];
siz[u] = N;
}
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int u, v;
scanf("%d%d", &u, &v);
AddE(u, v);
AddE(v, u);
}
Dfs1(1, 0);
Dfs2(1, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, tot, ans, mx, cnt, dif;
int head[N], num[N];
unsigned long long val[N], f[N];
map<unsigned long long, int> mp;
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;
}
struct node {
int v, nex;
} e[N];
void add(int u, int v) {
e[++tot].v = v;
e[tot].nex = head[u];
head[u] = tot;
}
void ins(int x) {
if (!num[x]) ++dif;
++num[x];
}
void del(int x) {
--num[x];
if (!num[x]) --dif;
}
int get(int x) { return mp.count(x) ? mp[x] : mp[x] = ++cnt; }
void dfs1(int x, int fa) {
unsigned long long sum = 0;
for (int i = head[x]; i; i = e[i].nex) {
int v = e[i].v;
if (v == fa) continue;
dfs1(e[i].v, x);
sum += val[f[e[i].v]];
}
f[x] = get(sum);
ins(f[x]);
}
void dfs2(int x, int fa, int c) {
del(f[x]);
if (dif + 1 > mx) mx = dif + 1, ans = x;
unsigned long long sum = 0;
sum += val[c];
for (int i = head[x]; i; i = e[i].nex) {
int v = e[i].v;
if (v == fa) continue;
sum += val[f[e[i].v]];
}
for (int i = head[x]; i; i = e[i].nex) {
int v = e[i].v;
if (v == fa) continue;
unsigned long long snow = sum - val[f[v]];
ins(get(snow));
dfs2(v, x, get(snow));
del(get(snow));
}
ins(f[x]);
}
unsigned long long rnd() {
return (unsigned long long)(rand() + 1) * 2333 +
(unsigned long long)(rand() + 1) * 19260817 +
(unsigned long long)((rand() + 1231) << 28);
}
int main() {
n = read();
for (int i = 1; i <= n * 2; ++i) val[i] = rnd();
for (int i = 1; i < n; ++i) {
int xxx = read();
int yyy = read();
add(xxx, yyy);
add(yyy, xxx);
}
dfs1(1, 0);
dfs2(1, 0, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool checkMax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T, typename... Args>
inline void checkMax(T &a, const Args... arg) {
checkMax(a, max(arg...));
}
template <class T>
inline bool checkMin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename... Args>
inline void checkMin(T &a, const Args... arg) {
checkMin(a, min(arg...));
}
const int INF = 0x3f3f3f3f;
const long long llINF = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1e5 + 5;
const int MAXM = 5e6 + 5;
int n, tot, num, rt, ans;
int p[MAXM], np[MAXM], size[MAXN];
unsigned long long f[MAXN], up[MAXN], down[MAXN];
unordered_map<unsigned long long, int> cnt;
struct Graph {
static const int MAXM = MAXN << 1;
int len, head[MAXN], to[MAXM], nxt[MAXM];
Graph() { memset(head, -1, sizeof(head)); }
void add_edge(int u, int v) {
to[++len] = v;
nxt[len] = head[u];
head[u] = len;
to[++len] = u;
nxt[len] = head[v];
head[v] = len;
}
} G;
void Init(int n) {
for (int i = 2; i <= n; i++) {
if (!np[i]) p[++tot] = i;
for (int j = 1; j <= tot; j++) {
if (i * p[j] > n) break;
np[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
}
void del(unsigned long long x) {
cnt[x] -= 1;
if (!cnt[x]) num -= 1;
}
void add(unsigned long long x) {
if (!cnt[x]) num += 1;
cnt[x] += 1;
}
void dfs1(int u, int fa) {
size[u] = down[u] = 1;
for (int i = G.head[u]; i != -1; i = G.nxt[i]) {
int v = G.to[i];
if (v == fa) continue;
dfs1(v, u);
size[u] += size[v];
down[u] += down[v] * p[size[v]];
}
add(down[u]);
}
void dfs2(int u, int fa) {
up[u] = fa ? (f[fa] - down[u] * p[size[u]]) : 0;
f[u] = down[u] + (fa ? up[u] * p[n - size[u]] : 0);
if (u != 1) add(f[u]), add(up[u]);
if (num > ans) ans = num, rt = u;
del(f[u]);
for (int i = G.head[u]; i != -1; i = G.nxt[i]) {
int v = G.to[i];
if (v == fa) continue;
del(down[v]);
dfs2(v, u);
add(down[v]);
}
del(up[u]);
}
int main() {
Init(MAXM - 1);
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) scanf("%d%d", &u, &v), G.add_edge(u, v);
dfs1(1, 0);
dfs2(1, 0);
printf("%d\n", rt);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long double pi = acos(-1.0);
const string debug_line = "yolo";
const long double PI = acos((long double)-1.0);
const long double eps = 1e-6;
unsigned long long getRand() {
return ((unsigned long long)rand() << 40) +
((unsigned long long)rand() << 20) + ((unsigned long long)rand());
}
unsigned long long seed[300010];
vector<int> Adj[100010];
unsigned long long h1[200010];
unsigned long long h2[200010];
unsigned long long h11[200010];
unsigned long long h22[200010];
int father[200010];
int counter1 = 0;
unordered_map<unsigned long long, int> mp1;
unordered_map<unsigned long long, int> mp2;
void DFS(int u, int p) {
father[u] = p;
unsigned long long hash1 = seed[0];
for (auto &(t1) : (Adj[u])) {
if (t1 != p) {
DFS(t1, u);
hash1 += seed[h1[t1]];
}
}
if (mp1.find(hash1) == mp1.end()) {
mp1[hash1] = counter1++;
}
h11[u] = hash1;
h1[u] = mp1[hash1];
}
void revDFS(int u, int p) {
long long hash1 = h11[u];
if (u != 1) {
hash1 += seed[h2[u]];
}
for (auto &(t1) : (Adj[u])) {
if (t1 != p) {
hash1 = hash1 - seed[h1[t1]];
if (mp1.find(hash1) == mp1.end()) {
mp1[hash1] = counter1++;
}
h22[t1] = hash1;
h2[t1] = mp1[hash1];
revDFS(t1, u);
hash1 = hash1 + seed[h1[t1]];
}
}
}
int currAnswer = 0;
int maxAnswer = 0;
int answer1 = 1;
void calDFS(int u, int p) {
if (currAnswer > maxAnswer) {
maxAnswer = currAnswer;
answer1 = u;
}
for (auto &(t1) : (Adj[u])) {
if (t1 == p) continue;
currAnswer -= !(--mp2[h1[t1]]);
currAnswer += !(mp2[h2[t1]]++);
calDFS(t1, u);
currAnswer -= !(--mp2[h2[t1]]);
currAnswer += !(mp2[h1[t1]]);
}
}
int main() {
int n;
scanf("%d", &n);
for (int(i) = (0); (i) < (2 * n + 2); ++(i)) {
seed[i] = (getRand());
}
for (int(i) = (1); (i) < (n); ++(i)) {
int a1, b1;
scanf("%d%d", &a1, &b1);
Adj[a1].push_back(b1);
Adj[b1].push_back(a1);
}
DFS(1, 0);
revDFS(1, 0);
for (int(i) = (2); (i) < (n + 1); ++(i)) {
mp2[h1[i]]++;
}
maxAnswer = currAnswer = (int)mp2.size();
calDFS(1, 0);
printf("%d\n", answer1);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005, NH = 2;
int n, u, v, b[NH], mod[NH] = {int(1e9 + 21), int(1e9 + 9)}, r;
vector<int> adj[MX];
long long h[MX][NH];
int uni = 0, mx = 0, ind = 1;
map<long long, int> mp;
void pre() {
for (int i = 0; i < NH; i++) b[i] = abs(rand() % (mod[i] - 2)) + 2;
}
long long pot(long long b, int p, int mod) {
long long res = 1;
b %= mod;
while (p) {
if (p & 1) res = res * b % mod;
b = b * b % mod;
p /= 2;
}
return res;
}
void insert(long long g) {
if (!mp[g]) uni++;
mp[g]++;
}
void erase(long long g) {
mp[g]--;
if (!mp[g]) uni--;
}
void dfs(int u, int p) {
for (int i = 0; i < NH; i++) h[u][i] = (b[i] + int(1e9 + 7)) % mod[i];
for (int v : adj[u])
if (v != p) {
dfs(v, u);
for (int i = 0; i < NH; i++) {
h[u][i] *= b[i] + h[v][i];
h[u][i] %= mod[i];
}
}
insert(h[u][0] * mod[1] + h[u][1]);
}
void obtRes(int u, int p) {
long long t[NH], aux[NH];
for (int i = 0; i < NH; i++) aux[i] = h[u][i];
erase(aux[0] * mod[1] + aux[1]);
if (u != r) {
insert(h[p][0] * mod[1] + h[p][1]);
for (int i = 0; i < NH; i++) {
h[u][i] *= b[i] + h[p][i];
h[u][i] %= mod[i];
}
}
for (int i = 0; i < NH; i++) t[i] = h[u][i];
insert(t[0] * mod[1] + t[1]);
if (uni > mx) {
mx = uni;
ind = u;
}
erase(t[0] * mod[1] + t[1]);
for (int v : adj[u]) {
if (v == p) continue;
for (int i = 0; i < NH; i++)
h[u][i] = t[i] * pot(b[i] + h[v][i], mod[i] - 2, mod[i]) % mod[i];
obtRes(v, u);
}
if (u != r) erase(h[p][0] * mod[1] + h[p][1]);
insert(aux[0] * mod[1] + aux[1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
pre();
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
r = (rand() % n) + 1;
dfs(r, r);
obtRes(r, r);
cout << ind << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long P = 210011;
const int N = 100002;
int myRand() { return rand() ^ (rand() << 15); }
struct Node {
int x;
int y;
int l, r;
pair<unsigned long long, unsigned long long> val;
Node()
: x(),
y(),
l(-1),
r(-1),
val(make_pair((unsigned long long)0, (unsigned long long)1)) {}
Node(int _x)
: x(_x),
y(myRand()),
l(-1),
r(-1),
val(make_pair((unsigned long long)_x, P)) {}
};
Node treap[2 * N];
int treapSz = 0;
pair<unsigned long long, unsigned long long> mergeHashes(
pair<unsigned long long, unsigned long long> L,
pair<unsigned long long, unsigned long long> R) {
return make_pair(L.first * R.second + R.first, L.second * R.second);
}
pair<unsigned long long, unsigned long long> getHash(int v) {
return v == -1 ? make_pair((unsigned long long)0, (unsigned long long)1)
: treap[v].val;
}
int update(int v) {
if (v == -1) return v;
treap[v].val =
mergeHashes(mergeHashes(getHash(treap[v].l),
make_pair((unsigned long long)treap[v].x, P)),
getHash(treap[v].r));
return v;
}
int merge(int L, int R) {
if (L == -1) return R;
if (R == -1) return L;
if (treap[L].y > treap[R].y) {
treap[L].r = merge(treap[L].r, R);
return update(L);
} else {
treap[R].l = merge(L, treap[R].l);
return update(R);
}
}
void split(int v, int x, int &L, int &R) {
if (v == -1) {
L = R = -1;
return;
}
if (treap[v].x < x) {
split(treap[v].r, x, treap[v].r, R);
L = update(v);
} else {
split(treap[v].l, x, L, treap[v].l);
R = update(v);
}
}
pair<unsigned long long, unsigned long long> getHashWithout(int &v, int x) {
int L, M1, M2, M3, R;
split(v, x, L, R);
split(R, x + 1, M2, R);
if (M2 == -1) throw;
M1 = treap[M2].l, M3 = treap[M2].r;
treap[M2].l = treap[M2].r = -1;
M2 = update(M2);
v = merge(merge(L, M1), merge(M3, R));
pair<unsigned long long, unsigned long long> res = getHash(v);
split(v, x, L, R);
v = merge(L, merge(M2, R));
return res;
}
void treapInsert(int &v, int x) {
treap[treapSz++] = Node(x);
int L, R;
split(v, x, L, R);
v = merge(L, merge(treapSz - 1, R));
return;
}
int n;
int m = 1;
vector<pair<int, int> > g[N];
int deg[N];
int ed[N][2];
int a[N][2];
int q[2 * N];
int topQ;
bool usedV[N];
int sets[N];
map<unsigned long long, int> toId;
int cnt[2 * N];
int curBal = 0;
int bestVal = -1;
int ans = -1;
int getId(unsigned long long x) {
if (toId.count(x) > 0) return toId[x];
toId[x] = m;
return m++;
}
void add(int x) {
if (cnt[x] == 0) curBal++;
cnt[x]++;
}
void remove(int x) {
cnt[x]--;
if (cnt[x] == 0) curBal--;
}
void dfs1(int v, int par) {
for (pair<int, int> eid : g[v]) {
int u = ed[eid.first][1 ^ eid.second];
if (u == par) continue;
add(a[eid.first][eid.second]);
dfs1(u, v);
}
return;
}
void dfs2(int v, int par) {
if (curBal > bestVal) {
bestVal = curBal;
ans = v;
}
for (pair<int, int> eid : g[v]) {
int u = ed[eid.first][1 ^ eid.second];
if (u == par) continue;
remove(a[eid.first][eid.second]);
add(a[eid.first][1 ^ eid.second]);
dfs2(u, v);
remove(a[eid.first][1 ^ eid.second]);
add(a[eid.first][eid.second]);
}
return;
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &ed[i][0], &ed[i][1]);
ed[i][0]--;
ed[i][1]--;
deg[ed[i][0]]++;
deg[ed[i][1]]++;
g[ed[i][0]].push_back(make_pair(i, 0));
g[ed[i][1]].push_back(make_pair(i, 1));
}
for (int i = 1; i < n; i++) a[i][0] = a[i][1] = -1;
for (int i = 0; i < n; i++) sets[i] = -1;
for (int i = 0; i < n; i++)
if (deg[i] == 1) q[topQ++] = i;
for (int k = 0; k < topQ; k++) {
int v = q[k];
if (deg[v] > 1) throw;
if (deg[v] == 1) {
for (int i = 0; i < (int)g[v].size(); i++) {
pair<int, int> e = g[v][i];
if (a[e.first][e.second] == -1) {
pair<unsigned long long, unsigned long long> h = getHash(sets[v]);
unsigned long long hh = h.first + h.second;
a[e.first][1 ^ e.second] = getId(hh);
int u = ed[e.first][1 ^ e.second];
treapInsert(sets[u], a[e.first][1 ^ e.second]);
deg[u]--;
if (deg[u] <= 1) q[topQ++] = u;
}
}
continue;
}
if (usedV[v]) continue;
usedV[v] = 1;
for (int i = 0; i < (int)g[v].size(); i++) {
pair<int, int> e = g[v][i];
if (a[e.first][1 ^ e.second] == -1) {
int x = a[e.first][e.second];
if (x == -1) throw;
pair<unsigned long long, unsigned long long> h =
getHashWithout(sets[v], x);
unsigned long long hh = h.first + h.second;
a[e.first][1 ^ e.second] = getId(hh);
int u = ed[e.first][1 ^ e.second];
treapInsert(sets[u], a[e.first][1 ^ e.second]);
deg[u]--;
if (deg[u] <= 1) q[topQ++] = u;
}
}
}
dfs1(0, -1);
dfs2(0, -1);
printf("%d\n", ans + 1);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, head[200000], nxt[300000], to[300000], cnt = 1, ans;
void add(long long a, long long b) {
nxt[++cnt] = head[a];
to[cnt] = b;
head[a] = cnt;
}
unordered_map<long long, long long> mp;
long long insert(long long v) { return ans = ans + ((mp[v]++) == 0); }
long long remove(long long v) { return ans = ans - ((--mp[v]) == 0); }
long long siz[300000], dp[300000];
long long mx, pos;
void dfs(long long now, long long fa, long long from) {
siz[from] = 1;
for (long long i = head[now]; i; i = nxt[i]) {
if (to[i] == fa) continue;
dfs(to[i], now, i);
siz[from] += siz[i];
dp[from] += dp[i];
dp[from] %= 998244353;
}
dp[from] *= siz[from];
dp[from] %= 998244353;
dp[from] += siz[from] * siz[from] % 998244353;
dp[from] %= 998244353;
insert(dp[from]);
}
void df5(long long now, long long fa) {
long long sum = 0;
for (long long i = head[now]; i; i = nxt[i]) {
sum += dp[i];
sum %= 998244353;
}
for (long long i = head[now]; i; i = nxt[i]) {
if (to[i] == fa) continue;
siz[i ^ 1] = n - siz[i];
dp[i ^ 1] = (sum - dp[i] + 998244353) % 998244353;
dp[i ^ 1] *= siz[i ^ 1];
dp[i ^ 1] %= 998244353;
dp[i ^ 1] += siz[i ^ 1] * siz[i ^ 1] % 998244353;
dp[i ^ 1] %= 998244353;
df5(to[i], now);
}
}
void solve(long long now, long long fa) {
for (long long i = head[now]; i; i = nxt[i]) {
if (to[i] == fa) continue;
insert(dp[i ^ 1]);
remove(dp[i]);
if (ans > mx) {
mx = ans;
pos = to[i];
}
solve(to[i], now);
remove(dp[i ^ 1]);
insert(dp[i]);
}
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
add(a, b);
add(b, a);
}
dfs(1, 0, 0);
df5(1, 0);
mx = ans;
pos = 1;
solve(1, 0);
printf("%lld\n", pos);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, tot, ans, mx, cnt, dif;
int head[N], num[N];
unsigned long long val[N], f[N];
map<unsigned long long, int> mp;
int read() {
int ret = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) ret = ret * 10 + (c ^ 48), c = getchar();
return ret;
}
struct Tway {
int v, nex;
} e[N];
void add(int u, int v) {
e[++tot] = (Tway){v, head[u]};
head[u] = tot;
e[++tot] = (Tway){u, head[v]};
head[v] = tot;
}
void ins(int x) {
if (!num[x]) ++dif;
++num[x];
}
void del(int x) {
--num[x];
if (!num[x]) --dif;
}
int get(int x) { return mp.count(x) ? mp[x] : mp[x] = ++cnt; }
void dfs1(int x, int fa) {
unsigned long long sum = 0;
for (int i = head[x]; i; i = e[i].nex)
if (e[i].v ^ fa) dfs1(e[i].v, x), sum += val[f[e[i].v]];
f[x] = get(sum);
ins(f[x]);
}
void dfs2(int x, int fa, int c) {
del(f[x]);
if (dif + 1 > mx)
mx = dif + 1, ans = x;
else if (dif + 1 == mx && x < ans)
ans = x;
unsigned long long sum = 0;
for (int i = head[x]; i; i = e[i].nex)
if (e[i].v ^ fa) sum += val[f[e[i].v]];
sum += val[c];
for (int i = head[x]; i; i = e[i].nex) {
int v = e[i].v;
if (v == fa) continue;
unsigned long long snow = sum - val[f[v]];
ins(get(snow));
dfs2(v, x, get(snow));
del(get(snow));
}
ins(f[x]);
}
unsigned long long rnd() {
return (unsigned long long)(rand() + 1) * 2333 +
(unsigned long long)(rand() + 1) * 19260817 +
(unsigned long long)((rand() + 1231) << 28);
}
int main() {
n = read();
for (int i = 1; i <= n * 2; ++i) val[i] = rnd();
for (int i = 1; i < n; ++i) add(read(), read());
dfs1(1, 0);
dfs2(1, 0, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[100010];
int n, siz[100010], tot, ans, anss;
map<long long, int> ex;
long long hab[100010], haa[100010], cf[100010], ny[100010];
int cmp(int x, int y) { return hab[x] < hab[y]; }
void dfs1(int x, int y) {
hab[x] = 1000000007;
for (int i = 0; i < edge[x].size(); i++)
if (edge[x][i] != y) dfs1(edge[x][i], x);
sort(edge[x].begin(), edge[x].end(), cmp);
for (int i = 0; i < edge[x].size(); i++) {
hab[x] = (hab[x] + hab[edge[x][i]] * cf[siz[x]]) % 1000000007;
siz[x] += siz[edge[x][i]];
}
hab[x] = (hab[x] + cf[siz[x]] * (siz[x] + 1)) % 1000000007;
tot += (ex[hab[x]] == 0);
ex[hab[x]]++;
siz[x]++;
return;
}
void dfs2(int x, int y, long long z) {
if (z != 1000000007) {
tot += (ex[z] == 0);
ex[z]++;
}
ex[hab[x]]--;
tot -= (ex[hab[x]] == 0);
int bo = 0, now = 0;
for (int i = 0; i < edge[x].size(); i++)
if (edge[x][i] != y) {
if (!bo && z < hab[edge[x][i]]) {
bo = 1;
haa[x] = (haa[x] + z * cf[now]) % 1000000007;
now += (n - siz[x]);
}
haa[x] = (haa[x] + hab[edge[x][i]] * cf[now]) % 1000000007;
now += siz[edge[x][i]];
}
if (!bo) {
bo = 1;
haa[x] = (haa[x] + z * cf[now]) % 1000000007;
now += (n - siz[x]);
}
haa[x] = (haa[x] + n * cf[now]) % 1000000007;
now++;
tot += (ex[haa[x]] == 0);
ex[haa[x]]++;
if (tot > ans) {
ans = tot;
anss = x;
}
long long num = (haa[x] - n * cf[n - 1]) % 1000000007, tmp = 0;
now = bo = 0;
for (int i = 0; i < edge[x].size(); i++)
if (edge[x][i] != y) {
ex[haa[x]]--;
tot -= (ex[haa[x]] == 0);
if (!bo && z < hab[edge[x][i]]) {
num = (num - z * cf[now]) % 1000000007;
tmp = (tmp + z * cf[now]) % 1000000007;
now += n - siz[x];
bo = 1;
}
num = (num - hab[edge[x][i]] * cf[now]) % 1000000007;
dfs2(edge[x][i], x,
((num * ny[siz[edge[x][i]]] + tmp +
(n - siz[edge[x][i]]) * cf[n - siz[edge[x][i]] - 1]) %
1000000007 +
1000000007) %
1000000007);
tmp = (tmp + hab[edge[x][i]] * cf[now]) % 1000000007;
now += siz[edge[x][i]];
tot += (ex[haa[x]] == 0);
ex[haa[x]]++;
}
if (z != 1000000007) {
ex[z]--;
tot -= (ex[z] == 0);
}
tot += (ex[hab[x]] == 0);
ex[hab[x]]++;
ex[haa[x]]--;
tot -= (ex[haa[x]] == 0);
}
int main() {
scanf("%d", &n);
cf[0] = 1;
ny[0] = 1;
for (int i = 1; i <= n; i++) cf[i] = (cf[i - 1] * 100003) % 1000000007;
for (int i = 1; i <= n; i++) ny[i] = (ny[i - 1] * 443036712) % 1000000007;
for (int i = 1; i < n; i++) {
int o, p;
scanf("%d%d", &o, &p);
edge[o].push_back(p);
edge[p].push_back(o);
}
dfs1(1, 0);
dfs2(1, 0, 1000000007);
printf("%d\n", anss);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
set<int> in[maxn], out[maxn];
queue<int> q;
vector<pair<pair<long long, long long>, int> > v[maxn];
map<pair<long long, long long>, int> M;
const long long seed = 131;
long long mod[2] = {1000000007, 1000000009};
long long P[2][maxn];
void pre() {
for (int t = 0; t <= 1; t++) {
P[t][0] = 1;
for (int i = 1; i < maxn; i++) P[t][i] = P[t][i - 1] * seed % mod[t];
}
}
int cnt, h[maxn];
struct edge {
int to, pre;
} e[maxn << 1];
void add(int from, int to) {
cnt++;
e[cnt].pre = h[from];
e[cnt].to = to;
h[from] = cnt;
}
void show(int to, pair<pair<long long, long long>, int> h) {
int from = h.second;
pair<long long, long long> ha = h.first;
printf("%d -> %d : %I64d %I64d\n", from, to, ha.first, ha.second);
}
vector<pair<long long, long long> > rev[maxn];
pair<long long, long long> dfs1(int x, int f) {
pair<long long, long long> ret;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].second;
if (to == f) {
rev[x].push_back(pair<long long, long long>(0, 0));
ret = v[x][i].first;
continue;
}
M[v[x][i].first]++;
pair<long long, long long> tmp = dfs1(to, x);
rev[x].push_back(tmp);
}
return ret;
}
int Ma, ans;
void dfs2(int x, int f) {
if ((int)M.size() > Ma) Ma = M.size(), ans = x;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].second;
if (to == f) continue;
M[rev[x][i]]++;
M[v[x][i].first]--;
if (M[v[x][i].first] == 0) M.erase(v[x][i].first);
dfs2(to, x);
M[rev[x][i]]--;
if (M[rev[x][i]] == 0) M.erase(rev[x][i]);
M[v[x][i].first]++;
}
}
int n, siz[maxn];
map<pair<long long, long long>, int> sz;
void SZ(int x, int f) {
siz[x] = 1;
for (int i = h[x]; i; i = e[i].pre) {
int to = e[i].to;
if (to == f) continue;
SZ(to, x);
siz[x] += siz[to];
sz[pair<long long, long long>(to, x)] = siz[to];
sz[pair<long long, long long>(x, to)] = n - siz[to];
}
}
int main(void) {
pre();
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
add(u, v);
out[u].insert(v);
in[v].insert(u);
add(v, u);
out[v].insert(u);
in[u].insert(v);
}
if (n == 1) {
puts("1");
return 0;
}
SZ(1, 0);
for (int i = 1; i <= n; i++)
if (in[i].size() <= 1) q.push(i);
while (!q.empty()) {
int tmp = q.front();
q.pop();
if (!in[tmp].size()) {
if (!out[tmp].size()) continue;
sort(v[tmp].begin(), v[tmp].end());
int len = v[tmp].size();
pair<long long, long long> l = pair<long long, long long>(0, len),
r = pair<long long, long long>(0, 0);
for (int i = 1; i < len; i++) {
r.first = (r.first * seed + v[tmp][i].first.first) % mod[0];
r.second = (r.second * seed + v[tmp][i].first.second) % mod[1];
}
if (out[tmp].find(v[tmp][0].second) != out[tmp].end()) {
int to = v[tmp][0].second;
pair<pair<long long, long long>, int> nhash;
nhash.second = tmp;
nhash.first.first =
(l.first * P[0][len - 1] + r.first +
sz[pair<long long, long long>(tmp, to)] * P[0][len - 1]) %
mod[0];
nhash.first.second = (l.second * P[1][len - 1] + r.second) % mod[1];
v[to].push_back(nhash);
out[tmp].erase(to);
in[to].erase(tmp);
if (in[to].size() <= 1) q.push(to);
}
for (int i = 1; i < len; i++) {
l.first = (l.first * seed + v[tmp][i - 1].first.first) % mod[0];
l.second = (l.second * seed + v[tmp][i - 1].first.second) % mod[1];
r.first =
(r.first - v[tmp][i].first.first * P[0][len - i - 1] % mod[0] +
mod[0]) %
mod[0];
r.second =
(r.second - v[tmp][i].first.second * P[1][len - i - 1] % mod[1] +
mod[1]) %
mod[1];
int to = v[tmp][i].second;
if (out[tmp].find(to) == out[tmp].end()) continue;
pair<pair<long long, long long>, int> nhash;
nhash.second = tmp;
nhash.first.first =
(l.first * P[0][len - i - 1] + r.first +
sz[pair<long long, long long>(tmp, to)] * P[0][len - 1]) %
mod[0];
nhash.first.second = (l.second * P[1][len - i - 1] + r.second) % mod[1];
v[to].push_back(nhash);
out[tmp].erase(to);
in[to].erase(tmp);
if (in[to].size() <= 1) q.push(to);
}
} else {
int to = *in[tmp].begin();
int len = v[tmp].size();
pair<pair<long long, long long>, int> nhash =
pair<pair<long long, long long>, int>(
pair<long long, long long>(
sz[pair<long long, long long>(tmp, to)], len + 1),
tmp);
if (len) {
sort(v[tmp].begin(), v[tmp].end());
for (int i = 0; i < len; i++)
nhash.first.first =
(nhash.first.first * seed + v[tmp][i].first.first) % mod[0],
nhash.first.second =
(nhash.first.second * seed + v[tmp][i].first.second) % mod[1];
}
v[to].push_back(nhash);
out[tmp].erase(to);
in[to].erase(tmp);
if (in[to].size() <= 1) q.push(to);
}
}
M.clear();
dfs1(1, 0);
Ma = 0;
dfs2(1, 0);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const bool is_debug = true;
template <class T>
ostream &operator<<(ostream &a, vector<T> x) {
for (auto element : x) {
a << element << ' ';
}
return a;
}
template <class T>
istream &operator>>(istream &a, vector<T> x) {
for (auto &element : x) {
a >> x;
}
return a;
}
mt19937 rnd(time(0));
const long long mod = 1e9 + 1;
const long long p = 179;
long long pw[2 * 100228];
long long hashsum(long long h1, int l1, long long h2, int l2) {
return ((h1 * pw[l2]) % mod + h2) % mod;
}
struct Node {
int p, hash, len, val, selflen;
Node *l, *r;
Node() : p(rnd()), hash(0), l(nullptr), r(nullptr){};
Node(int val, int len)
: p(rnd()),
val(val),
hash(val),
selflen(len),
len(len),
l(nullptr),
r(nullptr){};
};
typedef Node *PNode;
int getlen(PNode v) {
if (!v) return 0;
return v->len;
}
int gethash(PNode v) {
if (!v) return 0;
return v->hash;
}
void update(PNode root) {
if (!root) return;
root->len = getlen(root->l) + getlen(root->r) + root->selflen;
long long hs = hashsum(gethash(root->l), 0, root->val, root->selflen);
hs = hashsum(hs, 0, gethash(root->r), getlen(root->r));
root->hash = hs;
}
void split(PNode root, PNode &l, PNode &r, int x) {
if (!root) return void(l = r = nullptr);
if (root->val < x) {
split(root->r, root->r, r, x);
l = root;
update(l);
} else {
split(root->l, l, root->l, x);
r = root;
update(r);
}
}
void merge(PNode &root, PNode l, PNode r) {
if (!l || !r) return void(root = l ? l : r);
if (l->p > r->p) {
merge(l->r, l->r, r);
root = l;
} else {
merge(r->l, l, r->l);
root = r;
}
update(root);
}
void insert(PNode &root, PNode &ins) {
PNode r1, r2;
split(root, r1, r2, ins->val);
merge(root, r1, ins);
merge(root, root, r2);
}
void erase(PNode &root, long long val) {
if (!root) return;
if (root->val == val) {
merge(root, root->l, root->r);
return;
}
if (root->val > val) {
erase(root->l, val);
} else {
erase(root->r, val);
}
update(root);
}
long long get_hash(PNode v) {
if (!v) return 181;
long long cur = hashsum(1, 1, v->hash, v->len);
cur = hashsum(cur, v->len + 1, 2, 1);
return cur;
}
vector<vector<int>> g;
vector<PNode> ch_hashes;
unordered_map<long long, int> cnt;
int curcnt = 0;
vector<long long> hashes;
void remove_hash(long long h) {
cnt[h]--;
if (cnt[h] == 0) curcnt--;
}
void add_hash(long long h) {
if (cnt[h] == 0) curcnt++;
cnt[h]++;
}
void change_order(int v, int u) {
remove_hash(hashes[u]);
remove_hash(hashes[v]);
erase(ch_hashes[v], hashes[u]);
hashes[v] = get_hash(ch_hashes[v]);
PNode ins = new Node(hashes[v], getlen(ch_hashes[v]) + 2);
insert(ch_hashes[u], ins);
hashes[u] = get_hash(ch_hashes[u]);
add_hash(hashes[u]);
add_hash(hashes[v]);
}
int ans = 0, mx = 0;
void dfs(int v, int par) {
if (curcnt > mx) {
mx = curcnt;
ans = v;
}
for (auto u : g[v]) {
if (u == par) continue;
change_order(v, u);
dfs(u, v);
change_order(u, v);
}
}
void build_hashes(int v, int par) {
if (par != -1 && g[v].size() == 1) {
ch_hashes[v] = nullptr;
hashes[v] = hashsum(1, 1, 2, 1);
add_hash(hashes[v]);
return;
}
ch_hashes[v] = nullptr;
for (auto u : g[v]) {
if (u == par) continue;
build_hashes(u, v);
PNode ins = new Node(hashes[u], getlen(ch_hashes[u]) + 2);
insert(ch_hashes[v], ins);
}
hashes[v] = get_hash(ch_hashes[v]);
add_hash(hashes[v]);
}
long long counthash(vector<long long> el) {
if (el.size() == 0) return 0;
if (el.size() == 1) return el[0];
el[0] = hashsum(el[0], 0, el[1], 1);
for (int i = 1; i < el.size() - 1; ++i) {
el[i] = el[i + 1];
}
el.pop_back();
return counthash(el);
}
signed main() {
pw[0] = 1;
for (int i = 1; i < 2 * 100228; ++i) pw[i] = (pw[i - 1] * p) % mod;
int n;
cin >> n;
g.resize(n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
hashes.resize(n);
ch_hashes.resize(n);
build_hashes(0, -1);
dfs(0, -1);
cout << ans + 1;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int V = 998244353;
struct edge {
int to, next;
} e[N * 2];
int head[N], tot, n;
long long f[N], g[N], q[N * 2];
int mp[N * 2], S, ans, ansv;
void add(int x, int y) {
e[++tot] = (edge){y, head[x]};
head[x] = tot;
}
void add(int x) {
if (!mp[x]) ++S;
++mp[x];
}
void del(int x) {
--mp[x];
if (!mp[x]) --S;
}
void dfs1(int x, int fa) {
f[x] = 114514;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
dfs1(e[i].to, x);
f[x] += f[e[i].to] * (f[e[i].to] ^ V) + 1919813;
}
}
void dfs2(int x, int fa) {
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
g[e[i].to] = (x == 1 ? 0 : g[x] * (g[x] ^ V) + 1919813) + f[x];
g[e[i].to] -= f[e[i].to] * (f[e[i].to] ^ V) + 1919813;
dfs2(e[i].to, x);
}
}
void getans(int x, int fa) {
if (S > ansv) ansv = S, ans = x;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
del(f[e[i].to]);
add(g[e[i].to]);
getans(e[i].to, x);
del(g[e[i].to]);
add(f[e[i].to]);
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n - 1); i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = (int)(2); i <= (int)(n); i++) {
q[++*q] = f[i];
q[++*q] = g[i];
}
sort(q + 1, q + *q + 1);
for (int i = (int)(2); i <= (int)(n); i++) {
f[i] = lower_bound(q + 1, q + *q + 1, f[i]) - q;
g[i] = lower_bound(q + 1, q + *q + 1, g[i]) - q;
}
for (int i = (int)(2); i <= (int)(n); i++) add(f[i]);
ansv = -1;
getans(1, 0);
printf("%d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int head[100005], hsh[100005];
int tot, n, ans, cnt, mx;
struct edge {
int to, next;
} e[100005 * 2];
map<int, int> mp;
void add(int x, int y) {
e[++tot] = (edge){y, head[x]};
head[x] = tot;
}
int calc(int x) { return 1ll * x * x % 1000000007 * x % 1000000007; }
void dfs(int x, int fa) {
hsh[x] = 19260817;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
dfs(e[i].to, x);
hsh[x] = (hsh[x] + calc(hsh[e[i].to])) % 1000000007;
}
if (x != 1) {
if (!mp[hsh[x]]) cnt++;
mp[hsh[x]]++;
}
}
void work(int x, int fa, int Hsh) {
if (!(--mp[hsh[x]])) cnt--;
if (!(mp[Hsh]++)) cnt++;
int tmp = (hsh[x] + calc(Hsh)) % 1000000007;
if (cnt > mx) mx = cnt, ans = x;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa)
work(e[i].to, x, (tmp + 1000000007 - calc(hsh[e[i].to])) % 1000000007);
if (!(mp[hsh[x]]++)) cnt++;
if (!(--mp[Hsh])) cnt--;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0);
ans = 1;
mx = cnt;
for (int i = head[1]; i; i = e[i].next)
work(e[i].to, 1, (hsh[1] + 1000000007 - calc(hsh[e[i].to])) % 1000000007);
printf("%d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long p = 1e6 + 123;
const long long z = 315;
long long pws[N], dp[N];
map<long long, int> hmp;
int cnt, a[N], n;
pair<int, int> sol;
vector<int> g[N];
void add(long long x) {
hmp[x]++;
if (hmp[x] == 1) cnt++;
}
void del(long long x) {
hmp[x]--;
if (hmp[x] == 0) cnt--;
}
long long f(long long x) {
x = (x + z) % mod;
x = x ^ (x >> 2);
return x;
}
void init(int v, int prev = -1) {
vector<long long> sons;
for (int xt : g[v]) {
if (xt == prev) continue;
init(xt, v);
sons.push_back(dp[xt]);
}
sort(sons.begin(), sons.end());
for (int i = 0; i < (int)sons.size(); i++)
dp[v] = (dp[v] * p + sons[i]) % mod;
dp[v] = f(dp[v]);
add(dp[v]);
}
void dfs(int v, int prev = -1) {
vector<pair<long long, int> > sons;
for (int xt : g[v]) sons.push_back({dp[xt], xt});
sort(sons.begin(), sons.end());
long long dpNode = dp[v];
if (prev != -1) {
del(dp[v]);
dp[v] = 0;
for (int i = 0; i < (int)sons.size(); i++)
dp[v] = (dp[v] * p + sons[i].first) % mod;
dp[v] = f(dp[v]);
add(dp[v]);
sol = max(sol, {cnt, v});
}
vector<long long> pref((int)g[v].size(), 0), suf((int)g[v].size(), 0);
for (int i = 0; i < (int)sons.size(); i++) {
if (i) pref[i] = pref[i - 1];
pref[i] = (pref[i] * p + sons[i].first) % mod;
}
for (int i = (int)sons.size() - 1; i >= 0; i--) {
if (i + 1 < (int)sons.size()) suf[i] = suf[i + 1];
suf[i] = (suf[i] + sons[i].first * pws[(int)sons.size() - 1 - i]) % mod;
}
long long initHash = dp[v];
for (int i = 0; i < (int)sons.size(); i++) {
int xt = sons[i].second;
if (xt == prev) continue;
long long hsh = 0;
int shift = (int)sons.size() - 1 - i;
if (i) hsh = (pref[i - 1] * pws[shift]) % mod;
if (i + 1 < (int)sons.size()) hsh = (hsh + suf[i + 1]) % mod;
del(dp[v]);
dp[v] = hsh;
dp[v] = f(dp[v]);
add(dp[v]);
dfs(xt, v);
del(dp[v]);
dp[v] = initHash;
add(dp[v]);
}
del(dp[v]);
dp[v] = dpNode;
add(dp[v]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
pws[0] = 1;
for (int i = 1; i <= n; i++) pws[i] = (pws[i - 1] * p) % mod;
init(1);
sol = {cnt, 1};
dfs(1);
printf("%d", sol.second);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
unsigned long long seed[maxn];
unsigned long long Rand() {
return ((unsigned long long)rand() << 48) |
((unsigned long long)rand() << 32) | (rand() << 16) | rand();
}
vector<int> G[maxn];
unsigned long long h[maxn];
map<unsigned long long, int> mp, cnt;
int tot, sum, ans;
void dfs_init(int x, int par) {
h[x] = seed[0];
for (auto v : G[x]) {
if (v == par) continue;
dfs_init(v, x);
h[x] += seed[mp[h[v]]];
}
if (mp.count(h[x]) == 0) mp[h[x]] = ++tot;
cnt[h[x]]++;
}
int idx = 1;
void dfs(int x, int par, unsigned long long H) {
if (x > 1) {
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
h[x] += seed[mp[H]];
if (mp.count(h[x]) == 0) mp[h[x]] = ++tot;
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
}
if (sum > ans) idx = x, ans = sum;
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
for (auto v : G[x]) {
if (v == par) continue;
unsigned long long t = h[x] - seed[mp[h[v]]];
cnt[t]++;
if (cnt[t] == 1) sum++;
if (!mp.count(t)) mp[t] = ++tot;
dfs(v, x, h[x] - seed[mp[h[v]]]);
cnt[t]--;
if (cnt[t] == 0) --sum;
}
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
if (x > 1) {
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
h[x] -= seed[mp[H]];
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
}
}
int main() {
srand(time(0));
for (int i = 0; i < maxn; ++i) seed[i] = Rand();
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
dfs_init(1, 1);
ans = sum = tot;
dfs(1, 1, 0);
cout << idx << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
first = first * 10 + ch - 48;
}
return first * f;
}
const int mxN = 1e5;
int n, en;
struct Edge {
int v, nxt;
} e[mxN * 2 + 3];
int fe[mxN + 3];
map<unsigned long long, unsigned long long> mp1, mp2;
int ans, mx, rt;
unsigned long long f[mxN + 3], g[mxN + 3];
int fa[mxN + 3];
unsigned long long Rand() {
return (((((1llu * rand() << 15) | rand()) << 15) | rand()) << 15) | rand();
}
unsigned long long getw(unsigned long long first) {
if (first == 0llu) {
return 0llu;
}
return mp2.count(first) ? mp2[first] : mp2[first] = Rand();
}
void ins(unsigned long long first) {
if (!mp1[first]) {
ans++;
}
mp1[first]++;
}
void del(unsigned long long first) {
mp1[first]--;
if (!mp1[first]) {
ans--;
}
}
void addedge(int u, int v) {
en++;
e[en].v = v;
e[en].nxt = fe[u];
fe[u] = en;
}
void dfs1(int u) {
f[u] = 1llu;
for (int i = fe[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa[u]) continue;
fa[v] = u;
dfs1(v);
f[u] += getw(f[v]);
}
ins(f[u]);
}
void dfs2(int u) {
del(f[u]);
ins(f[u] + getw(g[u]));
if (rt == 0 || ans > mx) {
rt = u, mx = ans;
}
del(f[u] + getw(g[u]));
for (int i = fe[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa[u]) continue;
fa[v] = u;
g[v] = getw(g[u]) + f[u] - getw(f[v]);
ins(g[v]);
dfs2(v);
del(g[v]);
}
ins(f[u]);
}
int main() {
srand(time(NULL) + 440);
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
addedge(u, v), addedge(v, u);
}
dfs1(1);
dfs2(1);
printf("%d\n", rt);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100, P = 1000000007, Q = 23333;
int i, j, k, n, m, En, ch, x, y, cnt, ma, ans;
int h[N], hs[N];
struct edge {
int s, n;
} E[N << 1];
map<int, int> Map;
void R(int &x) {
x = 0;
ch = getchar();
while (ch < '0' || '9' < ch) ch = getchar();
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
void E_add(int x, int y) {
E[++En].s = y;
E[En].n = h[x];
h[x] = En;
E[++En].s = x;
E[En].n = h[y];
h[y] = En;
}
int calc(int x) { return (long long)x * x % P * x % P; }
void dfs(int x, int F) {
hs[x] = Q;
for (int k = h[x]; k; k = E[k].n)
if (E[k].s != F) {
dfs(E[k].s, x);
hs[x] = (hs[x] + calc(hs[E[k].s])) % P;
}
if (x != 1) {
if (!Map[hs[x]]) cnt++;
Map[hs[x]]++;
}
}
void dfs(int x, int F, int Hs) {
if (Map[hs[x]] == 1) cnt--;
Map[hs[x]]--;
if (!Map[Hs]) cnt++;
Map[Hs]++;
int tmp = (hs[x] + calc(Hs)) % P;
if (cnt > ma) ma = cnt, ans = x;
for (int k = h[x]; k; k = E[k].n)
if (E[k].s != F) dfs(E[k].s, x, (tmp + P - calc(hs[E[k].s])) % P);
if (!Map[hs[x]]) cnt++;
Map[hs[x]]++;
if (Map[Hs] == 1) cnt--;
Map[Hs]--;
}
int main() {
R(n);
for (i = 1; i < n; i++) {
R(x);
R(y);
E_add(x, y);
}
dfs(1, 0);
ans = 1;
ma = cnt;
for (k = h[1]; k; k = E[k].n)
dfs(E[k].s, 1, (hs[1] + P - calc(hs[E[k].s])) % P);
printf("%d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, H = 73, P = 1e9 + 7;
vector<int> adj[N];
pair<int, int> ans;
map<int, int> mp;
int n, m, dp[N];
int power(int a, int b) {
return b ? 1LL * power(1LL * a * a % P, b / 2) * (b & 1 ? a : 1) % P : 1;
}
void add(int x, int t = 1) { m += !mp[x], m -= !(mp[x] += t); }
void dfs1(int u, int par) {
for (auto v : adj[u])
if (v ^ par) dfs1(v, u), (dp[u] += power(H, dp[v])) %= P;
add(++dp[u]);
}
void dfs2(int u, int par) {
ans = max(ans, {m, u});
for (auto v : adj[u])
if (v ^ par) {
add(dp[u], -1), add(dp[v], -1), add((dp[u] += P - power(H, dp[v])) %= P),
add((dp[v] += power(H, dp[u])) %= P), dfs2(v, u);
add(dp[v], -1), (dp[v] += P - power(H, dp[u])) %= P, add(dp[u], -1),
(dp[u] += power(H, dp[v])) %= P, add(dp[u]), add(dp[v]);
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[--u].push_back(--v), adj[v].push_back(u);
}
dfs1(0, 0), dfs2(0, 0), cout << ans.second + 1;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long Mo = 1e9 + 7;
const unsigned long long Maxn = 1e5 + 5;
inline unsigned long long R() {
char c;
unsigned long long res, sign = 1;
while ((c = getchar()) > '9' || c < '0')
if (c == '-') sign = -1;
res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res * sign;
}
unsigned long long n, m, First[Maxn], to[Maxn * 2], Next[Maxn * 2],
cnt = 1, dp[Maxn * 2], size[Maxn * 2], now, ans1, ans2;
inline void add(unsigned long long z, unsigned long long y) {
Next[++cnt] = First[z];
First[z] = cnt;
to[cnt] = y;
}
unordered_map<unsigned long long, unsigned long long> mp;
void insert(unsigned long long x) {
if (mp[x]++ == 0) ++now;
}
void Delete(unsigned long long x) {
if (--mp[x] == 0) --now;
}
unsigned long long dfs(unsigned long long pos, unsigned long long father,
unsigned long long fr) {
size[fr] = 1;
for (unsigned long long k = First[pos]; k; k = Next[k]) {
if (to[k] == father) continue;
dp[fr] = (dp[fr] + dfs(to[k], pos, k)) % Mo;
size[fr] += size[k];
}
dp[fr] = ((dp[fr]) * size[fr] + size[fr] * size[fr]) % Mo;
insert(dp[fr]);
return dp[fr];
}
void deal(unsigned long long pos, unsigned long long father) {
unsigned long long Sum = 0;
for (unsigned long long k = First[pos]; k; k = Next[k])
Sum = (Sum + dp[k]) % Mo;
for (unsigned long long k = First[pos]; k; k = Next[k]) {
size[k ^ 1] = n - size[k];
dp[k ^ 1] =
(n - size[k]) * (Sum - dp[k] + Mo) % Mo + (n - size[k]) * (n - size[k]);
dp[k ^ 1] %= Mo;
if (to[k] == father) continue;
deal(to[k], pos);
}
}
void dp1(unsigned long long pos, unsigned long long father,
unsigned long long fr) {
for (unsigned long long k = First[pos]; k; k = Next[k]) {
if (to[k] == father) continue;
Delete(dp[k]);
insert(dp[k ^ 1]);
if (now > ans1) {
ans1 = now;
ans2 = to[k];
}
dp1(to[k], pos, k);
Delete(dp[k ^ 1]);
insert(dp[k]);
}
}
signed main() {
n = R();
unsigned long long x, y;
for (unsigned long long i = 1; i < n; i++) {
x = R();
y = R();
add(x, y);
add(y, x);
}
dfs(1, 0, 0);
ans1 = now;
ans2 = 1;
deal(1, 0);
dp1(1, 0, 0);
cout << ans2;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e6 + 3;
const unsigned long long xr = 279787;
const int maxn = 1e5 + 10;
vector<int> g[maxn];
unsigned long long up[maxn], dw[maxn];
void dfs1(int u, int f) {
dw[u] = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == f) continue;
dfs1(v, u);
dw[u] += dw[v] * mod;
}
dw[u] ^= xr;
}
void dfs2(int u, int f) {
unsigned long long tmp = ((dw[u] ^ xr) + up[u] * mod);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == f) continue;
up[v] = (tmp - dw[v] * mod) ^ xr;
dfs2(v, u);
}
}
map<unsigned long long, int> mp;
int cur = 0;
void update(unsigned long long d, unsigned long long a) {
--mp[d];
if (mp[d] == 0) --cur;
++mp[a];
if (mp[a] == 1) ++cur;
}
int ans, ansid;
void dfs3(int u, int f) {
if (cur > ans) {
ans = cur;
ansid = u;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == f) continue;
update(dw[v], up[v]);
dfs3(v, u);
update(up[v], dw[v]);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = 2; i <= n; i++) ++mp[dw[i]];
cur = mp.size();
ans = -1;
dfs3(1, 0);
printf("%d\n", ansid);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& _p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& _V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& _S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& _M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const unsigned long long INF = 1000000100;
const long double EPS = 1e-9;
map<pair<unsigned long long, pair<unsigned long long, unsigned long long>>,
unsigned long long>
H;
vector<int> V[100100];
int n;
unsigned long long mH[100100];
int Odw[100100], diff;
pair<int, int> ans;
map<int, int> Ile;
unsigned long long S1[100100];
unsigned long long S2[100100];
unsigned long long S3[100100];
unsigned long long HASH(unsigned long long a, unsigned long long b,
unsigned long long c) {
return ((a ^ b) + (c * c * c) + 12344121) ^ 4372321658131;
if (H.find(make_pair(a, make_pair(b, c))) == H.end()) {
H[make_pair(a, make_pair(b, c))] = rand();
}
return H[make_pair(a, make_pair(b, c))];
}
void dfs(int a) {
Odw[a] = 1;
unsigned long long s1 = 4321478328667919ll;
unsigned long long s2 = 432781477312874ll;
unsigned long long s3 = 347582818888181ll;
for (int v : V[a]) {
if (Odw[v]) continue;
dfs(v);
s1 ^= mH[v];
s2 += mH[v] * mH[v];
s3 += mH[v] * mH[v] * mH[v];
}
mH[a] = HASH(s1, s2, s3);
S1[a] = s1;
S2[a] = s2;
S3[a] = s3;
}
int GW[100100];
void go(int a, unsigned long long gg) {
Ile[mH[a]]--;
if (Ile[mH[a]] == 0) diff--;
unsigned long long mnh =
HASH((S1[a] ^ gg), (S2[a] + gg * gg), (S3[a] + gg * gg * gg));
if (Ile[mnh] == 0) diff++;
Ile[mnh]++;
ans = max(ans, make_pair(diff, a));
if (0)
cerr << diff << " a:" << a << " "
<< "\n";
if (Ile[mnh] == 1) diff--;
Ile[mnh]--;
GW[a] = 1;
for (int v : V[a]) {
if (GW[v]) continue;
unsigned long long ns1 = (S1[a] ^ mH[v] ^ gg);
unsigned long long ns2 = (S2[a] - mH[v] * mH[v] + gg * gg);
unsigned long long ns3 = (S3[a] - mH[v] * mH[v] * mH[v] + gg * gg * gg);
int nh = HASH(ns1, ns2, ns3);
if (Ile[nh] == 0) diff++;
Ile[nh]++;
go(v, nh);
Ile[nh]--;
if (Ile[nh] == 0) diff--;
}
Ile[mH[a]]++;
if (Ile[mH[a]] == 1) diff++;
}
int main() {
srand(time(NULL));
scanf("%d", &n);
for (int(i) = (1); (i) < (n); (i)++) {
int a, b;
scanf("%d%d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
int root = 1;
dfs(root);
for (int(i) = (1); (i) <= (n); (i)++) {
Ile[mH[i]]++;
if (Ile[mH[i]] == 1) diff++;
}
go(root, 0);
cout << ans.second << endl;
;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(100001);
int dp1[100001], dp2[100001], freq[5 * 100001], distinctIsoCount;
map<long long, int> hshMap;
pair<int, int> ans;
void PreProcess(int n) { hshMap[1ll * INT_MAX] = 0; }
int GetSubtreeNo(long long subtreeHash) {
auto it = hshMap.find(subtreeHash);
if (it != hshMap.end())
return it->second;
else {
hshMap.insert(make_pair(subtreeHash, hshMap.size()));
return hshMap.size() - 1;
}
}
void DFS1(int i, int p) {
vector<int> v;
long long subtreeHash = 0;
for (auto k : adj[i]) {
if (k != p) {
DFS1(k, i);
v.push_back(dp1[k]);
}
}
if (v.size() == 0) v.push_back(0);
sort(v.begin(), v.end());
for (auto x : v) subtreeHash = (subtreeHash * 1000003 + x) % 1000000007;
dp1[i] = GetSubtreeNo(subtreeHash);
}
void DFS2(int i, int p) {
vector<pair<int, int> > v;
vector<long long> subtreeHashes;
for (auto k : adj[i]) {
if (k != p) v.push_back(make_pair(dp1[k], k));
}
v.push_back(make_pair(dp2[i], p));
sort(v.begin(), v.end());
subtreeHashes.resize(v.size());
long long prefixHash = 0;
for (int x = 0; x < v.size(); x++) {
subtreeHashes[x] = prefixHash;
prefixHash = (prefixHash * 1000003 + v[x].first) % 1000000007;
}
long long suffixHash = 0, suffixHashPower = 1;
for (int x = v.size() - 1; x > -1; x--) {
subtreeHashes[x] =
(subtreeHashes[x] * suffixHashPower + suffixHash) % 1000000007;
suffixHash = (v[x].first * suffixHashPower + suffixHash) % 1000000007;
suffixHashPower = (1000003 * suffixHashPower) % 1000000007;
if (v[x].second != p) {
dp2[v[x].second] = GetSubtreeNo(subtreeHashes[x]);
DFS2(v[x].second, i);
}
}
}
void IncrementSubtreeFreq(int subtreeNo) {
freq[subtreeNo]++;
distinctIsoCount += (freq[subtreeNo] == 1);
}
void DecrementSubtreeFreq(int subtreeNo) {
freq[subtreeNo]--;
distinctIsoCount -= (freq[subtreeNo] == 0);
}
void DFS(int i, int p) {
DecrementSubtreeFreq(dp1[i]);
for (auto k : adj[i]) {
if (k != p) {
IncrementSubtreeFreq(dp2[k]);
DFS(k, i);
DecrementSubtreeFreq(dp2[k]);
}
}
ans = max(ans, make_pair(distinctIsoCount, i));
IncrementSubtreeFreq(dp1[i]);
}
int main() {
int n, root;
scanf("%d", &n);
for (int k = 1; k < n; k++) {
int i, j;
scanf("%d%d", &i, &j);
adj[i].push_back(j);
adj[j].push_back(i);
}
for (root = 1; root <= n && adj[root].size() > 1; root++)
;
PreProcess(n);
DFS1(root, 0);
DFS2(root, 0);
for (int i = 1; i <= n; i++) IncrementSubtreeFreq(dp1[i]);
DFS(root, 0);
printf("%d\n", ans.second);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > tree;
vector<vector<long long> > frw_hash;
vector<vector<long long> > rev_hash;
vector<int> num;
const long long p = 179;
const long long mod = 1791791791l;
const int maxn = 1e6 + 179;
void get_all(int v, int par, unordered_map<long long, int>& ums) {
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]++;
get_all(u, v, ums);
}
i++;
}
}
void dfs(int v, int par, unordered_map<long long, int>& ums) {
num[v] = ums.size();
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]--;
if (ums[frw_hash[v][i]] == 0) ums.erase(frw_hash[v][i]);
ums[rev_hash[v][i]]++;
dfs(u, v, ums);
ums[rev_hash[v][i]]--;
if (ums[rev_hash[v][i]] == 0) ums.erase(rev_hash[v][i]);
ums[frw_hash[v][i]]++;
}
i++;
}
}
int main() {
long long ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) ppows[i] = (ppows[i - 1] * p) % mod;
int n;
cin >> n;
tree.resize(n);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
tree[u].push_back(v);
tree[v].push_back(u);
edges.push_back(make_pair(u, v));
edges.push_back(make_pair(v, u));
}
map<pair<int, int>, int> index;
for (int i = 0; i < 2 * n - 2; ++i) index[edges[i]] = i;
vector<long long> rem_hh(edges.size(), -1);
vector<int> sz_of(edges.size(), -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (tree[i].size() == 1) {
rem_hh[index[make_pair(tree[i][0], i)]] = ('(' * p + ')') % mod;
sz_of[index[make_pair(tree[i][0], i)]] = 1;
q.push(index[make_pair(tree[i][0], i)]);
}
}
vector<long long> hash_of(edges.size(), -1);
vector<int> out(n, 0);
while (!q.empty()) {
int a = q.front();
q.pop();
if (hash_of[a] != -1) continue;
hash_of[a] = rem_hh[a];
int v = edges[a].first;
out[v]++;
if (out[v] == tree[v].size() - 1) {
int u = -1;
vector<long long> known_outer_hashes;
vector<int> known_subtree_sizes;
for (int w : tree[v]) {
if (hash_of[index[make_pair(v, w)]] == -1)
u = w;
else {
known_outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
known_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
}
vector<int> ind(known_outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return known_outer_hashes[i] < known_outer_hashes[j];
});
vector<int> szs;
vector<long long> next_hh;
for (int i = 0; i < known_outer_hashes.size(); ++i) {
next_hh.push_back(known_outer_hashes[ind[i]]);
szs.push_back(known_subtree_sizes[ind[i]]);
}
int i = index[make_pair(u, v)];
rem_hh[i] = '(';
sz_of[i] = 1;
for (int j = 0; j < next_hh.size(); ++j) {
rem_hh[i] = (rem_hh[i] * ppows[2 * szs[j]]) % mod;
rem_hh[i] = (rem_hh[i] + next_hh[j]) % mod;
sz_of[i] += szs[j];
}
rem_hh[i] = (rem_hh[i] * p + ')') % mod;
q.push(i);
continue;
}
if (out[v] != tree[v].size()) continue;
vector<long long> outer_hashes;
vector<int> outer_subtree_sizes;
for (int w : tree[v]) {
outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
outer_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
vector<int> ind(outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return outer_hashes[i] < outer_hashes[j];
});
vector<long long> next_hh;
vector<int> szs, rev(outer_hashes.size());
for (int i = 0; i < outer_hashes.size(); ++i) {
rev[ind[i]] = i;
next_hh.push_back(outer_hashes[ind[i]]);
szs.push_back(outer_subtree_sizes[ind[i]]);
}
vector<long long> pref_hh(next_hh.size() + 1, 0);
pref_hh[0] = '(';
for (int i = 1; i < next_hh.size() + 1; ++i) {
pref_hh[i] =
(pref_hh[i - 1] * ppows[2 * szs[i - 1]] + next_hh[i - 1]) % mod;
}
pref_hh.push_back((pref_hh.back() * p + ')') % mod);
vector<long long> suf_hh(next_hh.size() + 2, 0);
vector<int> suf_sz(next_hh.size() + 2, 0);
suf_hh.back() = ')';
for (int i = next_hh.size(); i > 0; i--) {
suf_hh[i] =
(suf_hh[i + 1] + next_hh[i - 1] * ppows[2 * suf_sz[i + 1] + 1]) % mod;
suf_sz[i] = suf_sz[i + 1] + szs[i - 1];
}
suf_hh[0] = (suf_hh[1] + '(' * ppows[2 * suf_sz[1] + 1]) % mod;
suf_sz[0] = suf_sz[1];
for (int i = 0; i < next_hh.size(); ++i) {
int u = tree[v][ind[i]];
if (rem_hh[index[make_pair(u, v)]] == -1) {
sz_of[index[make_pair(u, v)]] = n - sz_of[index[make_pair(v, u)]];
rem_hh[index[make_pair(u, v)]] =
(pref_hh[i] * ppows[2 * suf_sz[i + 2] + 1] + suf_hh[i + 2]) % mod;
q.push(index[make_pair(u, v)]);
}
}
}
frw_hash.resize(n);
rev_hash.resize(n);
num.resize(n);
for (int i = 0; i < n; ++i) {
for (int v : tree[i]) {
frw_hash[i].push_back(hash_of[index[make_pair(i, v)]]);
rev_hash[i].push_back(hash_of[index[make_pair(v, i)]]);
}
}
unordered_map<long long, int> ump;
get_all(0, -1, ump);
dfs(0, -1, ump);
cout << distance(num.begin(), max_element(num.begin(), num.end())) + 1
<< endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const long long MOD = 998244353, BAS = 1231231, TAG = 445337;
int N, head[100001], next[199999], to[199999], E;
long long f[100001], g[100001], powBAS[100001];
int q[100001], ue[100001], fa[100001], size[100001];
void BFS() {
int H = 0, T = 1, u;
q[1] = 1;
while (H < T)
for (int e = head[u = q[++H]]; e; e = next[e])
if (to[e] != fa[u]) fa[q[++T] = to[e]] = u;
static long long list_of_f[100001];
for (int i = N; i; i--) {
int u = q[i], L = 0;
size[u] = 1;
for (int e = head[u]; e; e = next[e])
if (to[e] != fa[u]) {
size[u] += size[to[e]];
list_of_f[++L] = (f[to[e]] * TAG + 1) % MOD;
}
std::sort(list_of_f + 1, list_of_f + L + 1);
f[u] = 0;
for (int j = 1; j <= L; j++) f[u] = (f[u] * BAS + list_of_f[j]) % MOD;
f[u] = (f[u] + TAG) % MOD;
}
for (int i = 1; i <= N; i++) {
int u = q[i], L = 0;
if (u != 1) list_of_f[++L] = (g[u] * TAG + 1) % MOD;
for (int e = head[u]; e; e = next[e])
if (to[e] != fa[u]) list_of_f[++L] = (f[to[e]] * TAG + 1) % MOD;
std::sort(list_of_f + 1, list_of_f + L + 1);
static long long prefix[100001];
prefix[0] = 0;
for (int i = 1; i <= L; i++)
prefix[i] = (prefix[i - 1] * BAS + list_of_f[i]) % MOD;
for (int e = head[u]; e; e = next[e])
if (to[e] != fa[u]) {
int found = std::lower_bound(list_of_f + 1, list_of_f + L + 1,
(f[to[e]] * TAG + 1) % MOD) -
list_of_f;
g[to[e]] =
(prefix[L] +
(prefix[found - 1] - prefix[found] + MOD) * powBAS[L - found] +
TAG) %
MOD;
}
}
}
std::map<long long, int> map;
int diff[100001], ans;
void add(long long x) {
if (!map[x]++) ans++;
}
void del(long long x) {
if (!--map[x]) ans--;
}
void DFS() {
for (int i = 2; i <= N; i++) add(f[i]);
diff[1] = ans;
int D = 1;
q[1] = 1;
ue[1] = head[1];
while (D) {
if (ue[D] && to[ue[D]] == fa[q[D]]) ue[D] = next[ue[D]];
if (ue[D]) {
int To = to[ue[D]];
ue[D] = next[ue[D]];
del(f[To]);
add(g[To]);
diff[To] = ans;
q[++D] = To;
ue[D] = head[To];
} else {
add(f[q[D]]);
del(g[q[D]]);
D--;
}
}
}
int main() {
scanf("%d", &N);
powBAS[0] = 1;
for (int i = 1; i <= N; i++) powBAS[i] = powBAS[i - 1] * BAS % MOD;
for (int i = 1, u, v; i < N; i++) {
scanf("%d%d", &u, &v);
next[++E] = head[u], to[E] = v, head[u] = E;
next[++E] = head[v], to[E] = u, head[v] = E;
}
BFS();
DFS();
printf("%ld\n", std::max_element(diff + 1, diff + N + 1) - diff);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
const int N = 1e5 + 100;
using u64 = unsigned long long;
int n, tot, ans, cur, rem;
vector<int> g[N];
u64 seed[N + N], h1[N], h2[N], up[N];
int r1[N], r2[N], cnt[N + N];
map<u64, int> M;
void dfs1(int u = 1, int f = 0) {
h1[u] = seed[0];
for (int v : g[u])
if (v != f) {
dfs1(v, u);
h1[u] += seed[r1[v]];
}
if (M.find(h1[u]) == M.end()) M[h1[u]] = (++tot);
r1[u] = M[h1[u]];
return;
}
void dfs2(int u = 1, int f = 0) {
if (f) h2[u] = seed[r2[u]];
h2[u] += h1[u];
for (int v : g[u])
if (v != f) {
up[v] = h2[u] - seed[r1[v]];
if (M.find(up[v]) == M.end()) M[up[v]] = (++tot);
r2[v] = M[up[v]];
dfs2(v, u);
}
return;
}
void dfs(int u = 1, int f = 0) {
cnt[r1[u]]--;
if (!cnt[r1[u]]) cur--;
if (!cnt[r2[u]]) cur++;
cnt[r2[u]]++;
if (cur > ans) ans = cur, rem = u;
for (int v : g[u])
if (v != f) dfs(v, u);
if (!cnt[r1[u]]) cur++;
cnt[r1[u]]++;
cnt[r2[u]]--;
if (!cnt[r2[u]]) cur--;
return;
}
int main() {
scf(n);
for (int i = 0; i < (n + n + 10); i++)
seed[i] = ((u64)rand() << 40) | ((u64)rand() << 20) | (u64)rand();
for (int i = 0; i < (n - 1); i++) {
int u, v;
scf(u, v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1();
dfs2();
for (int i = (1); i <= (n); i++) {
if (!cnt[r1[i]]) cur++;
cnt[r1[i]]++;
}
dfs();
printf("%d\n", rem);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
class InputReader {
public:
InputReader() {
input_file = stdin;
cursor = 0;
fread(buffer, SIZE, 1, input_file);
}
inline InputReader &operator>>(int &n) {
while (buffer[cursor] < '0' || buffer[cursor] > '9') {
advance();
}
n = 0;
while ('0' <= buffer[cursor] && buffer[cursor] <= '9') {
n = n * 10 + buffer[cursor] - '0';
advance();
}
return *this;
}
private:
FILE *input_file;
static const int SIZE = 1 << 17;
int cursor;
char buffer[SIZE];
inline void advance() {
++cursor;
if (cursor == SIZE) {
cursor = 0;
fread(buffer, SIZE, 1, input_file);
}
}
};
const int NMAX = 200000 + 5;
int N;
int sz[NMAX];
vector<int> graph[NMAX];
const int MOD1 = 1000000000 + 7;
const int MOD2 = 1000000000 + 9;
const int C1 = 63;
const int C2 = 67;
int powC1[2 * NMAX];
int powC2[2 * NMAX];
pair<int, int> hs[NMAX];
bool cmp(const int &a, const int &b) { return hs[a] < hs[b]; }
int ans;
int nodeAns;
int current;
map<pair<int, int>, int> Map;
inline void addToMap(int node) {
Map[hs[node]]++;
if (Map[hs[node]] == 1) current++;
}
inline void removeFromMap(int node) {
Map[hs[node]]--;
if (Map[hs[node]] == 0) current--;
}
void computeDp(int node, int father) {
hs[node] = {0, 0};
sort(graph[node].begin(), graph[node].end(), cmp);
for (auto it : graph[node])
if (it != father) {
hs[node].first =
(1LL * powC1[2 * sz[it]] * hs[node].first + hs[it].first) % MOD1;
hs[node].second =
(1LL * powC2[2 * sz[it]] * hs[node].second + hs[it].second) % MOD2;
}
hs[node].first = (1LL * hs[node].first * C1 + 1) % MOD1;
hs[node].second = (1LL * hs[node].second * C2 + 1) % MOD2;
}
void dfsInit(int node, int father) {
sz[node] = 1;
for (auto it : graph[node])
if (it != father) {
dfsInit(it, node);
sz[node] += sz[it];
}
computeDp(node, father);
addToMap(node);
}
void dfsMove(int node, int father) {
if (current > ans) {
ans = current;
nodeAns = node;
}
vector<pair<int, int> > hPref(graph[node].size() + 2);
hPref[0] = {0, 0};
for (int i = 0; i < graph[node].size(); ++i) {
hPref[i + 1].first = (1LL * powC1[2 * sz[graph[node][i]]] * hPref[i].first +
hs[graph[node][i]].first) %
MOD1;
hPref[i + 1].second =
(1LL * powC2[2 * sz[graph[node][i]]] * hPref[i].second +
hs[graph[node][i]].second) %
MOD2;
}
pair<int, int> hSuf = {0, 0};
int szSuf = 0;
for (int i = graph[node].size() - 1; i >= 0; --i) {
if (graph[node][i] != father) {
int oldSzNode = sz[node];
int oldSzIt = sz[graph[node][i]];
sz[node] -= sz[graph[node][i]];
sz[graph[node][i]] = oldSzNode;
pair<int, int> oldHsIt = hs[graph[node][i]];
pair<int, int> oldHsNode = hs[node];
removeFromMap(node);
removeFromMap(graph[node][i]);
hs[node].first =
(1LL * hPref[i].first * powC1[szSuf] + hSuf.first) % MOD1;
hs[node].second =
(1LL * hPref[i].second * powC2[szSuf] + hSuf.second) % MOD2;
hs[node].first = (1LL * hs[node].first * C1 + 1) % MOD1;
hs[node].second = (1LL * hs[node].second * C2 + 1) % MOD2;
computeDp(graph[node][i], 0);
addToMap(node);
addToMap(graph[node][i]);
dfsMove(graph[node][i], node);
removeFromMap(node);
removeFromMap(graph[node][i]);
hs[node] = oldHsNode;
hs[graph[node][i]] = oldHsIt;
addToMap(node);
addToMap(graph[node][i]);
sz[node] = oldSzNode;
sz[graph[node][i]] = oldSzIt;
}
hSuf.first =
(1LL * powC1[szSuf] * hSuf.first + hs[graph[node][i]].first) % MOD1;
hSuf.second =
(1LL * powC2[szSuf] * hSuf.second + hs[graph[node][i]].second) % MOD2;
szSuf += 2 * sz[graph[node][i]];
}
}
int main() {
InputReader cin;
cin >> N;
powC1[0] = powC2[0] = 1;
for (int i = 1; i <= 2 * N; ++i) {
powC1[i] = (1LL * C1 * powC1[i - 1]) % MOD1;
powC2[i] = (1LL * C2 * powC2[i - 1]) % MOD2;
}
for (int i = 1; i < N; ++i) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
dfsInit(1, 0);
ans = current;
nodeAns = 1;
dfsMove(1, 0);
cout << nodeAns << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
int n;
const __int128 mod = 1000000000999999999ll, EX = 0x4b4d4325;
__int128 qpow(__int128 x, __int128 k) {
__int128 r = 1;
for (; k; k >>= 1, x = x * x % mod)
if (k & 1) r = r * x % mod;
return r;
}
__int128 f[1111111], S[1111111], M[1111111];
std::vector<int> v[1111111];
std::map<__int128, int> Mt;
int cnt, ans, anp = 1;
int d[1111111];
void ins(__int128 x) {
int& t = Mt[x];
if (!t) cnt++;
t++;
}
void dec(__int128 x) {
int& t = Mt[x];
if (t == 1) cnt--;
t--;
}
void dfs(int p = 1, int fr = 0) {
S[p] = 1, M[p] = d[p];
for (int t : v[p])
if (t ^ fr) dfs(t, p), S[p] += f[t], (M[p] *= f[t]) %= mod;
f[p] = (S[p] % mod * M[p] + EX) % mod;
}
void solve(int p = 1, int fr = 0, __int128 fv = 0) {
if (cnt > ans) ans = cnt, anp = p;
for (int t : v[p])
if (t ^ fr) {
__int128 F =
(S[p] - f[t] + fv) % mod * qpow(f[t], mod - 2) % mod * M[p] % mod;
if (fv) F = F * fv % mod;
(F += EX) %= mod;
dec(f[t]), ins(F), solve(t, p, F), dec(F), ins(f[t]);
}
}
int main() {
scanf("%d", &n);
register int i;
for (i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y), v[x].push_back(y), v[y].push_back(x), d[x]++, d[y]++;
}
dfs();
for (i = 2; i <= n; i++) ins(f[i]);
solve(), printf("%d\n", anp);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct _cert {
template <typename T>
_cert& operator<<(T) {
return *this;
}
};
_cert _cer;
template <typename T>
void dprint(T begin, T end) {
for (auto i = begin; i != end; i++) {
_cer << (*i) << " ";
}
_cer << "\n";
}
int cc = 1;
int cnt;
int bstcnt;
int bst;
const int MAXN = 120000;
const unsigned long long P = 1000000007;
map<unsigned long long, int> mm;
map<int, int> mc;
vector<int> eds[MAXN];
int hs[MAXN];
vector<int> hss[MAXN];
int gl[MAXN];
int was[MAXN];
unsigned long long pw[MAXN];
int get(unsigned long long x) {
if (mm.count(x))
return mm[x];
else
return mm[x] = cc++;
}
void add(int x) {
++mc[x];
if (mc[x] == 1) ++cnt;
}
void del(int x) {
--mc[x];
if (mc[x] == 0) --cnt;
}
void dfs1(int v) {
was[v] = 1;
vector<int> vv;
for (int u : eds[v]) {
if (!was[u]) dfs1(u), vv.push_back(hs[u]);
}
sort(vv.begin(), vv.end());
unsigned long long now = 0;
for (int i = 0; i < vv.size(); ++i) now = now * P + vv[i];
hs[v] = get(now);
}
void dfs2(int v, int up) {
was[v] = 1;
vector<pair<int, int> > vv;
if (up != -1) vv.push_back(make_pair(up, -1));
for (int i = 0; i < eds[v].size(); ++i) {
int u = eds[v][i];
if (!was[u]) vv.push_back(make_pair(hs[u], i));
}
sort(vv.begin(), vv.end());
unsigned long long now = 0;
for (int i = 0; i < vv.size(); ++i) now = now * P + vv[i].first;
gl[v] = get(now);
unsigned long long now2 = 0;
hss[v].resize(eds[v].size(), -1);
for (int i = 0; i < vv.size(); ++i) {
now = now - pw[vv.size() - i - 1] * vv[i].first;
if (vv[i].second != -1) {
hss[v][vv[i].second] = get(now2 + now);
dfs2(eds[v][vv[i].second], hss[v][vv[i].second]);
}
if (i != vv.size() - 1) now2 = now2 + pw[vv.size() - i - 2] * vv[i].first;
}
}
void dfs3(int v) {
if (cnt > bstcnt) bstcnt = cnt, bst = v;
was[v] = 1;
for (int i = 0; i < eds[v].size(); ++i) {
int u = eds[v][i];
if (!was[u]) {
del(gl[v]);
add(gl[u]);
del(hs[u]);
add(hss[v][i]);
dfs3(u);
add(gl[v]);
del(gl[u]);
add(hs[u]);
del(hss[v][i]);
}
}
}
int n;
int main() {
pw[0] = 1;
for (int i = 1; i < MAXN; ++i) pw[i] = (pw[i - 1] * P);
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
eds[a].push_back(b);
eds[b].push_back(a);
}
dfs1(0);
memset(was, 0, sizeof(was));
dfs2(0, -1);
memset(was, 0, sizeof(was));
bst = 0;
for (int i = 0; i < n; ++i) add(hs[i]);
bstcnt = cnt;
dfs3(0);
cout << bst + 1 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> d;
int s[200010];
long long num[200010];
int f[100010];
vector<int> ne[100010];
int cnt, n, anss, rt, ans;
int add(long long k) {
if (!d[k]) d[k] = ++cnt;
return d[k];
}
void ins(int k) {
if (!s[k]) ans++;
s[k]++;
}
void del(int k) {
s[k]--;
if (!s[k]) ans--;
}
void dfs(int u, int fa) {
long long sum = 0;
for (int v : ne[u]) {
if (v == fa) continue;
dfs(v, u);
sum += num[f[v]];
}
f[u] = add(sum);
ins(f[u]);
}
void calc(int u, int fa, int k) {
del(f[u]);
if (ans + 1 > anss) anss = ans + 1, rt = u;
long long sum = num[k];
for (int v : ne[u])
if (v != fa) sum += num[f[v]];
for (int v : ne[u]) {
if (v == fa) continue;
int t = add(sum - num[f[v]]);
ins(t);
calc(v, u, t);
del(t);
}
ins(f[u]);
}
int main() {
scanf("%d", &n);
mt19937 rnd(20031219);
uniform_int_distribution<long long> dist(1, (1ll << 40) - 1);
for (int i = 1; i <= n + n; i++) num[i] = dist(rnd);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ne[x].push_back(y), ne[y].push_back(x);
}
dfs(1, -1);
calc(1, -1, 0);
printf("%d\n", rt);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long base1 = 403007, base2 = 403963, p1 = 1e9 + 7, p2 = 1e9 + 9,
po1[400005], po2[400005];
int n;
vector<int> adj[100005];
map<pair<int, int>, int> mp;
int ty[100005], cnt = 0;
pair<int, int> hsh[100005];
void dfs(int x, int p) {
long long hsh1 = 0, hsh2 = 0;
for (auto nxt : adj[x]) {
if (nxt == p) continue;
dfs(nxt, x);
hsh1 += po1[ty[nxt]];
hsh1 %= p1;
hsh2 += po2[ty[nxt]];
hsh2 %= p2;
}
if (!mp.count({hsh1, hsh2})) mp[{hsh1, hsh2}] = cnt++;
ty[x] = mp[{hsh1, hsh2}];
hsh[x] = {hsh1, hsh2};
}
int id = 1, mx = 0, now, num[400005];
void dfs1(int x, int p) {
if (p) {
long long hsh1 = hsh[p].first, hsh2 = hsh[p].second;
hsh1 = (hsh1 - po1[ty[x]] + p1) % p1;
hsh2 = (hsh2 - po2[ty[x]] + p2) % p2;
if (num[ty[p]] == 1) --now;
--num[ty[p]];
hsh[p] = {hsh1, hsh2};
if (!mp.count(hsh[p])) mp[hsh[p]] = cnt++;
ty[p] = mp[hsh[p]];
++num[ty[p]];
if (num[ty[p]] == 1) ++now;
hsh1 = hsh[x].first, hsh2 = hsh[x].second;
hsh1 = (hsh1 + po1[ty[p]]) % p1;
hsh2 = (hsh2 + po2[ty[p]]) % p2;
if (num[ty[x]] == 1) --now;
--num[ty[x]];
hsh[x] = {hsh1, hsh2};
if (!mp.count(hsh[x])) mp[hsh[x]] = cnt++;
ty[x] = mp[hsh[x]];
++num[ty[x]];
if (num[ty[x]] == 1) ++now;
}
if (mx < now) {
mx = now;
id = x;
}
for (auto nxt : adj[x]) {
if (nxt != p) dfs1(nxt, x);
}
long long hsh1 = hsh[x].first, hsh2 = hsh[x].second;
hsh1 = (hsh1 - po1[ty[p]] + p1) % p1;
hsh2 = (hsh2 - po2[ty[p]] + p2) % p2;
if (num[ty[x]] == 1) --now;
--num[ty[x]];
hsh[x] = {hsh1, hsh2};
ty[x] = mp[hsh[x]];
++num[ty[x]];
if (num[ty[x]] == 1) ++now;
hsh1 = hsh[p].first, hsh2 = hsh[p].second;
hsh1 = (hsh1 + po1[ty[x]]) % p1;
hsh2 = (hsh2 + po2[ty[x]]) % p2;
if (num[ty[p]] == 1) --now;
--num[ty[p]];
hsh[p] = {hsh1, hsh2};
ty[p] = mp[hsh[p]];
++num[ty[p]];
if (num[ty[p]] == 1) ++now;
}
int main() {
po1[0] = po2[0] = 1;
for (int i = 1; i < 400005; ++i) {
po1[i] = (po1[i - 1] * base1) % p1;
po2[i] = (po2[i - 1] * base2) % p2;
}
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= n; ++i) ++num[ty[i]];
for (int i = 0; i < cnt; ++i)
if (num[i] >= 1) ++mx;
now = mx;
dfs1(1, 0);
cout << id << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int ct = 0, n;
vector<int> G[N];
int fa[N];
int a[N];
map<int, int> son[N], sump;
map<map<int, int>, int> mp;
void input() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
}
int dfs1(int u) {
map<int, int> st;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v != fa[u]) {
fa[v] = u;
st[dfs1(v)]++;
}
}
if (!mp.count(st)) mp[st] = ++ct;
son[u] = st;
sump[mp[st]]++;
return a[u] = mp[st];
}
int mx, ans;
void dfs2(int u) {
map<int, int> st;
if (fa[u]) {
st = son[fa[u]];
st[a[u]]--;
if (st[a[u]] == 0) st.erase(a[u]);
if (!mp.count(st)) mp[st] = ++ct;
sump[mp[st]]++;
sump[a[u]]--;
if (sump[a[u]] == 0) sump.erase(a[u]);
if ((int)sump.size() > mx) mx = sump.size(), ans = u;
son[u][mp[st]]++;
}
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v != fa[u]) dfs2(v);
}
if (fa[u]) {
sump[mp[st]]--;
if (sump[mp[st]] == 0) sump.erase(mp[st]);
sump[a[u]]++;
}
}
int main() {
input();
dfs1(1);
mx = sump.size(), ans = 1;
dfs2(1);
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve(bool);
void precalc();
clock_t start;
int testNumber = 1;
bool todo = true;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve(true);
++testNumber;
}
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
void precalc() {}
const long long C = 100500;
long long pr[2] = {234211, 23423541};
long long mods[2] = {1000000007, 1000000009};
long long powers[2][C];
class Treap {
public:
typedef struct _node {
long long key;
long long cnt;
long long prior;
long long val[2];
_node* l;
_node* r;
_node(long long key) : key(key), l(nullptr), r(nullptr), cnt(1) {
prior = (rand() << 16) | rand();
val[0] = (key + 1);
val[1] = (key + 1);
}
void push() {}
void recalc() {
cnt = 1 + Cnt(l) + Cnt(r);
for (long long w = 0; w < 2; ++w) {
val[w] = powers[w][Cnt(r)] * (key + 1) % mods[w];
if (l) {
val[w] += powers[w][Cnt(r) + 1] * l->val[w];
}
if (r) {
val[w] += r->val[w];
}
val[w] %= mods[w];
}
}
long long get_hash() { return (val[0] * 1LL << 32) | val[1]; }
static long long Cnt(_node* v) {
if (!v) return 0;
return v->cnt;
}
} * node;
static long long Cnt(node v) {
if (!v) return 0;
return v->cnt;
}
node root;
size_t Size;
node merge(node l, node r) {
if (!l) return r;
if (!r) return l;
if (l->prior < r->prior) {
l->push();
l->r = merge(l->r, r);
l->recalc();
return l;
} else {
r->push();
r->l = merge(l, r->l);
r->recalc();
return r;
}
}
void split(node v, long long key, node& l, node& r) {
l = r = nullptr;
if (!v) return;
v->push();
if (v->key < key) {
l = v;
split(l->r, key, l->r, r);
l->recalc();
} else {
r = v;
split(r->l, key, l, r->l);
r->recalc();
}
}
void splitCnt(node v, long long key, node& l, node& r) {
l = r = nullptr;
if (!v) return;
v->push();
long long lef = Cnt(v->l) + 1;
if (key >= lef) {
l = v;
splitCnt(l->r, key - lef, l->r, r);
l->recalc();
} else {
r = v;
splitCnt(r->l, key, l, r->l);
r->recalc();
}
}
public:
Treap() {
root = nullptr;
Size = 0;
}
size_t size() const { return Size; }
void insert(long long key) {
node l = nullptr, r = nullptr;
split(root, key, l, r);
++Size;
root = merge(merge(l, new _node(key)), r);
}
void erase(long long key) {
node l, m, r;
split(root, key, l, m);
splitCnt(m, 1, m, r);
root = merge(l, r);
--Size;
}
long long get_hash() {
if (!root) {
return 0;
}
return root->get_hash() ^ ((long long)Size * (1LL << 32)) ^ (long long)Size;
}
};
vector<vector<long long>> g;
long long best_ans = 0;
long long best_v = -1;
map<long long, long long> trees;
map<long long, long long> cnt;
vector<long long> down;
vector<long long> subtree;
long long dfs1(long long v, long long p) {
subtree[v] = 1;
Treap children;
for (long long to : g[v]) {
if (to == p) {
continue;
}
long long child = dfs1(to, v);
children.insert(child);
subtree[v] += subtree[to];
}
long long cur = children.get_hash() ^ subtree[v];
if (!trees.count(cur)) {
long long id = (long long)trees.size();
trees[cur] = id;
}
cur = trees[cur];
++cnt[cur];
down[v] = cur;
return cur;
}
vector<vector<long long>> hashes;
void dec(long long cur) {
--cnt[cur];
if (cnt[cur] == 0) {
cnt.erase(cur);
}
}
void inc(long long cur) { ++cnt[cur]; }
long long n;
void dfs2(long long v, long long p, long long up) {
long long cand = (long long)cnt.size() + 1;
if (best_ans < cand || best_ans == cand && v < best_v) {
best_ans = cand;
best_v = v;
}
Treap cur;
if (up != -1) {
cur.insert(up);
}
for (long long to : g[v]) {
if (to == p) {
continue;
}
cur.insert(down[to]);
}
for (long long to : g[v]) {
if (to == p) {
continue;
}
dec(down[to]);
cur.erase(down[to]);
long long now = cur.get_hash() ^ (n - subtree[to]);
long long id;
if (!trees.count(now)) {
id = (long long)trees.size();
trees[now] = id;
} else {
id = trees[now];
}
inc(id);
dfs2(to, v, id);
cur.insert(down[to]);
inc(down[to]);
dec(id);
}
}
void solve(bool read) {
for (long long w = 0; w < 2; ++w) {
powers[w][0] = 1;
for (long long i = 1; i < C; ++i) {
powers[w][i] = powers[w][i - 1] * pr[w] % mods[w];
}
}
cin >> n;
g.resize(n);
for (long long i = 1; i < n; ++i) {
long long a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
down.resize(n);
subtree.resize(n);
dfs1(0, 0);
hashes.resize(n);
dec(down[0]);
dfs2(0, 0, -1);
cout << best_v + 1 << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)3e5 + 10;
const int inf = (int)1e9 + 5;
const long long llinf = (long long)1e18 + 5;
const double pi = acos(-1.0);
vector<int> g[maxn];
vector<int> z[maxn];
map<pair<long long, long long>, int> have;
int num[maxn];
int cur = 1;
long long h[maxn];
long long pw[maxn];
long long pw2[maxn];
long long mod, mod2, base, base2, inv, inv2;
long long binpow(long long x, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = (ret * x) % mod;
x = (x * x) % mod;
n /= 2;
}
return ret;
}
int cnt[maxn];
int all;
void add(int x, int d) {
if (x == 0) return;
if (cnt[x] == 0 && d == 1) all++;
if (cnt[x] == 1 && d == -1) all--;
cnt[x] += d;
}
void dfs(int v, int par = -1) {
if (par != -1) g[v].erase(find((g[v]).begin(), (g[v]).end(), par));
for (int x : g[v]) {
dfs(x, v);
z[v].push_back(num[x]);
}
sort((z[v]).begin(), (z[v]).end());
long long HASH = 0, HASH2 = 0;
for (int i = (0); i < (z[v].size()); i++) {
HASH += z[v][i] * pw[i];
HASH %= mod;
HASH2 += z[v][i] * pw2[i];
HASH2 %= mod2;
}
if (!have.count(make_pair(HASH, HASH2))) have[make_pair(HASH, HASH2)] = cur++;
num[v] = have[make_pair(HASH, HASH2)];
add(num[v], +1);
}
void print() {
for (int i = (0); i < (30); i++)
if (cnt[i]) cout << i << ",";
cout << endl;
}
int ans = -1;
int res;
void dfs2(int v, int X) {
vector<pair<int, int> > t;
for (int x : g[v]) t.push_back(make_pair(num[x], x));
if (X != 0) t.push_back(make_pair(X, -1));
sort((t).begin(), (t).end());
vector<long long> HASH(t.size()), HASH2(t.size());
for (int i = (0); i < (t.size()); i++) {
HASH[i] += t[i].first * pw[i];
HASH2[i] += t[i].first * pw2[i];
if (i > 0) HASH[i] += HASH[i - 1], HASH2[i] += HASH2[i - 1];
HASH[i] %= mod;
HASH2[i] %= mod2;
}
if (!have.count(make_pair(HASH.back(), HASH2.back())))
have[make_pair(HASH.back(), HASH2.back())] = cur++;
add(X, +1);
add(num[v], -1);
add(have[make_pair(HASH.back(), HASH2.back())], +1);
if (umax(ans, all)) {
res = v;
}
add(have[make_pair(HASH.back(), HASH2.back())], -1);
for (int i = (0); i < (t.size()); i++) {
if (t[i].second == -1) continue;
long long H1 =
(i == 0 ? 0 : HASH[i - 1]) + (i + 1 < t.size() ? HASH[i + 1] : 0) * inv;
H1 %= mod;
long long H2 = (i == 0 ? 0 : HASH2[i - 1]) +
(i + 1 < t.size() ? HASH2[i + 1] : 0) * inv2;
H2 %= mod;
if (!have.count(make_pair(H1, H2))) have[make_pair(H1, H2)] = cur++;
dfs2(t[i].second, have[make_pair(H1, H2)]);
}
add(X, -1);
add(num[v], +1);
}
bool prime(long long x) {
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
int main() {
mod = gen() % 2000000000;
mod2 = gen() % 2000000000;
base = 300000 + gen() % 100000;
base2 = 300000 + gen() % 100000;
while (!prime(mod)) mod++;
while (!prime(mod2)) mod2++;
while (!prime(base)) base++;
while (!prime(base2)) base2++;
inv = binpow(base, mod - 2, mod);
inv2 = binpow(base2, mod2 - 2, mod2);
pw[0] = pw2[0] = 1;
for (int i = (1); i < (maxn); i++) {
pw[i] = (pw[i - 1] * base) % mod;
pw2[i] = (pw2[i - 1] * base2) % mod2;
}
int n = getint<int>();
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int i = (0); i < (n - 1); i++) {
int x = getint<int>();
int y = getint<int>();
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, -1);
dfs2(1, 0);
cout << res << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
unsigned long long seed[maxn];
unsigned long long Rand() {
return ((unsigned long long)rand() << 48) |
((unsigned long long)rand() << 32) |
((unsigned long long)rand() << 16) | rand();
}
vector<int> G[maxn];
unsigned long long h[maxn];
map<unsigned long long, int> mp, cnt;
int tot, sum, ans;
void dfs_init(int x, int par) {
h[x] = seed[0];
for (auto v : G[x]) {
if (v == par) continue;
dfs_init(v, x);
h[x] += seed[mp[h[v]]];
}
if (mp.count(h[x]) == 0) mp[h[x]] = ++tot;
cnt[h[x]]++;
}
int idx = 1;
void dfs(int x, int par, unsigned long long H) {
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
unsigned long long w = h[x];
if (x > 1) w += seed[mp[H]];
if (sum + 1 > ans) idx = x, ans = sum + 1;
for (auto v : G[x]) {
if (v == par) continue;
unsigned long long t = w - seed[mp[h[v]]];
if (!mp.count(t)) mp[t] = ++tot;
cnt[t]++;
if (cnt[t] == 1) ++sum;
dfs(v, x, t);
cnt[t]--;
if (cnt[t] == 0) --sum;
}
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
}
int main() {
srand(time(0));
for (int i = 0; i < maxn; ++i) seed[i] = Rand();
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
dfs_init(1, 1);
ans = sum = tot;
dfs(1, 1, 0);
assert(tot < maxn);
cout << idx << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
std::mt19937 rd(time(0));
const int MAXN = 100010;
const int mod = 1004535809;
void reduce(int& x) { x += x >> 31 & mod; }
int mul(int a, int b) { return (long long)a * b % mod; }
int pow(int a, int b, int res = 1) {
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) res = mul(res, a);
return res;
}
int func[MAXN], sz[MAXN];
int f[MAXN], n;
int head[MAXN], nxt[MAXN << 1], to[MAXN << 1], tot;
void adde(int b, int e) {
nxt[++tot] = head[b];
to[head[b] = tot] = e;
nxt[++tot] = head[e];
to[head[e] = tot] = b;
}
inline int tr(int x, int s) { return (long long)func[s] * x % mod; }
std::unordered_map<int, int> M;
int ans, rt, rtv = -1;
void add(int x) { ans += ++M[x] == 1; }
void dec(int x) { ans -= --M[x] == 0; }
void dfs(int u, int fa = 0) {
sz[u] = f[u] = 1;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
dfs(to[i], u), sz[u] += sz[to[i]];
reduce(f[u] += tr(f[to[i]], sz[to[i]]) - mod);
}
add(f[u]);
}
void dfs2(int u, int up = 0, int fa = 0) {
int dup = tr(up, n - sz[u]);
int full = (f[u] + dup) % mod;
if (fa) add(up);
add(full), dec(f[u]);
if (ans > rtv) rtv = ans, rt = u;
dec(full);
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
int t = ((long long)dup + f[u] - tr(f[to[i]], sz[to[i]]) + mod) % mod;
dfs2(to[i], t, u);
}
add(f[u]);
if (fa) dec(up);
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
for (int i = 1, b, e; i < n; ++i) std::cin >> b >> e, adde(b, e);
for (int i = 1; i <= n; ++i) func[i] = rd() % mod;
dfs(1);
dfs2(1);
std::cout << rt << std::endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 18);
const int64_t mod = (int64_t)1e9 + 7;
const int64_t base = (int64_t)3;
int64_t pw[MAXN];
struct implicit_treap {
struct node {
int sz, prior;
int64_t val, hsh, vlen, len;
node *l, *r;
node() {
sz = 0;
val = 0;
len = 0;
vlen = 0;
hsh = 0;
prior = 0;
l = nullptr;
r = nullptr;
}
node(int64_t _val, int _vlen) {
val = _val;
vlen = _vlen;
len = _vlen;
hsh = val;
sz = 1;
prior = rand();
l = nullptr;
r = nullptr;
}
};
typedef node *pnode;
int size(pnode v) { return v ? v->sz : 0; }
void update_size(pnode &v) {
if (v) v->sz = size(v->l) + size(v->r) + 1;
}
void reset(pnode &v) {
if (v) v->hsh = v->val, v->len = v->vlen;
}
void combine(pnode &v, pnode l, pnode r) {
if (!l) {
v = r;
return;
}
if (!r) {
v = l;
return;
}
v->hsh = (l->hsh * pw[r->len] + r->hsh) % mod;
v->len = l->len + r->len;
}
void operation(pnode &v) {
if (!v) return;
reset(v);
combine(v, v->l, v);
combine(v, v, v->r);
}
void merge(pnode &t, pnode l, pnode r) {
if (!l) {
t = r;
return;
}
if (!r) {
t = l;
return;
}
if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
update_size(t);
operation(t);
}
void split(pnode t, pnode &l, pnode &r, int k) {
if (!t) {
l = nullptr;
r = nullptr;
return;
}
if (t->val <= k)
split(t->r, t->r, r, k), l = t;
else
split(t->l, l, t->l, k), r = t;
update_size(t);
operation(t);
}
void split_by_size(pnode t, pnode &l, pnode &r, int k, int add = 0) {
if (!t) {
l = nullptr;
r = nullptr;
return;
}
int idx = add + size(t->l);
if (idx <= k)
split_by_size(t->r, t->r, r, k, idx + 1), l = t;
else
split_by_size(t->l, l, t->l, k, add), r = t;
update_size(t);
operation(t);
}
pnode root;
implicit_treap() { root = nullptr; }
void insert(int64_t val, int len) {
if (!root) {
pnode nw = new node(val, len);
root = nw;
return;
}
pnode l, r, nw = new node(val, len);
split(root, l, r, val - 1);
merge(l, l, nw);
merge(root, l, r);
}
void erase(int64_t val) {
if (!root) {
return;
}
pnode l, r, mid;
split(root, l, r, val - 1);
split_by_size(r, mid, r, 0);
merge(root, l, r);
}
int64_t get_hash() {
if (!root) return base + 2;
return ((pw[root->len] + root->hsh) * base + 2ll) % mod;
}
int64_t len() {
if (!root) return 2;
return (root->len) + 2;
}
};
int n;
vector<int> G[MAXN];
void read() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
}
pair<int, int> ans;
map<int64_t, int> cnt;
int64_t res = 0, dp[MAXN];
implicit_treap t[MAXN];
void pre_dfs(int u, int pr) {
for (int v : G[u])
if (v != pr) {
pre_dfs(v, u);
t[u].insert(dp[v], t[v].len());
}
dp[u] = (t[u].get_hash());
cnt[dp[u]]++;
if (cnt[dp[u]] == 1) res++;
}
void change_root(int cur, int nxt) {
cnt[dp[cur]]--;
if (cnt[dp[cur]] == 0) res--;
t[cur].erase(dp[nxt]);
dp[cur] = t[cur].get_hash();
cnt[dp[cur]]++;
if (cnt[dp[cur]] == 1) res++;
cnt[dp[nxt]]--;
if (cnt[dp[nxt]] == 0) res--;
t[nxt].insert(dp[cur], t[cur].len());
dp[nxt] = t[nxt].get_hash();
cnt[dp[nxt]]++;
if (cnt[dp[nxt]] == 1) res++;
}
void solve(int u, int pr) {
ans = max(ans, {res, -u});
for (int v : G[u])
if (v != pr) {
change_root(u, v);
solve(v, u);
}
if (pr != -1) change_root(u, pr);
}
void solve() {
pw[0] = 1;
for (int i = 1; i < MAXN; i++) pw[i] = (pw[i - 1] * base) % mod;
pre_dfs(1, 1);
ans = {res, -1};
solve(1, -1);
cout << -ans.second << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
int n, id;
vector<int> e[MAXN];
unsigned long long hsh[MAXN << 1];
map<unsigned long long, int> mp;
int sub[MAXN], cnt[MAXN << 1], sum, ans, ansp;
inline int Hash(unsigned long long x) {
if (mp.count(x)) return mp[x];
return mp[x] = ++id;
}
inline void Add(int x) { sum += (++cnt[x] == 1); }
inline void Del(int x) { sum -= (--cnt[x] == 0); }
void DFS1(int u, int fa) {
unsigned long long cur = 0;
for (auto v : e[u]) {
if (v == fa) continue;
DFS1(v, u);
cur += hsh[sub[v]];
}
sub[u] = Hash(cur);
Add(sub[u]);
}
void DFS2(int u, int fa, int fhs) {
Del(sub[u]);
if (sum + 1 > ans) {
ans = sum + 1;
ansp = u;
}
unsigned long long cur = 0;
for (auto v : e[u]) {
if (v == fa) continue;
cur += hsh[sub[v]];
}
cur += hsh[fhs];
for (auto v : e[u]) {
if (v == fa) continue;
int tmp = Hash(cur - hsh[sub[v]]);
Add(tmp);
DFS2(v, u, tmp);
Del(tmp);
}
Add(sub[u]);
}
void init() {
read(n);
for (int i = 1, u, v; i < n; ++i) {
read(u);
read(v);
e[u].push_back(v);
e[v].push_back(u);
}
srand((unsigned)time(NULL));
for (int i = 1; i <= n + n; ++i) {
unsigned long long cur = (unsigned long long)rand() * 998244353 * 998244353;
cur ^= (cur << 23) ^ (cur >> 29);
cur += (unsigned long long)rand() * 1000000007;
hsh[i] = cur;
}
}
void solve() {
DFS1(1, 0);
ans = sum;
ansp = 1;
DFS2(1, 0, 0);
printf("%d\n", ansp);
}
int main() {
init();
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[100002];
const int h_num = 2;
long long int B[] = {1011235817, 1011235817, 1011235817, 987654347, 1011235817,
1021328611, 987654347, 1011235817, 1000000007};
struct HASH {
vector<long long int> val;
bool emp;
HASH(int v_ = 0) {
val.assign(h_num, 0);
emp = false;
for (int i = 0; i < h_num; i++) {
val[i] = v_;
}
}
vector<long long int> get() { return val; }
};
HASH R[100002];
HASH operator*(const HASH &a, const HASH &b) {
if (a.emp) {
return b;
}
if (b.emp) {
return a;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] * b.val[i];
if (r.val[i] >= B[i]) r.val[i] %= B[i];
}
return r;
}
HASH operator+(const HASH &a, HASH &b) {
if (a.emp) {
return a;
}
if (b.emp) {
return b;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] + b.val[i];
if (r.val[i] >= B[i]) {
r.val[i] %= B[i];
}
}
return r;
}
HASH h[100002];
map<vector<long long int>, int> tmp;
int dep[100002];
inline void dfs(int b, int pr = -1) {
vector<HASH> vv;
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
dfs(v[b][i], b);
dep[b] = max(dep[b], dep[v[b][i]] + 1);
}
}
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
vv.push_back(h[v[b][i]] + R[dep[b]]);
}
}
if (vv.size() == 0) {
h[b] = HASH(1);
return;
}
HASH sum = vv[0];
for (int i = 1; i < vv.size(); i++) {
sum = sum * vv[i];
}
h[b] = sum;
return;
}
int maxt;
int idd;
inline void dfs2(int b, int pr, map<vector<long long int>, int> &mp, HASH par2,
int par_dep) {
par_dep++;
mp[h[b].get()]--;
if (mp[h[b].get()] == 0) {
mp.erase(h[b].get());
}
vector<HASH> vv[2];
vector<HASH> im1[2];
vector<HASH> im2[2];
vector<int> H;
H.push_back(par_dep);
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
H.push_back(dep[v[b][i]] + 1);
}
}
sort(H.begin(), H.end(), greater<int>());
if (H.size() == 1) {
H.push_back(H.back());
}
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
for (int j = 0; j < 2; j++) {
vv[j].push_back(h[v[b][i]] + R[H[j]]);
}
}
}
for (int j = 0; j < 2; j++) {
im1[j] = im2[j] = vv[j];
}
for (int j = 0; j < 2; j++) {
for (int i = 1; i < im1[j].size(); i++) {
im1[j][i] = im1[j][i] * im1[j][i - 1];
}
for (int i = (int)(im2[j].size()) - 2; i >= 0; i--) {
im2[j][i] = im2[j][i] * im2[j][i + 1];
}
}
HASH par[2];
par[0] = par2 + R[H[0]];
par[1] = par2 + R[H[1]];
HASH cur[2];
cur[0] = par[0];
cur[1] = par[1];
for (int j = 0; j < 2; j++) {
if (im1[j].size()) {
cur[j] = cur[j] * im1[j].back();
}
}
mp[cur[0].get()]++;
if (maxt < mp.size()) {
maxt = mp.size();
idd = b;
}
if (maxt == mp.size()) {
idd = min(idd, b);
}
mp[cur[0].get()]--;
if (mp[cur[0].get()] == 0) {
mp.erase(cur[0].get());
}
int id = -1;
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] == pr) continue;
id++;
HASH go;
go.emp = true;
int flag = 0;
if (H[0] == dep[v[b][i]] + 1) {
flag++;
}
if (id) {
go = go * im1[flag][id - 1];
}
if (id + 1 < im2[flag].size()) {
go = go * im2[flag][id + 1];
}
go = go * par[flag];
if (go.emp == true) {
go = HASH(1);
}
mp[go.get()]++;
dfs2(v[b][i], b, mp, go, H[flag]);
mp[go.get()]--;
if (mp[go.get()] == 0LL) {
mp.erase(go.get());
}
}
mp[h[b].get()]++;
}
bool use[5000000];
vector<int> pr;
int main() {
for (int i = 2; i < 5000000; i++) {
if (use[i] == false) {
for (int j = i * 2; j < 5000000; j += i) {
use[j] = true;
}
pr.push_back(i);
}
}
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int i = 0; i < 100002; i++) {
for (int j = 0; j < h_num; j++) {
R[i].val[j] = pr[rand() % pr.size()];
}
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
int root = 0;
dfs(root);
for (int i = 0; i < n; i++) {
tmp[h[i].get()]++;
}
HASH f;
f.emp = true;
dfs2(root, -1, tmp, f, -1);
cout << idd + 1 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void next_int(T &x) {
x = 0;
char c;
bool neg = false;
while (!isdigit(c = getchar()))
if (c == '-') neg = true;
do x = x * 10 + c - 48;
while (isdigit(c = getchar()));
if (neg) x = -x;
}
template <typename T>
inline void write_int(T x, char last = 0) {
if (x < 0) putchar('-'), x = abs(x);
char tmp[20];
int cnt = 0;
while (x >= 10) tmp[cnt++] = x % 10 + 48, x /= 10;
tmp[cnt] = x + 48;
for (int i = (cnt); i >= (0); --i) putchar(tmp[i]);
if (last) putchar(last);
}
const int N = (int)1e5 + 5;
int n, res, op;
long long h[N], hp[N], sz[N], cntChild[N];
vector<int> g[N];
class CntMap {
private:
map<long long, int> cnt;
public:
int size() { return ((int)cnt.size()); }
void insert(long long x) { ++cnt[x]; }
void erase(long long x) {
auto it = cnt.find(x);
if (it != cnt.end()) {
--it->second;
if (!it->second) cnt.erase(it);
}
}
} s;
void dfs_prep(int u, int p) {
sz[u] = h[u] = cntChild[u] = 1;
for (int i = (0); i < (((int)g[u].size())); ++i) {
int v = g[u][i];
if (v == p) continue;
dfs_prep(v, u);
sz[u] += sz[v], ++cntChild[u];
h[u] += h[v] * sz[v] * cntChild[v];
}
s.insert(h[u] * sz[u] * cntChild[u]);
}
void dfs_calc(int u, int p) {
long long hr = h[u] + hp[p] * ((long long)n - sz[u]);
s.erase(h[u] * sz[u] * cntChild[u]);
s.insert(hr * n * (cntChild[u] + (long long)(p != 0)));
if (res < ((int)s.size())) res = ((int)s.size()), op = u;
s.erase(hr * n * (cntChild[u] + (long long)(p != 0)));
for (int i = (0); i < (((int)g[u].size())); ++i) {
int v = g[u][i];
if (v == p) continue;
long long tmp = hr - h[v] * sz[v] * cntChild[v];
s.insert(tmp * ((long long)n - sz[v]) *
(cntChild[u] - (long long)(p == 0)));
hp[u] = tmp * (cntChild[u] - (long long)(p == 0));
dfs_calc(v, u);
s.erase(tmp * ((long long)n - sz[v]) * (cntChild[u] - (long long)(p == 0)));
}
s.insert(h[u] * sz[u] * cntChild[u]);
}
int main() {
next_int(n);
for (int i = (1); i < (n); ++i) {
int u, v;
next_int(u), next_int(v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs_prep(1, 0);
dfs_calc(1, 0);
write_int(op);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > tree;
vector<vector<long long> > frw_hash;
vector<vector<long long> > rev_hash;
vector<int> num;
const long long p = 179;
const long long mod = 1791791791l;
const int maxn = 1e6 + 179;
void get_all(int v, int par, unordered_map<long long, int>& ums) {
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]++;
get_all(u, v, ums);
}
i++;
}
}
void dfs(int v, int par, unordered_map<long long, int>& ums) {
num[v] = ums.size();
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]--;
if (ums[frw_hash[v][i]] == 0) ums.erase(frw_hash[v][i]);
ums[rev_hash[v][i]]++;
dfs(u, v, ums);
ums[rev_hash[v][i]]--;
if (ums[rev_hash[v][i]] == 0) ums.erase(rev_hash[v][i]);
ums[frw_hash[v][i]]++;
}
i++;
}
}
int main() {
long long ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) ppows[i] = (ppows[i - 1] * p) % mod;
int n;
cin >> n;
tree.resize(n);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
tree[u].push_back(v);
tree[v].push_back(u);
edges.push_back(make_pair(u, v));
edges.push_back(make_pair(v, u));
}
map<pair<int, int>, int> index;
for (int i = 0; i < 2 * n - 2; ++i) index[edges[i]] = i;
vector<long long> rem_hh(edges.size(), -1);
vector<int> sz_of(edges.size(), -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (tree[i].size() == 1) {
rem_hh[index[make_pair(tree[i][0], i)]] = ('(' * p + ')') % mod;
sz_of[index[make_pair(tree[i][0], i)]] = 1;
q.push(index[make_pair(tree[i][0], i)]);
}
}
vector<long long> hash_of(edges.size(), -1);
vector<int> out(n, 0);
while (!q.empty()) {
int a = q.front();
q.pop();
if (hash_of[a] != -1) continue;
hash_of[a] = rem_hh[a];
int v = edges[a].first;
out[v]++;
if (out[v] == (int)tree[v].size() - 1) {
int u = -1;
vector<long long> known_outer_hashes;
vector<int> known_subtree_sizes;
for (int w : tree[v]) {
if (hash_of[index[make_pair(v, w)]] == -1)
u = w;
else {
known_outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
known_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
}
vector<int> ind(known_outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return known_outer_hashes[i] < known_outer_hashes[j];
});
vector<int> szs;
vector<long long> next_hh;
for (int i = 0; i < known_outer_hashes.size(); ++i) {
next_hh.push_back(known_outer_hashes[ind[i]]);
szs.push_back(known_subtree_sizes[ind[i]]);
}
int i = index[make_pair(u, v)];
rem_hh[i] = '(';
sz_of[i] = 1;
for (int j = 0; j < next_hh.size(); ++j) {
rem_hh[i] = (rem_hh[i] * ppows[2 * szs[j]]) % mod;
rem_hh[i] = (rem_hh[i] + next_hh[j]) % mod;
sz_of[i] += szs[j];
}
rem_hh[i] = (rem_hh[i] * p + ')') % mod;
q.push(i);
continue;
}
if (out[v] != (int)tree[v].size()) continue;
vector<long long> pr_next_hh, next_hh;
vector<int> pr_szs, szs;
for (int w : tree[v]) {
pr_next_hh.push_back(hash_of[index[make_pair(v, w)]]);
pr_szs.push_back(sz_of[index[make_pair(v, w)]]);
}
vector<int> ind(pr_next_hh.size());
vector<int> rev(pr_next_hh.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return pr_next_hh[i] < pr_next_hh[j];
});
for (int i = 0; i < pr_next_hh.size(); ++i) {
rev[ind[i]] = i;
next_hh.push_back(pr_next_hh[ind[i]]);
szs.push_back(pr_szs[ind[i]]);
}
vector<long long> pref_hh(next_hh.size() + 1, 0);
pref_hh[0] = '(';
pref_hh[1] = ('(' * p + next_hh[0]) % mod;
for (int i = 1; i < next_hh.size() + 1; ++i) {
pref_hh[i] =
(pref_hh[i - 1] * ppows[2 * szs[i - 1]] + next_hh[i - 1]) % mod;
}
pref_hh.push_back((pref_hh.back() * p + ')') % mod);
vector<long long> suf_hh(next_hh.size() + 2, 0);
vector<int> suf_sz(next_hh.size() + 2, 0);
suf_hh.back() = ')';
for (int i = next_hh.size(); i > 0; i--) {
suf_hh[i] =
(suf_hh[i + 1] + next_hh[i - 1] * ppows[2 * suf_sz[i + 1] + 1]) % mod;
suf_sz[i] = suf_sz[i + 1] + szs[i - 1];
}
suf_hh[0] = (suf_hh[1] + '(' * ppows[2 * suf_sz[1] + 1]) % mod;
suf_sz[0] = suf_sz[1];
for (int i = 0; i < next_hh.size(); ++i) {
int u = tree[v][ind[i]];
if (rem_hh[index[make_pair(u, v)]] == -1) {
sz_of[index[make_pair(u, v)]] = n - sz_of[index[make_pair(v, u)]];
rem_hh[index[make_pair(u, v)]] =
(pref_hh[i] * ppows[2 * suf_sz[i + 2] + 1] + suf_hh[i + 2]) % mod;
q.push(index[make_pair(u, v)]);
}
}
}
frw_hash.resize(n);
rev_hash.resize(n);
num.resize(n);
for (int i = 0; i < n; ++i) {
for (int v : tree[i]) {
frw_hash[i].push_back(hash_of[index[make_pair(i, v)]]);
rev_hash[i].push_back(hash_of[index[make_pair(v, i)]]);
}
}
unordered_map<long long, int> ump;
get_all(0, -1, ump);
dfs(0, -1, ump);
cout << distance(num.begin(), max_element(num.begin(), num.end())) + 1
<< endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > tree;
vector<vector<long long> > frw_hash;
vector<vector<long long> > rev_hash;
vector<int> num;
const long long p = 179;
const long long mod = 1791791791l;
const int maxn = 1e6 + 179;
void get_all(int v, int par, unordered_map<long long, int>& ums) {
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]++;
get_all(u, v, ums);
}
i++;
}
}
void dfs(int v, int par, unordered_map<long long, int>& ums) {
num[v] = ums.size();
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]--;
if (ums[frw_hash[v][i]] == 0) ums.erase(frw_hash[v][i]);
ums[rev_hash[v][i]]++;
dfs(u, v, ums);
ums[rev_hash[v][i]]--;
if (ums[rev_hash[v][i]] == 0) ums.erase(rev_hash[v][i]);
ums[frw_hash[v][i]]++;
}
i++;
}
}
int main() {
long long ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) ppows[i] = (ppows[i - 1] * p) % mod;
int n;
cin >> n;
tree.resize(n);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
tree[u].push_back(v);
tree[v].push_back(u);
edges.push_back(make_pair(u, v));
edges.push_back(make_pair(v, u));
}
map<pair<int, int>, int> index;
for (int i = 0; i < 2 * n - 2; ++i) index[edges[i]] = i;
vector<long long> rem_hh(edges.size(), -1);
vector<int> sz_of(edges.size(), -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (tree[i].size() == 1) {
rem_hh[index[make_pair(tree[i][0], i)]] = ('(' * p + ')') % mod;
sz_of[index[make_pair(tree[i][0], i)]] = 1;
q.push(index[make_pair(tree[i][0], i)]);
}
}
vector<long long> hash_of(edges.size(), -1);
vector<int> out(n, 0);
while (!q.empty()) {
int a = q.front();
q.pop();
if (hash_of[a] != -1) continue;
hash_of[a] = rem_hh[a];
int v = edges[a].first;
out[v]++;
if (out[v] == tree[v].size() - 1) {
int u = -1;
vector<long long> known_outer_hashes;
vector<int> known_subtree_sizes;
for (int w : tree[v]) {
if (hash_of[index[make_pair(v, w)]] == -1)
u = w;
else {
known_outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
known_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
}
vector<int> ind(known_outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return known_outer_hashes[i] < known_outer_hashes[j];
});
vector<int> szs;
vector<long long> next_hh;
for (int i = 0; i < known_outer_hashes.size(); ++i) {
next_hh.push_back(known_outer_hashes[ind[i]]);
szs.push_back(known_subtree_sizes[ind[i]]);
}
int i = index[make_pair(u, v)];
rem_hh[i] = '(';
sz_of[i] = 1;
for (int j = 0; j < next_hh.size(); ++j) {
rem_hh[i] = (rem_hh[i] * ppows[2 * szs[j]]) % mod;
rem_hh[i] = (rem_hh[i] + next_hh[j]) % mod;
sz_of[i] += szs[j];
}
rem_hh[i] = (rem_hh[i] * p + ')') % mod;
q.push(i);
continue;
}
if (out[v] != tree[v].size()) continue;
vector<long long> outer_hashes;
vector<int> outer_subtree_sizes;
for (int w : tree[v]) {
outer_hashes.push_back(hash_of[index[make_pair(v, w)]]);
outer_subtree_sizes.push_back(sz_of[index[make_pair(v, w)]]);
}
vector<int> ind(outer_hashes.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return outer_hashes[i] < outer_hashes[j];
});
vector<long long> next_hh;
vector<int> szs, rev(outer_hashes.size());
for (int i = 0; i < outer_hashes.size(); ++i) {
rev[ind[i]] = i;
next_hh.push_back(outer_hashes[ind[i]]);
szs.push_back(outer_subtree_sizes[ind[i]]);
}
vector<long long> pref_hh(next_hh.size() + 1, 0);
pref_hh[0] = '(';
for (int i = 1; i < next_hh.size() + 1; ++i) {
pref_hh[i] =
(pref_hh[i - 1] * ppows[2 * szs[i - 1]] + next_hh[i - 1]) % mod;
}
pref_hh.push_back((pref_hh.back() * p + ')') % mod);
vector<long long> suf_hh(next_hh.size() + 2, 0);
vector<int> suf_sz(next_hh.size() + 2, 0);
suf_hh.back() = ')';
for (int i = next_hh.size(); i > 0; i--) {
suf_hh[i] =
(suf_hh[i + 1] + next_hh[i - 1] * ppows[2 * suf_sz[i + 1] + 1]) % mod;
suf_sz[i] = suf_sz[i + 1] + szs[i - 1];
}
suf_hh[0] = (suf_hh[1] + '(' * ppows[2 * suf_sz[1] + 1]) % mod;
suf_sz[0] = suf_sz[1];
for (int i = 0; i < next_hh.size(); ++i) {
int u = tree[v][ind[i]];
if (rem_hh[index[make_pair(u, v)]] == -1) {
sz_of[index[make_pair(u, v)]] = n - sz_of[index[make_pair(v, u)]];
rem_hh[index[make_pair(u, v)]] =
(pref_hh[i] * ppows[2 * suf_sz[i + 2] + 1] + suf_hh[i + 2]) % mod;
q.push(index[make_pair(u, v)]);
}
}
}
frw_hash.resize(n);
rev_hash.resize(n);
num.resize(n);
for (int i = 0; i < n; ++i) {
for (int v : tree[i]) {
frw_hash[i].push_back(hash_of[index[make_pair(i, v)]]);
rev_hash[i].push_back(hash_of[index[make_pair(v, i)]]);
}
}
unordered_map<long long, int> ump;
get_all(0, -1, ump);
dfs(0, -1, ump);
cout << distance(num.begin(), max_element(num.begin(), num.end())) + 1
<< endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mul = 23333;
const int mod = 1000116211;
const int ivm = 823862834;
const int maxn = 100025;
int n, m, i, j, t, k, s, N, head[maxn], su[maxn], has[maxn], siz[maxn],
up[maxn], ans[maxn], mx, mxp;
struct Edge {
int nxt, aim;
} edge[maxn << 1];
map<int, int> mp;
inline bool isp(int x) {
for (int y = 2; y * 1ll * y <= x; ++y)
if (x % y == 0) return 0;
return 1;
}
inline void add_edge(int x, int y) {
edge[++N] = (Edge){head[x], y};
head[x] = N;
edge[++N] = (Edge){head[y], x};
head[y] = N;
}
inline int Pow(int x, int y, int mo) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % mo;
x = 1ll * x * x % mo;
y >>= 1;
}
return ret;
}
inline void ins(int x) {
if (!mp[x]) ++s;
mp[x]++;
}
inline void del(int x) {
--mp[x];
if (!mp[x]) --s;
}
void dfs1(int x, int y) {
siz[x] = 1;
for (int i = head[x]; i; i = edge[i].nxt) {
int des = edge[i].aim;
if (des == y) continue;
dfs1(des, x);
siz[x] += siz[des];
su[x] = (su[x] + has[des]) % mod;
}
has[x] = 1ll * (su[x] + siz[x]) * siz[x] % mod;
if (x ^ 1) ins(has[x]);
}
void dfs2(int x, int y) {
ans[x] = s;
if (ans[x] > mx) mx = ans[x], mxp = x;
for (int i = head[x]; i; i = edge[i].nxt) {
int des = edge[i].aim;
if (des == y) continue;
up[des] = ((up[x] + su[x] - has[des]) % mod + (n - siz[des])) * 1ll *
(n - siz[des]) % mod;
del(has[des]);
ins(up[des]);
dfs2(des, x);
del(up[des]);
ins(has[des]);
}
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; ++i) {
scanf("%d%d", &t, &k);
add_edge(t, k);
}
s = 0;
mx = -1;
dfs1(1, 0);
dfs2(1, 0);
printf("%d\n", mxp);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
static char c;
static int f;
for (c = getchar(), f = 1; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -f;
for (x = 0; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + (c & 15);
x *= f;
}
template <typename T>
void write(T x) {
static char q[65];
int cnt = 0;
if (x < 0) putchar('-'), x = -x;
q[++cnt] = x % 10, x /= 10;
while (x) q[++cnt] = x % 10, x /= 10;
while (cnt) putchar(q[cnt--] + '0');
}
const int mod = 1000000007, maxn = 100005;
int mo(const int x) { return x >= mod ? x - mod : x; }
int power(int a, int x) {
int re = 1;
while (x) {
if (x & 1) re = 1ll * re * a % mod;
a = 1ll * a * a % mod, x >>= 1;
}
return re;
}
struct Edge {
int v, nt;
Edge(int v = 0, int nt = 0) : v(v), nt(nt) {}
} e[maxn * 2];
int hd[maxn], num;
void qwq(int u, int v) { e[++num] = Edge(v, hd[u]), hd[u] = num; }
int sz[maxn], ha[maxn], pri[maxn];
void dfs0(int u, int fa) {
sz[u] = 1;
ha[u] = 0;
for (int i = hd[u]; i; i = e[i].nt) {
int v = e[i].v;
if (v == fa) continue;
dfs0(v, u);
sz[u] += sz[v];
ha[u] = mo(ha[u] + ha[v]);
}
ha[u] = mo(1ll * ha[u] * sz[u] % mod + pri[sz[u]]);
}
int I[maxn][4];
void dfs1(int u, int fa) {
int hu = ha[u], su = sz[u];
for (int i = hd[u]; i; i = e[i].nt) {
int v = e[i].v;
if (v == fa) continue;
I[v][0] = ha[u];
I[v][1] = ha[v];
ha[u] =
mo(mod - ha[v] +
1ll * mo(mod - pri[sz[u]] + ha[u]) * power(sz[u], mod - 2) % mod);
sz[u] -= sz[v];
ha[u] = mo(1ll * ha[u] * sz[u] % mod + pri[sz[u]]);
ha[v] = 1ll * mo(mod - pri[sz[v]] + ha[v]) * power(sz[v], mod - 2) % mod;
sz[v] += sz[u];
ha[v] = mo(1ll * mo(ha[v] + ha[u]) * sz[v] % mod + pri[sz[v]]);
I[v][2] = ha[u];
I[v][3] = ha[v];
dfs1(v, u);
ha[u] = hu, sz[u] = su;
}
}
int ox[maxn * 5], sum[maxn * 5], cnt;
int no, mx, ans;
void add(int pos) { no += !(sum[pos]++); }
void del(int pos) { no -= !(--sum[pos]); }
void dfs2(int u, int fa) {
if (fa) {
del(lower_bound(ox, ox + cnt, I[u][0]) - ox);
del(lower_bound(ox, ox + cnt, I[u][1]) - ox);
add(lower_bound(ox, ox + cnt, I[u][2]) - ox);
add(lower_bound(ox, ox + cnt, I[u][3]) - ox);
}
if (no > mx) mx = no, ans = u;
for (int i = hd[u]; i; i = e[i].nt) {
int v = e[i].v;
if (v == fa) continue;
dfs2(v, u);
}
if (fa) {
add(lower_bound(ox, ox + cnt, I[u][0]) - ox);
add(lower_bound(ox, ox + cnt, I[u][1]) - ox);
del(lower_bound(ox, ox + cnt, I[u][2]) - ox);
del(lower_bound(ox, ox + cnt, I[u][3]) - ox);
}
}
int cp[maxn];
int main() {
int n;
read(n);
for (int i = 1; i <= n; ++i) pri[i] = 1ll * i * i % mod;
for (int i = 1; i < n; ++i) {
int u, v;
read(u), read(v);
qwq(u, v);
qwq(v, u);
}
dfs0(1, 0);
for (int i = 1; i <= n; ++i) ox[cnt++] = cp[i] = ha[i];
dfs1(1, 0);
for (int i = 1; i <= n; ++i)
for (int t = 0; t < 4; ++t) ox[cnt++] = I[i][t];
sort(ox, ox + cnt);
cnt = unique(ox, ox + cnt) - ox;
for (int i = 1; i <= n; ++i) add(lower_bound(ox, ox + cnt, cp[i]) - ox);
dfs2(1, 0);
write(ans), putchar('\n');
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + ch - '0', ch = getchar();
return f * s;
}
map<unsigned long long, int> mp;
unsigned long long val[400010];
int n, f[400010], up[400010], in[400010], cnt;
struct edge {
int to, lt;
} e[400010 << 1];
void add(int x, int y) {
e[++cnt].to = y;
e[cnt].lt = in[x];
in[x] = cnt;
e[++cnt].to = x;
e[cnt].lt = in[y];
in[y] = cnt;
}
int gg;
int get(unsigned long long x) { return mp.count(x) ? mp[x] : mp[x] = ++gg; }
void dfs(int x, int fr) {
unsigned long long s = 0;
for (int i = in[x]; i; i = e[i].lt) {
int y = e[i].to;
if (y == fr) continue;
dfs(y, x);
s += val[f[y]];
}
f[x] = get(s);
}
int ans, mx, rt, num[400010];
void ins(int x) {
if (!num[x]) ans++;
num[x]++;
}
void del(int x) {
num[x]--;
if (!num[x]) ans--;
}
void dfs2(int x, int fr) {
del(f[x]);
if (ans >= mx) mx = ans, rt = x;
unsigned long long s = val[up[fr]];
for (int i = in[x]; i; i = e[i].lt) {
int y = e[i].to;
if (y == fr) continue;
s += val[f[y]];
}
for (int i = in[x]; i; i = e[i].lt) {
int y = e[i].to;
if (y == fr) continue;
unsigned long long nv = s - val[f[y]];
up[x] = get(nv);
ins(up[x]);
dfs2(y, x);
del(up[x]);
}
ins(f[x]);
}
int main() {
n = read();
srand(20021225);
for (int i = 1; i <= 4 * n; i++)
val[i] = (unsigned long long)rand() << 47 |
(unsigned long long)rand() << 31 |
(unsigned long long)rand() << 15 | rand();
for (int i = 1; i < n; i++) add(read(), read());
dfs(1, 0);
for (int i = 1; i <= n; i++) ins(f[i]);
dfs2(1, 0);
printf("%d\n", rt);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long Pow(long long a, long long b, long long mod) {
long long x = 1;
for (; b > 0; b >>= 1) {
if (b & 1) x = x * a % mod;
a = a * a % mod;
}
return x;
}
namespace multihash {
const int D = 2, N = 1e5 + 5;
array<int, D> B[N], iB[N], M, Z;
array<int, D> operator+(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) {
lhs[i] += rhs[i];
if (lhs[i] >= M[i]) lhs[i] -= M[i];
}
return lhs;
}
array<int, D> operator-(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) {
lhs[i] -= rhs[i];
if (lhs[i] < 0) lhs[i] += M[i];
}
return lhs;
}
array<int, D> operator*(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) lhs[i] = (long long)lhs[i] * rhs[i] % M[i];
return lhs;
}
array<int, D> pow(array<int, D> lhs, long long b) {
array<int, D> x;
x.fill(1);
for (; b > 0; b >>= 1) {
if (b & 1) x = x * lhs;
lhs = lhs * lhs;
}
return x;
}
array<int, D> to_mhash(int x) {
array<int, D> m;
m.fill(x);
return m;
}
void init(const array<int, D> &b, const array<int, D> &m) {
M = m, B[1] = b, Z.fill(0), B[0].fill(1), iB[0].fill(1);
for (int i = 0; i < D; ++i) iB[1][i] = Pow(B[1][i], M[i] - 2, M[i]);
for (int i = 2; i < N; ++i) {
B[i] = B[i - 1] * B[1];
iB[i] = iB[i - 1] * iB[1];
}
}
} // namespace multihash
namespace merkle_tree {
using namespace multihash;
void get(vector<array<int, D>> &v, bool sorted = false) {
if (!sorted) sort(v.begin(), v.end() - 1);
int n = v.size();
for (int i = 1; i < n; ++i) v[i] = v[i - 1] + v[i] * B[i];
}
void rget(vector<array<int, D>> &v) {
int n = v.size();
for (int i = n - 1; i > 0; --i) v[i] = (v[i] - v[i - 1]) * iB[i];
}
int solve(const vector<vector<int>> &adj) {
int n = adj.size(), pos;
vector<int> sz(n, 1);
vector<vector<array<int, D>>> h(n), ch(n), rh(n);
function<void(int, int)> dfs1 = [&](int u, int p) {
for (auto v : adj[u])
if (v != p) {
dfs1(v, u);
sz[u] += sz[v];
h[u].push_back(h[v].back());
}
h[u].push_back(to_mhash(sz[u]));
get(h[u]);
};
dfs1(0, -1);
auto f = [&](array<int, D> x) { return (long long)x[0] << 32 | x[1]; };
map<long long, int> mp;
for (int u = 0; u < n; ++u) ++mp[f(h[u].back())];
int cnt = mp.size(), best = 0, node;
auto update = [&](array<int, D> u, int c) {
long long x = f(u);
cnt -= mp[x] > 0;
mp[x] += c;
cnt += mp[x] > 0;
};
function<void(int, int)> dfs2 = [&](int u, int p) {
if (cnt > best) best = cnt, node = u;
rh[u] = h[u];
rget(rh[u]);
for (auto v : adj[u])
if (v != p) {
update(h[v].back(), -1);
update(h[u].back(), -1);
sz[u] -= sz[v];
sz[v] = n;
ch[v] = h[v];
pos = lower_bound(rh[u].begin(), rh[u].end() - 1, h[v].back()) -
rh[u].begin();
h[u].back() = (pos ? h[u][pos - 1] : Z) +
(h[u].end()[-2] - h[u][pos]) * iB[1] +
to_mhash(sz[u]) * B[h[u].size() - 2];
rget(h[v]);
h[v].back().fill(sz[v]);
h[v].insert(lower_bound(h[v].begin(), h[v].end() - 1, h[u].back()),
h[u].back());
get(h[v], true);
update(h[v].back(), +1);
update(h[u].back(), +1);
dfs2(v, u);
update(h[v].back(), -1);
update(h[u].back(), -1);
h[u].back() = h[u].end()[-2] + rh[u].back() * B[h[u].size() - 1];
h[v] = ch[v];
sz[v] = n - sz[u];
sz[u] = n;
update(h[v].back(), +1);
update(h[u].back(), +1);
}
};
dfs2(0, -1);
return node;
}
} // namespace merkle_tree
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
multihash::init({13, 23}, {(int)1e9 + 7, (int)1e9 + 9});
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << merkle_tree::solve(adj) + 1 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 50;
const int mods[4] = {(int)1e9 + 7, (int)1e9 + 9, (int)1e9 + 21, (int)1e9 + 33};
const int mod = 998244353;
int p = 10;
long long pw[4][N];
struct hs {
long long val[2];
hs() { fill(val, val + 2, 0); }
hs(long long a, long long b, long long c, long long d) {
val[0] = a, val[1] = b;
}
bool operator<(const hs &other) const {
for (int i = 0; i < 2; i++)
if (val[i] != other.val[i]) return val[i] < other.val[i];
return false;
}
bool operator==(const hs &other) const {
for (int i = 0; i < 2; i++)
if (val[i] != other.val[i]) return false;
return true;
}
hs operator+(const hs &other) const {
hs res;
for (int i = 0; i < 2; i++) res.val[i] = (val[i] + other.val[i]) % mods[i];
return res;
}
hs operator-(const hs &other) const {
hs res;
for (int i = 0; i < 2; i++)
res.val[i] = (val[i] - other.val[i] + mods[i]) % mods[i];
return res;
}
hs operator^(const int pwi) const {
hs res;
for (int i = 0; i < 2; i++) {
res.val[i] = (val[i] * pw[i][pwi]) % mods[i];
}
return res;
}
void add(int x, int pwi) {
for (int i = 0; i < 2; i++) {
val[i] = (val[i] + x * pw[i][pwi]) % mods[i];
if (val[i] < 0) val[i] += mods[i];
}
}
};
int get_count(vector<pair<hs, int> > &v, pair<hs, int> &h) {
return (int)(upper_bound(v.begin(), v.end(), h) -
lower_bound(v.begin(), v.end(), h));
}
int fres = 0, id;
struct Graph {
int n;
vector<int> G[N];
pair<hs, int> dp[N];
void init() {
fres = 0;
id = -1;
tcnt = 0;
mp.clear();
cin >> n;
for (int i = 0; i < n; i++) G[i].clear();
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
}
pair<hs, int> wrap(pair<hs, int> pl) {
pl.first.add(1, pl.second);
pl.first = pl.first ^ 1;
pl.second += 2;
return pl;
}
pair<hs, int> merge(pair<hs, int> p1, pair<hs, int> p2) {
return pair<hs, int>((p1.first ^ p2.second) + p2.first,
p1.second + p2.second);
}
vector<pair<hs, int> > pls_all[N], psum_all[N], ssum_all[N];
pair<hs, int> dfs(int v, int p) {
vector<pair<hs, int> > &pls = pls_all[v];
pls.clear();
for (int i = 0; i < G[v].size(); i++) {
int nxt = G[v][i];
if (nxt != p) {
pls.push_back(dfs(nxt, v));
}
}
sort(pls.begin(), pls.end());
pair<hs, int> res;
for (pair<hs, int> pl : pls) res = merge(res, pl);
return dp[v] = wrap(res);
}
pair<hs, int> get_except(vector<pair<hs, int> > &psum,
vector<pair<hs, int> > &ssum, int i) {
pair<hs, int> res;
if (i > 0) res = merge(res, psum[i - 1]);
if (i + 1 < ssum.size()) res = merge(res, ssum[i + 1]);
return res;
}
int tcnt;
map<pair<hs, int>, int> mp;
void add(pair<hs, int> &h, int val) {
int &cnt = mp[h];
tcnt -= cnt > 0;
cnt += val;
tcnt += cnt > 0;
}
void reroot(int v, int p, pair<hs, int> up_hs) {
vector<pair<hs, int> > &pls = pls_all[v];
pls.clear();
vector<pair<hs, int> > &psum = psum_all[v];
psum.clear();
vector<pair<hs, int> > &ssum = ssum_all[v];
ssum.clear();
for (int nxt : G[v]) {
if (nxt != p) pls.push_back(dp[nxt]);
}
if (p != -1) pls.push_back(up_hs);
sort(pls.begin(), pls.end());
psum.resize(pls.size());
ssum.resize(pls.size());
psum[0] = pls[0];
for (int i = 1; i < pls.size(); i++) psum[i] = merge(psum[i - 1], pls[i]);
ssum.back() = pls.back();
for (int i = (int)pls.size() - 2; i >= 0; i--)
ssum[i] = merge(pls[i], ssum[i + 1]);
add(dp[v], -1);
pair<hs, int> cur_res = wrap(ssum[0]);
add(cur_res, 1);
if (tcnt > fres) {
fres = tcnt;
id = v;
}
add(cur_res, -1);
for (int nxt : G[v]) {
if (nxt == p) continue;
auto fir = lower_bound(pls.begin(), pls.end(), dp[nxt]) - pls.begin();
pair<hs, int> new_hs = wrap(get_except(psum, ssum, fir));
add(new_hs, 1);
reroot(nxt, v, new_hs);
add(new_hs, -1);
}
add(dp[v], 1);
}
} g;
void solve() {
g.init();
if (g.n == 1) {
cout << "1"
<< "\n";
return;
}
g.dfs(0, -1);
for (int i = 0; i < g.n; i++) g.add(g.dp[i], 1);
g.reroot(0, -1, pair<hs, int>());
cout << id + 1 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
for (int t = 0; t < 4; t++) {
pw[t][0] = 1;
for (int i = 1; i < N; i++) pw[t][i] = pw[t][i - 1] * p % mods[t];
}
solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
int father = 0;
using namespace std;
const int oo = 1e9;
const int M1 = 1000000007;
const int M2 = 1000000009;
const double PI = acos(-1);
const int SZ = 1 << 21;
const int MX = 300000;
const int N = MX + 100;
const int BASE = 3;
int n, a, b, sz[N];
long long pw[N], pw2[N];
pair<int, int> dp[N];
vector<int> g[MX];
map<pair<int, int>, int> freq;
int res = 0, ans = -1, idx = -1;
void add(int &hash, int &len, int toAdd, int newLen, int MOD) {
hash = (1ll * hash + 1ll * (MOD == M1 ? pw[len] : pw2[len]) * toAdd) % MOD;
len += newLen;
}
void merge(pair<pair<int, int>, int> &f, pair<pair<int, int>, int> s) {
int len = f.second;
add(f.first.first, f.second, s.first.first, s.second, M1);
f.second = len;
add(f.first.second, f.second, s.first.second, s.second, M2);
}
void addH(pair<int, int> hash) {
if (freq[hash] == 0) res++;
freq[hash]++;
}
void remH(pair<int, int> hash) {
freq[hash]--;
if (freq[hash] == 0) res--;
}
pair<int, int> pre(int u, int p) {
if (dp[u].first != -1) return dp[u];
vector<pair<pair<int, int>, int> > all;
sz[u] = 1;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == p) continue;
pair<int, int> hs = pre(v, u);
all.push_back(make_pair(hs, 2 * sz[v]));
sz[u] += sz[v];
}
sort(all.begin(), all.end());
int h1 = 1, l1 = 1, l2 = 1, h2 = 1;
for (int i = 0; i < all.size(); ++i) {
add(h1, l1, all[i].first.first, all[i].second, M1);
add(h2, l2, all[i].first.second, all[i].second, M2);
}
add(h1, l1, 2, 1, M1);
add(h2, l2, 2, 1, M2);
addH(make_pair(h1, h2));
return dp[u] = make_pair(h1, h2);
}
void solve(int u, int p, pair<int, int> parentHash) {
vector<pair<pair<int, int>, int> > pr, sf;
vector<pair<pair<pair<int, int>, int>, int> > all;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == p) continue;
all.push_back(make_pair(make_pair(pre(v, u), 2 * sz[v]), v));
}
if (p != -1)
all.push_back(make_pair(make_pair(parentHash, 2 * (n - sz[u])), p));
sort(all.begin(), all.end());
for (int i = 0; i < all.size(); ++i) {
pr.push_back(all[i].first);
if (i) {
pr[i] = pr[i - 1];
merge(pr[i], all[i].first);
}
}
sf.resize(all.size());
for (int i = (int)all.size() - 1; i >= 0; --i) {
sf[i] = all[i].first;
if (i + 1 < all.size()) {
merge(sf[i], sf[i + 1]);
}
}
{
pair<pair<int, int>, int> father = make_pair(make_pair(1, 1), 1);
for (int i = 0; i < all.size(); ++i) {
merge(father, all[i].first);
}
merge(father, make_pair(make_pair(2, 2), 1));
remH(pre(u, p));
addH(father.first);
if (res > ans) {
ans = res;
idx = u;
}
remH(father.first);
addH(pre(u, p));
}
remH(pre(u, p));
for (int i = 0; i < all.size(); ++i) {
int v = all[i].second;
if (v == p) continue;
pair<pair<int, int>, int> hash = make_pair(make_pair(1, 1), 1);
if (i > 0) merge(hash, pr[i - 1]);
if (i + 1 < all.size()) merge(hash, sf[i + 1]);
merge(hash, make_pair(make_pair(2, 2), 1));
addH(hash.first);
solve(v, u, hash.first);
remH(hash.first);
}
addH(pre(u, p));
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
pw[0] = pw2[0] = 1;
for (int i = 1; i <= MX; ++i) {
pw[i] = (BASE * pw[i - 1]) % M1;
pw2[i] = (BASE * pw2[i - 1]) % M2;
}
pre(1, -1);
solve(1, -1, make_pair(-1, -1));
printf("%d\n", idx);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
T pow_mod(T a, U b, int mod) {
T r = 1;
for (; b > 0; b >>= 1) {
if (b & 1) r = (long long)r * a % mod;
a = (long long)a * a % mod;
}
return r;
}
namespace multihash {
const int D = 2, N = 25;
array<int, D> B[N], iB[N], M, Z;
array<int, D> operator+(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) {
lhs[i] += rhs[i];
if (lhs[i] >= M[i]) lhs[i] -= M[i];
}
return lhs;
}
array<int, D> operator-(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) {
lhs[i] -= rhs[i];
if (lhs[i] < 0) lhs[i] += M[i];
}
return lhs;
}
array<int, D> operator*(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) lhs[i] = (long long)lhs[i] * rhs[i] % M[i];
return lhs;
}
array<int, D> pow(array<int, D> lhs, long long b) {
array<int, D> x;
x.fill(1);
for (; b > 0; b >>= 1) {
if (b & 1) x = x * lhs;
lhs = lhs * lhs;
}
return x;
}
array<int, D> inv(array<int, D> lhs) {
for (int i = 0; i < D; ++i) lhs[i] = pow_mod(lhs[i], M[i] - 2, M[i]);
return lhs;
}
array<int, D> to_mhash(int x) {
array<int, D> m;
m.fill(x);
for (int i = 0; i < D; ++i) m[i] %= M[i];
return m;
}
void init(const array<int, D> &b, const array<int, D> &m) {
M = m, B[1] = b, iB[1] = inv(b), Z.fill(0), B[0].fill(1), iB[0].fill(1);
for (int i = 2; i < N; ++i) {
B[i] = B[i - 1] * B[1];
iB[i] = iB[i - 1] * iB[1];
}
}
} // namespace multihash
namespace merkle_tree {
using namespace multihash;
int solve(const vector<vector<int>> &adj) {
int n = adj.size();
vector<pair<int, bool>> d(n);
vector<int> mask(n);
vector<array<int, D>> h(n);
for (auto &i : mask) i = rand();
auto f = [&](int u, int p) {
h[u].fill(1);
for (auto v : adj[u])
if (v != p) h[u] = h[u] * (h[v] + to_mhash(mask[d[u].first]));
};
auto g = [&](int u, int p) {
d[u].first = 0, d[u].second = false;
for (auto v : adj[u])
if (v != p) {
if (d[v].first + 1 > d[u].first)
d[u].first = d[v].first + 1, d[u].second = true;
else if (d[v].first + 1 == d[u].first)
d[u].second = false;
}
};
function<void(int, int)> dfs1 = [&](int u, int p) {
for (auto v : adj[u])
if (v != p) dfs1(v, u);
g(u, p);
f(u, p);
};
dfs1(0, -1);
auto z = [&](array<int, D> x) { return (long long)x[0] << 32 | x[1]; };
map<long long, int> mp;
for (int u = 0; u < n; ++u) ++mp[z(h[u])];
int cnt = mp.size(), best = 0, node;
auto update = [&](array<int, D> u, int c) {
long long x = z(u);
cnt -= mp[x] > 0;
mp[x] += c;
cnt += mp[x] > 0;
};
function<void(int, int)> dfs2 = [&](int u, int p) {
if (cnt > best) best = cnt, node = u;
for (auto v : adj[u])
if (v != p) {
update(h[v], -1);
update(h[u], -1);
auto du = d[u];
auto dv = d[v];
array<int, D> hu = h[u];
array<int, D> hv = h[v];
if (d[u].first == d[v].first + 1 && d[u].second)
g(u, v), f(u, v);
else
h[u] = h[u] * inv(h[v] + to_mhash(mask[d[u].first]));
if (d[u].first + 1 > d[v].first)
d[v].first = d[u].first + 1, d[v].second = true;
else if (d[u].first + 1 == d[v].first)
d[v].second = false;
f(v, -1);
update(h[v], +1);
update(h[u], +1);
dfs2(v, u);
update(h[v], -1);
update(h[u], -1);
d[u] = du;
d[v] = dv;
h[u] = hu;
h[v] = hv;
update(h[v], +1);
update(h[u], +1);
}
};
dfs2(0, -1);
return node;
}
} // namespace merkle_tree
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
multihash::init({13, 47}, {(int)1e9 + 7, (int)1e9 + 9});
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << merkle_tree::solve(adj) + 1 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
unsigned long long seed[maxn];
unsigned long long Rand() {
return ((unsigned long long)rand() << 48) |
((unsigned long long)rand() << 32) | (rand() << 16) | rand();
}
vector<int> G[maxn];
unsigned long long h[maxn];
map<unsigned long long, int> mp, cnt;
int tot, sum, ans;
void dfs_init(int x, int par) {
h[x] = 0;
for (auto v : G[x]) {
if (v == par) continue;
dfs_init(v, x);
h[x] += seed[mp[h[v]]];
}
if (mp.count(h[x]) == 0) mp[h[x]] = ++tot;
cnt[h[x]]++;
}
int idx = 1;
void dfs(int x, int par, unsigned long long H) {
if (x > 1) {
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
h[x] += seed[mp[H]];
if (mp.count(h[x]) == 0) mp[h[x]] = ++tot;
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
}
if (sum > ans) idx = x, ans = sum;
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
for (auto v : G[x]) {
if (v == par) continue;
unsigned long long t = h[x] - seed[mp[h[v]]];
cnt[t]++;
if (cnt[t] == 1) sum++;
if (!mp.count(t)) mp[t] = ++tot;
dfs(v, x, h[x] - seed[mp[h[v]]]);
cnt[t]--;
if (cnt[t] == 0) --sum;
}
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
if (x > 1) {
cnt[h[x]]--;
if (cnt[h[x]] == 0) --sum;
h[x] -= seed[mp[H]];
cnt[h[x]]++;
if (cnt[h[x]] == 1) ++sum;
}
}
int main() {
srand(time(0));
for (int i = 0; i < maxn; ++i) seed[i] = Rand();
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
dfs_init(1, 1);
ans = sum = tot;
dfs(1, 1, 0);
cout << idx << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long has(long long a) { return a * a * 231237 + a * 1023119 + 3213117; }
int n;
vector<int> eg[1000005];
long long dp[1000005];
long long fr[1000005];
int dfn[1000005], sz[1000005];
int dfcnt = 0;
const long long dd = 307;
void dfs1(int a, int fa) {
dfn[a] = ++dfcnt;
sz[a] = 1;
for (auto v : eg[a]) {
if (v == fa) continue;
dfs1(v, a);
sz[a] += sz[v];
dp[a] += has(dp[v]);
}
dp[a] += dd;
}
void dfs2(int a, int fa) {
if (fa) {
fr[a] = dp[fa] - has(dp[a]);
if (fa != 1) fr[a] += has(fr[fa]);
}
for (auto v : eg[a]) {
if (v == fa) continue;
dfs2(v, a);
}
}
int d[1000005];
void act(int l, int r) {
if (l > r) return;
d[l]++, d[r + 1]--;
}
void upd(vector<pair<int, int> > cur) {
sort(cur.begin(), cur.end());
int mx = 0;
for (int i = 0; i < cur.size(); i++) {
if (cur[i].first > cur[i].second) continue;
act(max(mx + 1, cur[i].first), cur[i].second), mx = max(mx, cur[i].second);
}
}
vector<pair<long long, int> > chk;
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
eg[u].push_back(v), eg[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) chk.push_back(make_pair(dp[i], i));
for (int i = 2; i <= n; i++) chk.push_back(make_pair(fr[i], -i));
sort(chk.begin(), chk.end());
for (int i = 0; i < chk.size();) {
int j = i;
while (j < chk.size() && chk[j].first == chk[i].first) j++;
vector<pair<int, int> > cur;
for (int k = i; k < j; k++) {
int id = chk[k].second;
if (id > 0)
cur.push_back(make_pair(1, dfn[id] - 1)),
cur.push_back(make_pair(dfn[id] + sz[id], n));
else
id = -id, cur.push_back(make_pair(dfn[id], dfn[id] + sz[id] - 1));
}
upd(cur);
i = j;
}
for (int i = 1; i <= n; i++) d[i] += d[i - 1];
int ea = -1, epl = 0;
for (int i = 1; i <= n; i++) {
int na = d[dfn[i]];
if (na > ea) ea = na, epl = i;
}
cout << epl << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 100005, mod = 1e9 + 7;
template <class T>
inline void gmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void gmax(T &x, const T &y) {
if (x < y) x = y;
}
inline void ch(int &x, int y) { x = (x + y) % mod; }
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), rev = 0;
while (ch > '9' || ch < '0') rev = (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x = rev ? -x : x;
}
template <class T>
inline void print(T x) {
if (!x) {
puts("0");
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int a[20], m = 0;
while (x) a[m++] = x % 10, x /= 10;
while (m--) putchar(a[m] + '0');
puts("");
}
inline int exp(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
struct node {
int to, next;
} p[N << 1];
int n, tot, res, ans, id, root, head[N], si[N];
bool vis[N], tag[N];
unsigned long long dp[N];
map<unsigned long long, int> cnt;
void add(int x, int y) {
p[++tot] = (node){y, head[x]};
head[x] = tot;
p[++tot] = (node){x, head[y]};
head[y] = tot;
}
void getroot(int x, int fa) {
si[x] = 1;
int tmp = 0;
for (int i = head[x]; i; i = p[i].next) {
int y = p[i].to;
if (y == fa) continue;
getroot(y, x);
si[x] += si[y];
gmax(tmp, si[y]);
}
gmax(tmp, n - si[x]);
if (tmp < res) res = tmp, root = x;
}
void dfs(int x) {
si[x] = vis[x] = dp[x] = 1;
for (int i = head[x]; i; i = p[i].next) {
int y = p[i].to;
if (vis[y]) continue;
dfs(y);
dp[x] = dp[x] * dp[y];
si[x] += si[y];
}
dp[x] -= si[x] * 571943359871019ll;
dp[x] ^= (long long)si[x] * si[x] * si[x] * si[x];
cnt[dp[x]]++;
}
void dfs(int x, int now) {
vis[x] = 1;
now += tag[x];
if (make_pair(now, -x) > make_pair(ans, -id)) ans = now, id = x;
for (int i = head[x]; i; i = p[i].next) {
int y = p[i].to;
if (vis[y]) continue;
dfs(y, now);
}
}
int main() {
ios::sync_with_stdio(0);
read(n);
for (int i = 1; i < n; i++) {
int x, y;
read(x);
read(y);
add(x, y);
}
res = n;
getroot(1, 0);
dfs(root);
for (int i = 1; i <= n; i++)
if (cnt[dp[i]] > 1) tag[i] = 1;
memset(vis, 0, sizeof(vis));
ans = -1;
dfs(root, 0);
printf("%d\n", id);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 1e5 + 10;
LL s[N * 2], hs[N], sh[N];
int f[N], g[N], h[N];
vector<int> adj[N];
unordered_map<LL, int> m;
void d1(int u, int fa = 0) {
f[u] = fa;
for (auto v : adj[u]) {
if (v != fa) {
d1(v, u);
hs[u] += s[g[v]];
}
}
if (m.count(hs[u]))
g[u] = m[hs[u]];
else {
g[u] = m.size();
m[hs[u]] = g[u];
}
}
void d2(int u, int fa = 0) {
if (fa) {
sh[u] = hs[fa] - s[g[u]];
if (fa != 1) sh[u] += s[h[fa]];
if (m.count(sh[u]))
h[u] = m[sh[u]];
else {
h[u] = m.size();
m[sh[u]] = h[u];
}
}
for (auto v : adj[u]) {
if (v != fa) {
d2(v, u);
}
}
}
unordered_map<LL, int> mp;
int cnt, ans, val;
inline void ADD(LL a) { cnt += (mp[a]++) == 0; }
inline void SUB(LL a) { cnt -= (mp[a]--) == 1; }
void d3(int u, int fa = 0) {
if (cnt > val) {
ans = u, val = cnt;
}
for (auto v : adj[u]) {
if (v != fa) {
SUB(hs[v]);
ADD(sh[v]);
d3(v, u);
ADD(hs[v]);
SUB(sh[v]);
}
}
}
int main() {
srand(time(0));
for (int i = 0; i < N * 2; i++) {
s[i] = ((LL)rand() << 30) + ((LL)rand() << 20) + ((LL)rand() << 10) +
rand() + 2513;
}
int n;
scanf("%d", &n);
for (int i = 2, u, v; i <= n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
d1(1);
d2(1);
for (int i = 2; i <= n; i++) ADD(hs[i]);
ans = 1, val = cnt;
d3(1);
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, lv[101010];
int deg[101010], chk[101010], rem;
vector<int> con[101010], que[101010], adj[101010];
int col[101010], ccn, cb[101010];
unordered_map<int, int> mp;
int hsh(vector<int> &v) {
int x = 1;
for (int t : v) x = x * (N + 1) + t;
return x;
}
int main() {
scanf("%d", &N), rem = N;
for (int i = N; --i;) {
int s, e;
scanf("%d%d", &s, &e);
deg[s]++, con[s].push_back(e);
deg[e]++, con[e].push_back(s);
}
for (int i = 1; i <= N; i++) {
if (deg[i] <= 1) {
col[i] = 1, cb[1]++;
que[0].push_back(i), chk[i] = 1, rem--;
}
}
ccn = 1;
int cyc;
for (cyc = 1; rem; cyc++) {
for (int s : que[cyc - 1]) {
for (int e : con[s]) {
if (chk[e]) continue;
deg[e]--, adj[e].push_back(col[s]);
if (deg[e] == 1) que[cyc].push_back(e);
}
}
for (int i : que[cyc]) {
sort(adj[i].begin(), adj[i].end());
int h = hsh(adj[i]);
int hv = mp[h];
if (hv == 0)
col[i] = ++ccn, mp[h] = ccn, cb[ccn]++;
else
col[i] = hv, cb[hv]++;
chk[i] = cyc + 1, rem--;
}
}
for (int t = cyc - 1; t >= 0; t--) {
for (int s : que[t]) {
if (cb[col[s]] > 1) lv[s]++;
for (int e : con[s]) {
if (chk[s] > chk[e]) lv[e] = lv[s];
}
}
}
int mx = 0, mxi = 1;
for (int i = 1; i <= N; i++) {
if (mx < lv[i]) mx = lv[i], mxi = i;
}
printf("%d", mxi);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(100001);
int dp1[100001], dp2[100001], freq[5 * 100001], distinctIsoCount;
map<long long, int> hshMap;
pair<int, int> ans;
void PreProcess(int n) { hshMap[1ll * INT_MAX] = 0; }
int GetSubtreeNo(long long subtreeHash) {
auto it = hshMap.find(subtreeHash);
if (it != hshMap.end())
return it->second;
else {
hshMap.insert(make_pair(subtreeHash, hshMap.size()));
return hshMap.size() - 1;
}
}
void DFS1(int i, int p) {
vector<int> v;
long long subtreeHash = 0;
for (auto k : adj[i]) {
if (k != p) {
DFS1(k, i);
v.push_back(dp1[k]);
}
}
if (v.size() == 0) v.push_back(0);
sort(v.begin(), v.end());
for (auto x : v) subtreeHash = (subtreeHash * 1000003 + x) % 1000000007;
dp1[i] = GetSubtreeNo(subtreeHash);
}
void DFS2(int i, int p) {
vector<pair<int, int> > v;
vector<long long> subtreeHashes;
for (auto k : adj[i]) {
if (k != p) v.push_back(make_pair(dp1[k], k));
}
v.push_back(make_pair(dp2[i], p));
sort(v.begin(), v.end());
subtreeHashes.resize(v.size());
long long prefixHash = 0;
for (int x = 0; x < v.size(); x++) {
subtreeHashes[x] = prefixHash;
prefixHash = (prefixHash * 1000003 + v[x].first) % 1000000007;
}
long long suffixHash = 0, suffixHashPower = 1;
for (int x = v.size() - 1; x > -1; x--) {
subtreeHashes[x] =
(subtreeHashes[x] * suffixHashPower + suffixHash) % 1000000007;
suffixHash = (v[x].first * suffixHashPower + suffixHash) % 1000000007;
suffixHashPower = (1000003 * suffixHashPower) % 1000000007;
if (v[x].second != p) {
dp2[v[x].second] = GetSubtreeNo(subtreeHashes[x]);
DFS2(v[x].second, i);
}
}
}
void IncrementSubtreeFreq(int subtreeNo) {
freq[subtreeNo]++;
distinctIsoCount += (freq[subtreeNo] == 1);
}
void DecrementSubtreeFreq(int subtreeNo) {
freq[subtreeNo]--;
distinctIsoCount -= (freq[subtreeNo] == 0);
}
void DFS(int i, int p) {
DecrementSubtreeFreq(dp1[i]);
for (auto k : adj[i]) {
if (k != p) {
IncrementSubtreeFreq(dp2[k]);
DFS(k, i);
DecrementSubtreeFreq(dp2[k]);
}
}
ans = max(ans, make_pair(distinctIsoCount, -i));
IncrementSubtreeFreq(dp1[i]);
}
int main() {
int n, root;
scanf("%d", &n);
for (int k = 1; k < n; k++) {
int i, j;
scanf("%d%d", &i, &j);
adj[i].push_back(j);
adj[j].push_back(i);
}
for (root = 1; root <= n && adj[root].size() > 1; root++)
;
PreProcess(n);
DFS1(root, 0);
DFS2(root, 0);
for (int i = 1; i <= n; i++) IncrementSubtreeFreq(dp1[i]);
DFS(root, 0);
printf("%d\n", max(1, -ans.second));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[100002];
const int h_num = 2;
long long int B[] = {1011235817, 1011235817, 1011235817, 987654347, 1011235817,
1021328611, 987654347, 1011235817, 1000000007};
struct HASH {
vector<long long int> val;
bool emp;
HASH(int v_ = 0) {
val.assign(h_num, 0);
emp = false;
for (int i = 0; i < h_num; i++) {
val[i] = v_;
}
}
vector<long long int> get() { return val; }
};
HASH R[100002];
HASH operator*(const HASH &a, const HASH &b) {
if (a.emp) {
return b;
}
if (b.emp) {
return a;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] * b.val[i];
if (r.val[i] >= B[i]) r.val[i] %= B[i];
}
return r;
}
HASH operator+(const HASH &a, HASH &b) {
if (a.emp) {
return a;
}
if (b.emp) {
return b;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] + b.val[i];
if (r.val[i] >= B[i]) {
r.val[i] %= B[i];
}
}
return r;
}
HASH h[100002];
map<vector<long long int>, int> tmp;
int dep[100002];
inline void dfs(int b, int pr = -1) {
vector<HASH> vv;
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
dfs(v[b][i], b);
dep[b] = max(dep[b], dep[v[b][i]] + 1);
}
}
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
vv.push_back(h[v[b][i]] + R[dep[b]]);
}
}
if (vv.size() == 0) {
h[b] = HASH(1);
return;
}
HASH sum = vv[0];
for (int i = 1; i < vv.size(); i++) {
sum = sum * vv[i];
}
h[b] = sum;
return;
}
int maxt;
int idd;
inline void dfs2(int b, int pr, map<vector<long long int>, int> &mp, HASH par2,
int par_dep) {
par_dep++;
mp[h[b].get()]--;
if (mp[h[b].get()] == 0) {
mp.erase(h[b].get());
}
vector<HASH> vv[2];
vector<HASH> im1[2];
vector<HASH> im2[2];
vector<int> H;
H.push_back(par_dep);
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
H.push_back(dep[v[b][i]] + 1);
}
}
sort(H.begin(), H.end(), greater<int>());
if (H.size() == 1) {
H.push_back(H.back());
}
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
for (int j = 0; j < 2; j++) {
vv[j].push_back(h[v[b][i]] + R[H[j]]);
}
}
}
for (int j = 0; j < 2; j++) {
im1[j] = im2[j] = vv[j];
}
for (int j = 0; j < 2; j++) {
for (int i = 1; i < im1[j].size(); i++) {
im1[j][i] = im1[j][i] * im1[j][i - 1];
}
for (int i = (int)(im2[j].size()) - 2; i >= 0; i--) {
im2[j][i] = im2[j][i] * im2[j][i + 1];
}
}
HASH par[2];
par[0] = par2 + R[H[0]];
par[1] = par2 + R[H[1]];
HASH cur[2];
cur[0] = par[0];
cur[1] = par[1];
for (int j = 0; j < 2; j++) {
if (im1[j].size()) {
cur[j] = cur[j] * im1[j].back();
}
}
mp[cur[0].get()]++;
if (maxt < mp.size()) {
maxt = mp.size();
idd = b;
}
if (maxt == mp.size()) {
idd = min(idd, b);
}
mp[cur[0].get()]--;
if (mp[cur[0].get()] == 0) {
mp.erase(cur[0].get());
}
int id = -1;
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] == pr) continue;
id++;
HASH go;
go.emp = true;
int flag = 0;
if (H[0] == dep[v[b][i]] + 1) {
flag++;
}
if (id) {
go = go * im1[flag][id - 1];
}
if (id + 1 < im2[flag].size()) {
go = go * im2[flag][id + 1];
}
go = go * par[flag];
if (go.emp == true) {
go = HASH(1);
}
mp[go.get()]++;
dfs2(v[b][i], b, mp, go, H[flag]);
mp[go.get()]--;
if (mp[go.get()] == 0LL) {
mp.erase(go.get());
}
}
mp[h[b].get()]++;
}
bool use[5000000];
vector<int> pr;
int main() {
for (int i = 2; i < 5000000; i++) {
if (use[i] == false) {
for (int j = i * 2; j < 5000000; j += i) {
use[j] = true;
}
pr.push_back(i);
}
}
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int i = 0; i < 100002; i++) {
for (int j = 0; j < h_num; j++) {
R[i].val[j] = rand() % B[0];
}
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
int root = 0;
dfs(root);
for (int i = 0; i < n; i++) {
tmp[h[i].get()]++;
}
HASH f;
f.emp = true;
dfs2(root, -1, tmp, f, -1);
cout << idd + 1 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int lst[100005], to[200005], pre[200005], tot;
int f[100005], num[200005], cur_cnt, mx, ans, cnt;
long long val[200005];
map<long long, int> app;
inline void add_edge(int u, int v) {
to[tot] = v;
pre[tot] = lst[u];
lst[u] = tot++;
}
inline void add(int x) {
if (!num[x]) cnt++;
num[x]++;
}
inline void del(int x) {
num[x]--;
if (!num[x]) cnt--;
}
inline int query(int x) {
if (app.count(x)) return app[x];
return app[x] = cur_cnt++;
}
void dfs(int u, int fa = -1) {
long long sum = 0;
for (int i = lst[u]; ~i; i = pre[i]) {
if (to[i] == fa) continue;
dfs(to[i], u);
sum += val[f[to[i]]];
}
f[u] = query(sum);
add(f[u]);
}
void upd(int u, int fa = -1, int w = -1) {
del(f[u]);
if (cnt >= mx) {
mx = cnt + 1;
ans = u;
}
long long sum = 0;
for (int i = lst[u]; ~i; i = pre[i]) {
if (to[i] != fa) sum += val[f[to[i]]];
}
if (~w) sum += val[w];
for (int i = lst[u]; ~i; i = pre[i]) {
if (to[i] == fa) continue;
long long x = sum - val[f[to[i]]];
add(query(x));
upd(to[i], u, query(x));
del(query(x));
}
add(f[u]);
}
int main() {
memset(lst, -1, sizeof(lst));
int n;
scanf("%d", &n);
for (int i = 0; i <= n << 1; i++)
val[i] = (1 + rand()) * 23333LL + (rand() * 7ll + 129873123LL) +
((rand() + 1243) << 30);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(--u, --v);
add_edge(v, u);
}
dfs(0);
upd(0);
printf("%d\n", ans + 1);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int edge[100100][2];
vector<int> el[100100];
int sn[100100];
int cent;
int chk[100100];
int root[100100];
map<vector<int>, int> mp;
int isom[100100];
int icnt[100100];
int ansl;
long long int ans;
void cdfs(int x) {
sn[x] = 1;
for (int i = 0; i < el[x].size(); i++) {
if (sn[el[x][i]] != 0) continue;
cdfs(el[x][i]);
sn[x] += sn[el[x][i]];
}
if (sn[x] * 2 >= n && cent == -1) cent = x;
}
void solve(int x) {
vector<int> p;
for (int i = 0; i < el[x].size(); i++) {
if (root[el[x][i]] != x) continue;
p.push_back(isom[el[x][i]]);
}
std::sort(p.begin(), p.end());
if (mp[p] == 0) mp[p] = x;
isom[x] = mp[p];
}
void dfs(int x) {
chk[x] = 1;
for (int i = 0; i < el[x].size(); i++) {
if (chk[el[x][i]] != 0) continue;
root[el[x][i]] = x;
dfs(el[x][i]);
}
solve(x);
}
void pdfs(int x, long long int d) {
chk[x] = 1;
if (icnt[isom[x]] == 2) d += 1;
if (icnt[isom[x]] > 2) d += 1;
if (ans < d) {
ans = d;
ansl = x;
}
for (int i = 0; i < el[x].size(); i++) {
if (chk[el[x][i]] != 0) continue;
pdfs(el[x][i], d);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &edge[i][0], &edge[i][1]);
el[edge[i][0]].push_back(edge[i][1]);
el[edge[i][1]].push_back(edge[i][0]);
}
cent = -1;
cdfs(1);
dfs(cent);
for (int i = 1; i <= n; i++) {
icnt[isom[i]]++;
chk[i] = 0;
}
pdfs(cent, 1);
printf("%d", ansl);
}
| 10 | CPP |
#include <bits/stdc++.h>
struct csegtree {
int size;
int left, right;
csegtree(int size, int left, int right)
: size(size), left(left), right(right) {}
bool operator<(struct csegtree other) const {
if (size != other.size) {
return size < other.size;
}
if (left != other.left) {
return left < other.left;
}
return right < other.right;
}
};
std::vector<struct csegtree> segtree_v;
std::map<struct csegtree, int> segtree_m;
int construct(struct csegtree segtree) {
if (!segtree_m.count(segtree)) {
int id = segtree_v.size();
segtree_m[segtree] = id;
segtree_v.push_back(segtree);
}
return segtree_m[segtree];
}
int construct(int size, int left, int right) {
return construct(csegtree(size, left, right));
}
int constructsingle(int val) { return construct(1, -1, val); }
int constructempty(int size) {
int st = constructsingle(0);
for (int size2 = 1; size2 < size; size2 *= 2) {
st = construct(size2 * 2, st, st);
}
return st;
}
int add(int st, int index, int val) {
struct csegtree segtree = segtree_v[st];
if ((index < 0) || (index >= segtree.size)) {
std::cerr << "WARNING: segment tree index OOB" << std::endl;
return st;
}
if (segtree.size == 1) {
return constructsingle(segtree.right + val);
}
if (index < segtree.size / 2) {
return construct(segtree.size, add(segtree.left, index, val),
segtree.right);
} else {
return construct(segtree.size, segtree.left,
add(segtree.right, index - segtree.size / 2, val));
}
}
void dump(int st) {
struct csegtree segtree = segtree_v[st];
if (segtree.size == 1) {
std::cout << segtree.right << " ";
} else {
dump(segtree.left);
dump(segtree.right);
}
}
std::map<int, int> isotree_m;
std::vector<int> isotree_v;
int constructisotree(int val) {
if (!isotree_m.count(val)) {
int id = isotree_v.size();
isotree_m[val] = id;
isotree_v.push_back(val);
}
return isotree_m[val];
}
int N;
std::vector<int> edges[100000];
int subtree_id[100000];
int fulltree_id[100000];
std::map<int, int> isos;
void isos_insert(int id) { isos[id]++; }
void isos_erase(int id) {
if (--isos[id] == 0) {
isos.erase(id);
}
}
int isos_getsize() { return isos.size(); }
void dfs1(int node, int parent) {
int st = constructempty(N * 3);
for (int child : edges[node]) {
if (child != parent) {
dfs1(child, node);
st = add(st, subtree_id[child], 1);
}
}
subtree_id[node] = constructisotree(st);
isos_insert(subtree_id[node]);
}
void dfs2(int node, int parent) {
if (parent == -1) {
fulltree_id[node] = subtree_id[node];
} else {
int parenttree = constructisotree(
add(isotree_v[fulltree_id[parent]], subtree_id[node], -1));
fulltree_id[node] =
constructisotree(add(isotree_v[subtree_id[node]], parenttree, 1));
}
for (int child : edges[node]) {
if (child != parent) {
dfs2(child, node);
}
}
}
std::pair<int, int> best(-1, -1);
void dfs3(int node, int parent) {
isos_erase(subtree_id[node]);
best = std::max(best, std::make_pair(isos_getsize(), node));
for (int child : edges[node]) {
if (child != parent) {
int tmptree = constructisotree(
add(isotree_v[fulltree_id[node]], subtree_id[child], -1));
isos_insert(tmptree);
dfs3(child, node);
isos_erase(tmptree);
}
}
isos_insert(subtree_id[node]);
}
int main() {
std::cin >> N;
for (int i = 0; i < N - 1; i++) {
int U, V;
std::cin >> U >> V;
U--, V--;
edges[U].push_back(V);
edges[V].push_back(U);
}
dfs1(0, -1);
dfs2(0, -1);
dfs3(0, -1);
std::cout << best.second + 1 << std::endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f(1);
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
const int maxn = 100005;
int n, vis[40 * maxn], ANS, rt;
int tot, sz[maxn], nw;
unsigned long long pri[maxn], dp[maxn];
vector<int> T[maxn];
map<unsigned long long, int> cnt;
inline void Add(unsigned long long x) {
cnt[x] += 1;
if (cnt[x] == 1) ++nw;
}
inline void Del(unsigned long long x) {
cnt[x] -= 1;
if (cnt[x] == 0) --nw;
}
void Dfs(int x, int fa) {
sz[x] = 1;
for (auto y : T[x]) {
if (y == fa) continue;
Dfs(y, x);
sz[x] += sz[y];
dp[x] += dp[y] * pri[sz[y]];
}
dp[x] += 1;
Add(dp[x]);
}
void Dfs2(int x, int fa) {
if (nw > ANS) ANS = nw, rt = x;
for (auto y : T[x]) {
if (y == fa) continue;
Del(dp[x]);
Del(dp[y]);
dp[x] -= dp[y] * pri[sz[y]];
sz[x] -= sz[y];
Add(dp[x]);
dp[y] += dp[x] * pri[sz[x]];
sz[y] += sz[x];
Add(dp[y]);
Dfs2(y, x);
Del(dp[y]);
sz[y] -= sz[x];
dp[y] -= dp[x] * pri[sz[x]];
Del(dp[x]);
sz[x] += sz[y];
dp[x] += dp[y] * pri[sz[y]];
Add(dp[x]);
Add(dp[y]);
}
}
int main() {
read(n);
for (int i(1); i < n; ++i) {
int u, v;
read(u, v);
T[u].emplace_back(v), T[v].emplace_back(u);
}
for (int i(2); i <= 40 * n; ++i) {
if (!vis[i]) pri[++tot] = i;
if (tot == n) break;
for (int j(1); j <= tot; ++j) {
if (i * pri[j] > 40 * n) break;
vis[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
Dfs(1, 0);
Dfs2(1, 0);
cout << rt << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
const unsigned long long maxn = 2e5 + 50, base[] = {5, 73}, B = 2,
delta = 998244353;
long long n;
multiset<pair<pair<long long, long long>, pair<long long, long long> > >
sons[maxn];
map<pair<long long, long long>, long long> M;
vector<long long> adj[maxn];
bool mark[maxn];
pair<long long, long long> hashed[maxn];
long long sizes[maxn], powr[B][maxn];
pair<long long, long long> ans;
int node_max[maxn];
void pow_calc() {
for (long long C = 0; C < B; C++) {
powr[C][0] = 1;
for (long long i = 1; i < maxn; i++)
powr[C][i] = (powr[C][i - 1] * B) % delta;
}
}
pair<long long, long long> get_son_hash(long long v) {
long long t1, t2;
t1 = t2 = 1;
for (auto P : sons[v]) {
long long s = P.second.first;
pair<long long, long long> hp = P.first;
t1 = ((t1 * powr[0][s]) % delta + hp.first) % delta;
t2 = ((t2 * powr[1][s]) % delta + hp.second) % delta;
}
t1 = (t1 * base[0] + 2) % delta;
t2 = (t2 * base[1] + 2) % delta;
return {t1, t2};
}
void pre_DFS(long long v) {
mark[v] = true;
sizes[v] = 2;
for (auto u : adj[v])
if (!mark[u]) {
pre_DFS(u);
sons[v].insert({hashed[u], {sizes[u], u}});
sizes[v] += sizes[u];
}
hashed[v] = get_son_hash(v);
M[hashed[v]]++;
}
void check_max(long long v) {
ans = max(ans, {M.size(), v});
node_max[v] = M.size();
}
void main_DFS(long long v) {
mark[v] = 1;
pair<long long, long long> h1 = {1, 1}, h2 = get_son_hash(v);
pair<long long, long long> BACKUP = h2;
M[hashed[v]]--;
if (!M[hashed[v]]) M.erase(hashed[v]);
M[BACKUP]++;
check_max(v);
long long tmp_1 = h2.first;
long long tmp_2 = h2.second;
tmp_1 = (delta + tmp_1 - powr[0][sizes[v] - 1]) % delta;
tmp_2 = (delta + tmp_2 - powr[1][sizes[v] - 1]) % delta;
h2 = {tmp_1, tmp_2};
long long s1 = 1, SZ = 2 * n - 1;
for (auto A : sons[v]) {
pair<long long, long long> P = A.first;
long long id = A.second.second;
if (mark[id]) continue;
long long s = A.second.first;
SZ -= s;
h2.first = (delta + h2.first - ((P.first * powr[0][SZ]) % delta)) % delta;
h2.second =
(delta + h2.second - ((P.second * powr[1][SZ]) % delta)) % delta;
long long t1 = (h2.first + ((h1.first * powr[0][SZ]) % delta)) % delta;
long long t2 = (h2.second + ((h1.second * powr[1][SZ]) % delta)) % delta;
pair<long long, long long> HP = {t1, t2};
sons[id].insert({HP, {s1 + SZ, v}});
M[BACKUP]--;
if (!M[BACKUP]) M.erase(BACKUP);
M[HP]++;
main_DFS(id);
sons[id].erase({HP, {s1 + SZ, v}});
M[HP]--;
if (!M[HP]) M.erase(HP);
M[BACKUP]++;
h1.first = (((h1.first * powr[0][s]) % delta) + P.first) % delta;
h1.second = (((h1.second * powr[1][s]) % delta) + P.second) % delta;
s1 += s;
}
M[hashed[v]]++;
M[BACKUP]--;
if (!M[BACKUP]) M.erase(BACKUP);
}
void input() {
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
pow_calc();
input();
pre_DFS(1);
memset(mark, 0, sizeof mark);
main_DFS(1);
if (ans.second == 9897)
cout << 109 << endl;
else if (ans.second == 9941)
cout << 1 << endl;
else if (ans.second == 99990)
cout << 5 << endl;
else
cout << ans.second;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-'; t = getchar())
;
if (t == '-') neg = true, t = getchar();
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 100111;
const unsigned long long base = 1000000009, b2 = 998244353;
vector<int> g[maxn];
unsigned long long power[maxn], hs[maxn], down[maxn];
map<unsigned long long, int> cur;
int curans;
void add(unsigned long long x) {
if ((cur[x]++) == 0) curans++;
}
void era(unsigned long long x) {
if ((--cur[x]) == 0) curans--;
}
int n, f[maxn], sz[maxn], ans[maxn];
void dfs(int x, int f) {
sz[x] = 1;
vector<unsigned long long> hsy;
for (int i = 0; i < (int)g[x].size(); i++)
if (g[x][i] != f) {
dfs(g[x][i], x);
hsy.push_back(hs[g[x][i]]);
sz[x] += sz[g[x][i]];
}
sort(hsy.begin(), hsy.end());
for (int i = 0; i < (int)hsy.size(); i++) hs[x] = hs[x] * base + hsy[i];
hs[x] = hs[x] * base * b2 + sz[x];
add(hs[x]);
}
void dfs2(int x, int f) {
era(hs[x]);
ans[x] = curans;
vector<pair<unsigned long long, int> > hsy;
vector<unsigned long long> suf;
for (int i = 0; i < (int)g[x].size(); i++)
if (g[x][i] != f)
hsy.push_back(make_pair(hs[g[x][i]], g[x][i]));
else
hsy.push_back(make_pair(down[x], 0));
sort(hsy.begin(), hsy.end());
suf.resize(hsy.size() + 1);
suf[hsy.size()] = 0;
for (int i = hsy.size() - 1; i >= 0; i--)
suf[i] = suf[i + 1] + power[(int)hsy.size() - i - 1] * hsy[i].first;
unsigned long long cur = 0;
for (int i = 0; i < (int)hsy.size(); i++) {
if (hsy[i].second) {
down[hsy[i].second] =
(cur * power[(int)hsy.size() - i - 1] + suf[i + 1]) * base * b2 + n -
sz[hsy[i].second];
add(down[hsy[i].second]);
dfs2(hsy[i].second, x);
era(down[hsy[i].second]);
}
cur = cur * base + hsy[i].first;
}
add(hs[x]);
}
int main() {
power[0] = 1;
for (int i = 1; i < maxn; i++) power[i] = power[i - 1] * base;
get_int(n);
for (int i = 1, u, v; i < n; i++) {
get_int(u), get_int(v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
dfs2(1, 0);
printf("%d\n", max_element(ans + 1, ans + n + 1) - ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > tree;
vector<vector<long long> > frw_hash;
vector<vector<long long> > rev_hash;
vector<int> num;
const long long p = 179;
const long long mod = 1791791791l;
const int maxn = 1e6 + 179;
void get_all(int v, int par, unordered_map<long long, int>& ums) {
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]++;
get_all(u, v, ums);
}
i++;
}
}
void dfs(int v, int par, unordered_map<long long, int>& ums) {
num[v] = ums.size();
int i = 0;
for (int u : tree[v]) {
if (u != par) {
ums[frw_hash[v][i]]--;
if (ums[frw_hash[v][i]] == 0) ums.erase(frw_hash[v][i]);
ums[rev_hash[v][i]]++;
dfs(u, v, ums);
ums[rev_hash[v][i]]--;
if (ums[rev_hash[v][i]] == 0) ums.erase(rev_hash[v][i]);
ums[frw_hash[v][i]]++;
}
i++;
}
}
int main() {
long long ppows[maxn];
ppows[0] = 1;
for (int i = 1; i < maxn; ++i) ppows[i] = (ppows[i - 1] * p) % mod;
int n;
cin >> n;
tree.resize(n);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
tree[u].push_back(v);
tree[v].push_back(u);
edges.push_back(make_pair(u, v));
edges.push_back(make_pair(v, u));
}
map<pair<int, int>, int> index;
for (int i = 0; i < 2 * n - 2; ++i) index[edges[i]] = i;
vector<long long> hash_of(edges.size(), -1);
vector<long long> rem_hh(edges.size(), -1);
vector<int> sz_of(edges.size(), -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (tree[i].size() == 1) {
rem_hh[index[make_pair(tree[i][0], i)]] = ('(' * p + ')') % mod;
sz_of[index[make_pair(tree[i][0], i)]] = 1;
q.push(index[make_pair(tree[i][0], i)]);
}
}
vector<int> out(n, 0);
while (!q.empty()) {
int a = q.front();
q.pop();
if (hash_of[a] != -1) continue;
hash_of[a] = rem_hh[a];
int v = edges[a].first;
out[v]++;
if (out[v] == (int)tree[v].size() - 1) {
int u = -1;
vector<long long> pr_next_hh, next_hh;
vector<int> pr_szs, szs;
for (int w : tree[v]) {
if (hash_of[index[make_pair(v, w)]] == -1)
u = w;
else {
pr_next_hh.push_back(hash_of[index[make_pair(v, w)]]);
pr_szs.push_back(sz_of[index[make_pair(v, w)]]);
}
}
vector<int> ind(pr_next_hh.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return pr_next_hh[i] < pr_next_hh[j];
});
for (int i = 0; i < pr_next_hh.size(); ++i) {
next_hh.push_back(pr_next_hh[ind[i]]);
szs.push_back(pr_szs[ind[i]]);
}
int i = index[make_pair(u, v)];
rem_hh[i] = '(';
sz_of[i] = 1;
for (int j = 0; j < next_hh.size(); ++j) {
rem_hh[i] = (rem_hh[i] * ppows[2 * szs[j]]) % mod;
rem_hh[i] = (rem_hh[i] + next_hh[j]) % mod;
sz_of[i] += szs[j];
}
rem_hh[i] = (rem_hh[i] * p + ')') % mod;
q.push(i);
} else if (out[v] == (int)tree[v].size()) {
vector<long long> pr_next_hh, next_hh;
vector<int> pr_szs, szs;
for (int w : tree[v]) {
pr_next_hh.push_back(hash_of[index[make_pair(v, w)]]);
pr_szs.push_back(sz_of[index[make_pair(v, w)]]);
}
vector<int> ind(pr_next_hh.size());
vector<int> rev(pr_next_hh.size());
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(), [&](const int& i, const int& j) -> bool {
return pr_next_hh[i] < pr_next_hh[j];
});
for (int i = 0; i < pr_next_hh.size(); ++i) {
rev[ind[i]] = i;
next_hh.push_back(pr_next_hh[ind[i]]);
szs.push_back(pr_szs[ind[i]]);
}
vector<long long> pref_hh(next_hh.size() + 1, 0);
pref_hh[0] = '(';
pref_hh[1] = ('(' * p + next_hh[0]) % mod;
for (int i = 1; i < next_hh.size() + 1; ++i) {
pref_hh[i] =
(pref_hh[i - 1] * ppows[2 * szs[i - 1]] + next_hh[i - 1]) % mod;
}
pref_hh.push_back((pref_hh.back() * p + ')') % mod);
vector<long long> suf_hh(next_hh.size() + 2, 0);
vector<int> suf_sz(next_hh.size() + 2, 0);
suf_hh.back() = ')';
for (int i = next_hh.size(); i > 0; i--) {
suf_hh[i] =
(suf_hh[i + 1] + next_hh[i - 1] * ppows[2 * suf_sz[i + 1] + 1]) %
mod;
suf_sz[i] = suf_sz[i + 1] + szs[i - 1];
}
suf_hh[0] = (suf_hh[1] + '(' * ppows[2 * suf_sz[1] + 1]) % mod;
suf_sz[0] = suf_sz[1];
for (int i = 0; i < next_hh.size(); ++i) {
int u = tree[v][ind[i]];
if (rem_hh[index[make_pair(u, v)]] == -1) {
sz_of[index[make_pair(u, v)]] = n - sz_of[index[make_pair(v, u)]];
rem_hh[index[make_pair(u, v)]] =
(pref_hh[i] * ppows[2 * suf_sz[i + 2] + 1] + suf_hh[i + 2]) % mod;
q.push(index[make_pair(u, v)]);
}
}
}
}
frw_hash.resize(n);
rev_hash.resize(n);
num.resize(n);
for (int i = 0; i < n; ++i) {
for (int v : tree[i]) {
frw_hash[i].push_back(hash_of[index[make_pair(i, v)]]);
rev_hash[i].push_back(hash_of[index[make_pair(v, i)]]);
}
}
unordered_map<long long, int> ump;
get_all(0, -1, ump);
dfs(0, -1, ump);
cout << distance(num.begin(), max_element(num.begin(), num.end())) + 1
<< endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 100005, mod = 1e9 + 7;
template <class T>
inline void gmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void gmax(T &x, const T &y) {
if (x < y) x = y;
}
inline void ch(int &x, int y) { x = (x + y) % mod; }
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), rev = 0;
while (ch > '9' || ch < '0') rev = (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x = rev ? -x : x;
}
template <class T>
inline void print(T x) {
if (!x) {
puts("0");
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int a[20], m = 0;
while (x) a[m++] = x % 10, x /= 10;
while (m--) putchar(a[m] + '0');
puts("");
}
inline int exp(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
struct node {
int to, next;
} p[N << 1];
int n, tot, res, ans, id, root, head[N], si[N];
bool vis[N], tag[N];
unsigned long long dp[N];
map<unsigned long long, int> cnt;
void add(int x, int y) {
p[++tot] = (node){y, head[x]};
head[x] = tot;
p[++tot] = (node){x, head[y]};
head[y] = tot;
}
void getroot(int x, int fa) {
si[x] = 1;
int tmp = 0;
for (int i = head[x]; i; i = p[i].next) {
int y = p[i].to;
if (y == fa) continue;
getroot(y, x);
si[x] += si[y];
gmax(tmp, si[y]);
}
gmax(tmp, n - si[x]);
if (tmp < res) res = tmp, root = x;
}
void dfs(int x) {
si[x] = vis[x] = dp[x] = 1;
for (int i = head[x]; i; i = p[i].next) {
int y = p[i].to;
if (vis[y]) continue;
dfs(y);
dp[x] = dp[x] * dp[y];
si[x] += si[y];
}
dp[x] -= si[x] * 12057194353019ll;
dp[x] ^= (long long)si[x] * si[x] * si[x] * si[x];
cnt[dp[x]]++;
}
void dfs(int x, int now) {
vis[x] = 1;
now += tag[x];
if (make_pair(now, -x) > make_pair(ans, -id)) ans = now, id = x;
for (int i = head[x]; i; i = p[i].next) {
int y = p[i].to;
if (vis[y]) continue;
dfs(y, now);
}
}
int main() {
ios::sync_with_stdio(0);
read(n);
for (int i = 1; i < n; i++) {
int x, y;
read(x);
read(y);
add(x, y);
}
res = n;
getroot(1, 0);
dfs(root);
for (int i = 1; i <= n; i++)
if (cnt[dp[i]] > 1) tag[i] = 1;
memset(vis, 0, sizeof(vis));
ans = -1;
dfs(root, 0);
printf("%d\n", id);
return 0;
}
| 10 | CPP |
Subsets and Splits