树上启发式合并
强大的解决对于子树的询问问题。
有个英文名字叫 dsu on tree。
一种是基于重链剖分的，一种是基于set map的启发式合并的。
第一种就是先走轻边，再走重边，重边的不改回来，这样修改次数就是 $logn$ 次的。
第二种就是看set map的size，把size小的并到大的上。
某些情况下！！！dfs序+主席树(某种数据结构)比这个做法可能少一个log！！！
模板题啦
#include <bits/stdc++.h> #define ll long long const int N = 1e5 + 7; int n, cc[N], col[N], son[N], sz[N], skip[N]; ll ans[N]; std::vector<int> G[N]; void dfs1(int u, int fa = 0) { sz[u] = 1; for (auto v: G[u]) { if (v == fa) continue; dfs1(v, u); sz[u] += sz[v]; if (sz[v] > sz[son[u]]) son[u] = v; } } ll sum; int cx; void edt(int u, int fa, int k) { cc[col[u]] += k; if (k > 0 && cc[col[u]] >= cx) { if (cc[col[u]] > cx) sum = 0, cx = cc[col[u]]; sum += col[u]; } for (auto v: G[u]) if (v != fa && !skip[v]) edt(v, u, k); } void dfs(int u, int fa = 0, bool kep = 0) { for (auto v: G[u]) if (v != fa && v != son[u]) dfs(v, u); if (son[u]) dfs(son[u], u, 1), skip[son[u]] = 1; edt(u, fa, 1); ans[u] = sum; if (son[u]) skip[son[u]] = 0; if (!kep) edt(u, fa, -1), cx = sum = 0; } int main() { scanf("%d", &n); for (int i = 1; i <= n; i++) scanf("%d", col + i); for (int i = 1, u, v; i < n; i++) { scanf("%d%d", &u, &v); G[u].push_back(v); G[v].push_back(u); } dfs1(1); dfs(1); for (int i = 1; i <= n; i++) printf("%lld%c", ans[i], " \n"[i == n]); return 0; }
把询问离线，一些字母能组成回文串，即出现偶数次的字母不能超过一个，那么对每一个深度用一个26位的二进制数表示一个字母出现的奇偶性，记为 $cnt[dep]$ 即可。
#include <bits/stdc++.h> #define pii pair<int, int> #define fi first #define se second const int N = 5e5 + 7; std::vector<int> G[N]; std::vector<std::pii> que[N]; int cnt[N], n, m, dep[N], sz[N], son[N]; char s[N]; bool ans[N], skip[N]; void dfs1(int u, int d) { dep[u] = d; sz[u] = 1; for (auto v: G[u]) { dfs1(v, d + 1); sz[u] += sz[v]; if (sz[v] > sz[son[u]]) son[u] = v; } } void edt(int u) { cnt[dep[u]] ^= (1 << (s[u] - 'a')); for (auto v: G[u]) if (!skip[v]) edt(v); } bool check(int d) { int res = 0; for (int i = 0; i < 26; i++) if (cnt[d] >> i & 1) res++; return res <= 1; } void dfs(int u, int keep = 0) { for (auto v: G[u]) if (v != son[u]) dfs(v, 0); if (son[u]) dfs(son[u], 1), skip[son[u]] = 1; edt(u); for (auto p: que[u]) ans[p.se] = check(p.fi); if (son[u]) skip[son[u]] = 0; if (!keep) edt(u); } int main() { // freopen("in.txt", "r", stdin); scanf("%d%d", &n, &m); for (int i = 2; i <= n; i++) { int x; scanf("%d", &x); G[x].push_back(i); } scanf("%s", s + 1); for (int i = 1, u, h; i <= m; i++) { scanf("%d%d", &u, &h); que[u].push_back(std::pii(h, i)); } dfs1(1, 1); dfs(1); for (int i = 1; i <= m; i++) puts(ans[i] ? "Yes" : "No"); return 0; }
想用重链剖分的写法。用一个multiset维护出现的数字，一个multiset维护每个插入的数和附近两个数的差值.
但是这跟插入顺序有关，插入的时候正着插入，删除的时候倒着删除，然后WA on 20了... 正着删除有RE on 20了...
看了一下别人的解法就是，每个结点维护一个set，发现这个set元素个数最多是所有叶子个数，空间能接受，然后就启发式合并就OK了。
#include <bits/stdc++.h> namespace IO { void read() {} template <typename T, typename... T2> inline void read(T &x, T2 &... oth) { T f = 1; x = 0; char ch = getchar(); while (!isdigit(ch)) { if (ch == '-') f = -1; ch = getchar(); } while (isdigit(ch)) { x = x * 10 + ch - 48; ch = getchar(); } x *= f; read(oth...); } } // using namespace IO #define read IO::read #define print IO::print #define flush IO::flush const int N = 1e5 + 7; const int INF = 2147483647; std::vector<int> vec[N]; std::set<int> st[N]; int n, m, color[N], ans[N]; int merge(int u, int v) { if (st[u].size() < st[v].size()) std::swap(st[u], st[v]); int res = INF; for (std::set<int>::iterator it = st[v].begin(); it != st[v].end(); it++) { auto i = st[u].lower_bound(*it); if (i == st[u].begin()) { res = std::min(res, *i - *it); } else if (i == st[u].end()) { i--; res = std::min(res, *it - *i); } else { res = std::min(res, *i - *it); i--; res = std::min(res, *it - *i); } st[u].insert(*it); } st[v].clear(); return res; } void dfs(int u) { ans[u] = INF; if (vec[u].size() == 0) { st[u].insert(color[u]); return; } for (int v: vec[u]) { dfs(v); ans[u] = std::min(ans[u], ans[v]); ans[u] = std::min(ans[u], merge(u, v)); } } int main() { read(n, m); for (int i = 2; i <= n; i++) { int u; read(u); vec[u].push_back(i); } for (int i = n - m + 1; i <= n; i++) read(color[i]); dfs(1); for (int i = 1; i <= n - m; i++) printf("%d%c", ans[i], " \n"[i == n - m]); return 0; }
这个就是每个结点维护一个map表示其子树钟出现过的数字以及出现的次数。
然后根据合并前枚举小的map里面的每个元素，看看大的map中能与其相乘成为当前结点的值的就行了。
#include <bits/stdc++.h> #define ll long long const int N = 1e5 + 7; std::map<int, int> mp[N]; int n, val[N]; std::vector<int> vec[N]; ll ans; void merge(int u, int v) { if (mp[u].size() < mp[v].size()) std::swap(mp[u], mp[v]); for (auto p: mp[v]) { if (val[u] % p.first == 0) ans += 1LL * p.second * mp[u][val[u] / p.first]; } for (auto p: mp[v]) mp[u][p.first] += p.second; mp[v].clear(); } void dfs(int u, int fa) { mp[u][val[u]] = 1; for (int v: vec[u]) { if (v == fa) continue; dfs(v, u); merge(u, v); } } int main() { scanf("%d", &n); for (int i = 1; i < n; i++) { int u, v; scanf("%d%d", &u, &v); vec[u].push_back(v); vec[v].push_back(u); } for (int i = 1; i <= n; i++) scanf("%d", val + i); dfs(1, 0); printf("%lld\n", ans); return 0; }
对每一个深度用一个map维护出现的字符串以及出现的次数，然后然后就做完了。
#include <bits/stdc++.h> #define pii pair<int, int> #define fi first #define se second const int N = 1e5 + 7; char s[N][22]; std::vector<int> vec[N]; std::vector<std::pii> query[N]; std::map<std::string, int> mp[N]; int n, son[N], sz[N], dep[N], ans[N], root, cnt[N]; bool skip[N]; void dfs1(int u, int d) { sz[u] = 1; dep[u] = d; son[u] = -1; for (int v: vec[u]) { dfs1(v, d + 1); sz[u] += sz[v]; if (son[u] == -1 || sz[son[u]] < sz[v]) son[u] = v; } } void edt(int u, int k) { mp[dep[u]][s[u]] += k; int w = mp[dep[u]][s[u]]; if (k == 1 && w == 1) cnt[dep[u]]++; if (k == -1 && w == 0) cnt[dep[u]]--; assert(cnt[dep[u]] >= 0); for (int v: vec[u]) if (!skip[v]) edt(v, k); } void dfs(int u, bool keep = 0) { for (int v: vec[u]) if (v != son[u]) dfs(v); if (son[u] != -1) dfs(son[u], 1), skip[son[u]] = 1; edt(u, 1); for (auto p: query[u]) ans[p.se] = cnt[dep[u] + p.fi]; if (son[u] != -1) skip[son[u]] = 0; if (!keep) edt(u, -1); } int main() { scanf("%d", &n); for (int i = 1, u; i <= n; i++) { scanf("%s%d", s[i], &u); vec[u].push_back(i); } int m; scanf("%d", &m); for (int i = 1; i <= m; i++) { int u, k; scanf("%d%d", &u, &k); query[u].push_back(std::pii(k, i)); } dfs1(0, 0); dfs(0, 1); for (int i = 1; i <= m; i++) printf("%d\n", ans[i]); return 0; }
先转换一下询问，把 $v_i$ 往上跳 $p_i$ 步得到 $u_i$，变成询问 $u_i$ 有多少个 $p_i$ 级儿子。然后就做完了。
#include <bits/stdc++.h> #define pii pair<int, int> #define fi first #define se second const int N = 1e5 + 7; int dep[N], son[N], sz[N], n, fa[N][20], ans[N]; bool skip[N]; std::vector<int> vec[N]; std::vector<std::pii> query[N]; void dfs1(int u, int pre = 0, int d = 0) { dep[u] = d; fa[u][0] = pre; for (int i = 1; i <= 18; i++) { fa[u][i] = fa[fa[u][i - 1]][i - 1]; if (!fa[u][i]) break; } sz[u] = 1; son[u] = -1; for (int v: vec[u]) { dfs1(v, u, d + 1); sz[u] += sz[v]; if (son[u] == -1 || sz[son[u]] < sz[v]) son[u] = v; } } int jump(int u, int k) { for (int i = 18; ~i; i--) if (k >> i & 1) u = fa[u][i]; return u; } int cnt[N]; void edt(int u, int k) { cnt[dep[u]] += k; for (int v: vec[u]) if (!skip[v]) edt(v, k); } void dfs(int u, bool keep = 0) { for (int v: vec[u]) if (v != son[u]) dfs(v); if (son[u] != -1) dfs(son[u], 1), skip[son[u]] = 1; edt(u, 1); for (auto p: query[u]) { ans[p.se] = cnt[dep[u] + p.fi] - 1; } if (son[u] != -1) skip[son[u]] = 0; if (!keep) edt(u, -1); } int main() { scanf("%d", &n); for (int i = 1; i <= n; i++) { int u; scanf("%d", &u); vec[u].push_back(i); } int m; scanf("%d", &m); dfs1(0); for (int i = 1; i <= m; i++) { int u, k; scanf("%d%d", &u, &k); u = jump(u, k); if (u) query[u].push_back(std::pii(k, i)); } dfs(0, 1); for (int i = 1; i <= m; i++) printf("%d%c", ans[i], " \n"[i == m]); return 0; }
这题可以用启发式合并，但是没必要。
另一个trick。当需要继承、查询祖先上的信息时，可以用一个(树状数组/桶)维护这些信息，进入一个点时加入该点的信息，离开这个点时删除这些信息即可。
比如树上斜率优化DP就可以这样做。
那么这道题就用一个vector维护哈希值，进入一个点，就继续插入哈希值，并在插入的过程中完成查询。离开时删除即可。
#include <bits/stdc++.h> #define ull unsigned long long #define ll long long const ull base = 19260817; const int N = 3e5 + 7; ull p[N], need; std::vector<char> s[N]; std::vector<int> vec[N]; std::vector<ull> cur; char t[N]; ll ans; int len, n; void dfs(int u) { for (int i = 0; i < s[u].size(); i++) { cur.push_back(cur.back() * base + s[u][i]); if (cur.size() > len) { ull x = cur.back() - cur[cur.size() - len - 1] * p[len]; if (x == need) ans++; } } for (int v: vec[u]) dfs(v); for (int i = 0; i < s[u].size(); i++) cur.pop_back(); } int main() { scanf("%d", &n); for (int i = p[0] = 1; i < N; i++) p[i] = p[i - 1] * base; for (int i = 2; i <= n; i++) { int u; scanf("%d%s", &u, t); vec[u].push_back(i); int len = strlen(t); for (int j = 0; j < len; j++) s[i].push_back(t[j]); } scanf("%s", t); len = strlen(t); for (int i = 0; i < len; i++) need = need * base + t[i]; cur.push_back(0); dfs(1); printf("%lld\n", ans); return 0; }
这题是长链剖分板子。而我用了重链剖分...
$O(nlog^{2}n)$ 水过去了...
用一个pair记录 cnt[dep[u]] 和 dep[u]，然后用set维护，cnt取负就能变成越大的排越前，在cnt相同时dep更小的排越前。
当set为空或者第一个的cnt是-1时答案是0
#include <bits/stdc++.h> #define pii pair<int, int> const int N = 1e6 + 7; int n, cnt[N], dep[N], son[N], sz[N], cur, ans[N]; std::vector<int> vec[N]; std::set< std::pii > st; bool skip[N]; void dfs1(int u, int fa = 0) { dep[u] = dep[fa] + 1; sz[u] = 1; for (int v: vec[u]) { if (v == fa) continue; dfs1(v, u); sz[u] += sz[v]; if (sz[son[u]] < sz[v]) son[u] = v; } } void edt(int u, int fa, int k) { auto it = st.find(std::pii(-cnt[dep[u]], dep[u])); if (it != st.end()) st.erase(it); cnt[dep[u]] += k; st.insert(std::pii(-cnt[dep[u]], dep[u])); for (int v: vec[u]) if (v != fa && !skip[v]) edt(v, u, k); } void dfs(int u, int fa, bool keep = 0) { for (int v: vec[u]) if (v != fa && v != son[u]) dfs(v, u); if (son[u]) dfs(son[u], u, 1), skip[son[u]] = 1; edt(u, fa, 1); if (st.empty() || st.begin()->first == -1) ans[u] = 0; else ans[u] = st.begin()->second - dep[u]; if (son[u]) skip[son[u]] = 0; if (!keep) edt(u, fa, -1); } int main() { scanf("%d", &n); for (int i = 1, u, v; i < n; i++) scanf("%d%d", &u, &v), vec[u].push_back(v), vec[v].push_back(u); dfs1(1, 0); dfs(1, 0, 1); for (int i = 1; i <= n; i++) printf("%d\n", ans[i]); return 0; }
感谢 https://blog.csdn.net/zlttttt/article/details/78634449 这篇dsu on tree的解法。
要 $O(1)$ 继承重儿子的信息，而重儿子的信息和自己的信息的差距只为一条边的长度和一条边
那么就不实际维护实际的长度和深度，而是维护一个差值。
具体用一个 cur_dep 和 cur_dis 维护当前结点 $u$ 到重链底端经过的边数和距离。
然后map维护当前节点到子树中的 节点的距离 减去 cur_dis 需要用的最小 边数 减去 cur_dep
查询是否存在一个距离时得减去 cur_dis，更新答案是加上 cur_dep 即可。
#include <bits/stdc++.h> namespace IO { char buf[1 << 21], buf2[1 << 21], a[20], *p1 = buf, *p2 = buf, hh = '\n'; int p, p3 = -1; void read() {} void print() {} inline int getc() { return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++; } inline void flush() { fwrite(buf2, 1, p3 + 1, stdout), p3 = -1; } template <typename T, typename... T2> inline void read(T &x, T2 &... oth) { T f = 1; x = 0; char ch = getc(); while (!isdigit(ch)) { if (ch == '-') f = -1; ch = getc(); } while (isdigit(ch)) { x = x * 10 + ch - 48; ch = getc(); } x *= f; read(oth...); } template <typename T, typename... T2> inline void print(T x, T2... oth) { if (p3 > 1 << 20) flush(); if (x < 0) buf2[++p3] = 45, x = -x; do { a[++p] = x % 10 + 48; } while (x /= 10); do { buf2[++p3] = a[p]; } while (--p); buf2[++p3] = hh; print(oth...); } } // using namespace IO #define read IO::read #define print IO::print #define flush IO::flush #define pii pair<int, int> #define fi first #define se second inline void checkmin(int &a, int b) { if (a > b) a = b; } const int N = 2e5 + 7; const int INF = 0x3f3f3f3f; int n, dep[N], son[N], sz[N], in[N], out[N], dfn[N], tol, dis[N], ans; int cur_dis[N], cur_dep[N], k, wt[N]; std::vector<std::pii> vec[N]; std::unordered_map<int, int> f; void dfs1(int u, int fa = 0) { dfn[in[u] = ++tol] = u; sz[u] = 1; for (auto p: vec[u]) { int v = p.fi; if (v == fa) continue; dep[v] = dep[u] + 1; dis[v] = dis[u] + p.se; wt[v] = p.se; dfs1(v, u); sz[u] += sz[v]; if (sz[v] > sz[son[u]]) son[u] = v; } out[u] = tol; } void dfs(int u, int fa) { if (!son[u]) { cur_dis[u] = cur_dep[u] = 0; return; } for (auto p: vec[u]) if (p.fi != fa && p.fi != son[u]) dfs(p.fi, u); dfs(son[u], u); cur_dis[u] = cur_dis[son[u]] + wt[son[u]]; cur_dep[u] = cur_dep[son[u]] + 1; if (f.count(f[wt[son[u]] - cur_dis[u]])) checkmin(f[wt[son[u]] - cur_dis[u]], 1 - cur_dep[u]); else f[wt[son[u]] - cur_dis[u]] = 1 - cur_dep[u]; for (auto p: vec[u]) { if (p.fi == fa || p.fi == son[u]) continue; for (int j = in[p.fi]; j <= out[p.fi]; j++) { int v = dfn[j]; int temp = k - (dis[v] - dis[u]); if (temp > 0 && f.count(temp - cur_dis[u])) checkmin(ans, f[temp - cur_dis[u]] + cur_dep[u] + dep[v] - dep[u]); } for (int j = in[p.fi]; j <= out[p.fi]; j++) { int v = dfn[j]; int temp = dis[v] - dis[u]; if (temp <= k) if (f.count(temp - cur_dis[u])) checkmin(f[temp - cur_dis[u]], dep[v] - dep[u] - cur_dep[u]); else f[temp - cur_dis[u]] = dep[v] - dep[u] - cur_dep[u]; } } if (f.count(k - cur_dis[u])) checkmin(ans, f[k - cur_dis[u]] + cur_dep[u]); if (son[fa] != u && u != 1) f.clear(); } int main() { freopen("in.txt", "r", stdin); read(n, k); for (int i = 1; i < n; i++) { int u, v, w; read(u, v, w); u++, v++; vec[u].push_back(std::pii(v, w)); vec[v].push_back(std::pii(u, w)); } ans = INF; dfs1(1, 0); dfs(1, 0); printf("%d\n", ans == INF ? -1 : ans); return 0; }
查询子树中颜色出现次数不少于 $k_i$ 次的颜色种类数，用一个 $cnt$ 数组存颜色出现的次数，再用一个树状数组存 $cnt$ 值的出现次数。
回答询问就是一个后缀和
#include <bits/stdc++.h> #define pii pair<int, int> #define fi first #define se second const int N = 1e5 + 7; int color[N], cnt[N], n, m, sz[N], son[N], ans[N]; bool skip[N]; std::vector<int> vec[N]; std::vector<std::pii> query[N]; struct BIT { int tree[N]; inline int lowbit(int x) { return x & -x; } void add(int x, int k) { if (!x) return; for (int i = x; i < N; i += lowbit(i)) tree[i] += k; } int query(int x) { int ans = 0; for (int i = x; i; i -= lowbit(i)) ans += tree[i]; return ans; } } bit; void dfs1(int u, int fa) { sz[u] = 1; for (int v: vec[u]) { if (v == fa) continue; dfs1(v, u); sz[u] += sz[v]; if (sz[v] > sz[son[u]]) son[u] = v; } } void edt(int u, int fa, int k) { bit.add(cnt[color[u]], -1); cnt[color[u]] += k; bit.add(cnt[color[u]], 1); for (int v: vec[u]) if (v != fa && !skip[v]) edt(v, u, k); } void dfs(int u, int fa, bool kep) { for (int v: vec[u]) if (v != fa && v != son[u]) dfs(v, u, 0); if (son[u]) dfs(son[u], u, 1), skip[son[u]] = 1; edt(u, fa, 1); for (auto p: query[u]) ans[p.se] = bit.query(N - 1) - bit.query(p.fi - 1); if (son[u]) skip[son[u]] = 0; if (!kep) edt(u, fa, -1); } int main() { freopen("in.txt", "r", stdin); scanf("%d%d", &n, &m); for (int i = 1; i <= n; i++) scanf("%d", color + i); for (int i = 1; i < n; i++) { int u, v; scanf("%d%d", &u, &v); vec[u].push_back(v); vec[v].push_back(u); } for (int i = 1; i <= m; i++) { int u, k; scanf("%d%d", &u, &k); query[u].push_back(std::pii(k, i)); } dfs1(1, 0); dfs(1, 0, 1); for (int i = 1; i <= m; i++) printf("%d\n", ans[i]); return 0; }
查询有多少点对 $(u, v)$ 路径上的数字组成的数为 $M$ 的倍数。
点分治做的话，维护一个当前重心到当前点 $u$ 走过来组成的数字 $down_u$ 以及从 $u$ 走到重心组成的数字 $up_u$。
然后就是 $up_u * 10^{dep_v}+ down_v \equiv 0$($mod$ $M$)
得到 $up_u \equiv M - down_v * 10^{-dep_v}$($mod$ $M$)
用两个map维护这个东西就好了。
考虑重链剖分的做法，就是先递归轻儿子，再递归重儿子。
现在 $down_u$ 和 $up_u$ 分别代表根节点到 $u$ 和 $u$ 到根节点形成的两个数字。
考虑现在到了 $f$ 节点，其子树中一个节点 $u$ 和一个节点 $v$ 能形成一个合法的点对
从 $u$ 到 $v$ 需符合
$(up_u - up_f) * 10^{-dep_f}*10^{dep_v-dep_f} + (down_v - down_f * 10^{dep_v-dep_f}) \equiv 0$($mod$ $M$)
得到 $down_f * 10^{-dep_f}+(up_f-up_u)*10^{-dep_f} \equiv down_v * 10^{-dep_v}$($mod$ $M$)
从 $v$ 到 $u$ 需符合
$down_f*10^{dep_f}-down_{u}*10^{2dep_f-dep_u}+up_f \equiv up_v$($mod$ $M$)
用两个map维护右边两个值即可。
两种做法复杂度都是 $O(nlog^2n)$，但是常数有很大区别...
#include <bits/stdc++.h> #define ll long long #define pii pair<int, int> #define fi first #define se second const int N = 1e5 + 7; int n, MOD, down[N], up[N], dep[N], son[N], sz[N], in[N], out[N], dfn[N], tol; int base[N * 5]; std::vector<std::pii> vec[N]; int qp(int a, int b) { int ans = 1; while (b) { if (b & 1) ans = 1LL * ans * a % MOD; a = 1LL * a * a % MOD; b >>= 1; } return ans; } void dfs1(int u, int fa, int fac, int p1, int p2, int d) { sz[u] = 1; dep[u] = d; in[u] = ++tol; dfn[tol] = u; down[u] = p1, up[u] = p2; for (auto p: vec[u]) { int v = p.fi; if (v == fa) continue; dfs1(v, u, fac * 10LL % MOD, (p1 * 10LL + p.se) % MOD, (p2 + 1LL * p.se * fac) % MOD, d + 1); sz[u] += sz[v]; if (sz[v] > sz[son[u]]) son[u] = v; } out[u] = tol; } std::map<int, int> mp1, mp2; inline int BASE(int x) { return base[x + 3 * N]; } ll ans; void update(int u, int f) { int x = (1LL * down[f] * BASE(dep[f]) % MOD - 1LL * down[u] * BASE(2 * dep[f] - dep[u]) % MOD + up[f]) % MOD; x = (x + MOD) % MOD; std::map<int, int>::iterator it; it = mp1.find(x); if (it != mp1.end()) ans += it->se; x = (1LL * down[f] * BASE(-dep[f]) % MOD + 1LL * (up[f] - up[u]) * BASE(-2 * dep[f])) % MOD; x = (x + MOD) % MOD; it = mp2.find(x); if (it != mp2.end()) ans += it->se; } void getans(int u, int f) { for (int i = in[u]; i <= out[u]; i++) update(dfn[i], f); } void add(int u) { for (int i = in[u]; i <= out[u]; i++) { int f = dfn[i]; mp1[up[f]]++; int x = 1LL * down[f] * BASE(-dep[f]) % MOD; mp2[x]++; } } void dfs(int u, int fa) { if (son[u]) { for (auto p: vec[u]) if (p.fi != fa && p.fi != son[u]) dfs(p.fi, u), mp1.clear(), mp2.clear(); dfs(son[u], u); for (auto p: vec[u]) if (p.fi != fa && p.fi != son[u]) getans(p.fi, u), add(p.fi); update(u, u); } int x = 1LL * down[u] * BASE(-dep[u]) % MOD; mp2[x]++; mp1[up[u]]++; } int main() { scanf("%d%d", &n, &MOD); for (int i = 1; i < n; i++) { int u, v, w; scanf("%d%d%d", &u, &v, &w); u++; v++; vec[u].push_back(std::pii(v, w)); vec[v].push_back(std::pii(u, w)); } if (MOD == 1) { printf("%lld\n", 1LL * n * (n - 1)); return 0; } int phi = MOD, temp = MOD; for (int i = 2; i * i <= temp; i++) { if (temp % i == 0) { phi = phi / i * (i - 1); while (temp % i == 0) temp /= i; } } if (temp > 1) phi = phi / temp * (temp - 1); phi--; base[3 * N] = 1; int inv = qp(10, phi); for (int i = 1; i <= 2 * n; i++) base[i + 3 * N] = base[i + 3 * N - 1] * 10LL % MOD; for (int i = 1; i <= 2 * n; i++) base[3 * N - i] = 1LL * base[3 * N - i + 1] * inv % MOD; dfs1(1, 0, 1, 0, 0, 0); dfs(1, 0); printf("%lld\n", ans); return 0; }
741D - Arpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths
看错题了之后不会写。
要求每个子树内最长的回文路径，回文路径定义为路径上的字符重排后能得到回文串。
那么就如同570D - Tree Requests
用一个二十六进制的数来表示一条路径上的字符，能成为回文路径就是该数字二进制下有不超过两个 $1$。
开一个桶 $f[x]$ 表示路径为 $x$ 最长是多少。先走重儿子，再枚举轻儿子，先更新，后合并信息。
#include <bits/stdc++.h> #define pii pair<int, int> #define fi first #define se second const int N = 5e5 + 7; int n, sz[N], son[N], pre[N], fa[N], ans[N], in[N], out[N], dfn[N], tol, dep[N]; std::vector<std::pii> vec[N]; inline void checkmax(int &a, int b) { if (a < b) a = b; } int f[1 << 22]; void dfs1(int u, int f) { sz[u] = 1; dfn[in[u] = ++tol] = u; dep[u] = dep[f] + 1; for (auto p: vec[u]) { int v = p.fi; if (v == f) continue; fa[v] = u; pre[v] = pre[u] ^ (1 << p.se); dfs1(v, u); sz[u] += sz[v]; if (sz[son[u]] < sz[v]) son[u] = v; } out[u] = tol; } void dfs(int u, bool kep) { for (auto p: vec[u]) if (p.fi != son[u]) dfs(p.fi, 0), checkmax(ans[u], ans[p.fi]); if (son[u]) dfs(son[u], 1), checkmax(ans[u], ans[son[u]]); if (f[pre[u]]) checkmax(ans[u], f[pre[u]] - dep[u]); for (int i = 0; i < 22; i++) if (f[pre[u] ^ (1 << i)]) checkmax(ans[u], f[pre[u] ^ (1 << i)] - dep[u]); checkmax(f[pre[u]], dep[u]); for (auto p: vec[u]) if (p.fi != son[u]) { for (int i = in[p.fi]; i <= out[p.fi]; i++) { int v = dfn[i]; if (f[pre[v]]) checkmax(ans[u], f[pre[v]] + dep[v] - 2 * dep[u]); for (int i = 0; i < 22; i++) if (f[pre[v] ^ (1 << i)]) checkmax(ans[u], f[pre[v] ^ (1 << i)] + dep[v] - 2 * dep[u]); } for (int i = in[p.fi]; i <= out[p.fi]; i++) { int v = dfn[i]; checkmax(f[pre[v]], dep[v]); } } if (!kep) for (int i = in[u]; i <= out[u]; i++) f[pre[dfn[i]]] = 0; } int main() { scanf("%d", &n); for (int i = 2; i <= n; i++) { int p; char s[3]; scanf("%d%s", &p, s); vec[p].push_back(std::pii(i, (int)(s[0] - 'a'))); } dfs1(1, 0); dfs(1, 1); for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]); return 0; }
完结撒花！！！
https://codeforces.com/blog/entry/44351
评论区还有很多题，慢慢补吧...
浙公网安备 33010602011771号