NOI2020 简要题解
Delicacy
Solution
暴力 DP：\(f_{i,u}\) 表示 \(i\) 时刻到达 \(u\) 的最大收益，注意到转移 \(f_{i,v}\leftarrow f_{i-w,u}\)（\(w\le 5\)）对所有的 \(i\) 都一样，可以使用矩阵快速幂，矩阵规模为 \(nw\)。
对于原问题，设 \(g_{i,u}\) 表示从小到大第 \(i\) 个时间点到达 \(u\) 的最大收益，这里从 \(i\) 从小到大，不断让 \(g\) 乘上转移矩阵 \(A\) 的 \(t_i-t_{i-1}\) 次幂之后再加上 \(x_i\) 的额外收益 \(y_i\)。
对于求一个 \(1\times n\) 行向量 \(F\) 和一个 \(n\times n\) 矩阵 \(A\) 的 \(t\) 次幂的乘积，我们有 \(O(n^3\log t)\) 预处理，每组询问 \(O(n^2\log t)\) 的做法：预处理 \(A^{2^0}\)，\(A^{2^1}\)，\(A^{2^2}\)，\(\dots\)，每次询问把 \(t\) 二进制分解，依次把对应的 \(A^{2^i}\) 乘在 \(F\) 右边，每次相乘只做了一个 \(1\times n\) 和 \(n\times n\) 的矩阵乘法。
总复杂度 \(O((k+nw)(nw)^2\log t)\)。
Code
#include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
template <class T>
inline T Max(const T &a, const T &b) {return a > b ? a : b;}
typedef long long ll;
const int N = 55, E = 255;
int n, m, T, k, c[N];
struct matrix
{
int n, m; ll a[E][E];
matrix() {}
matrix(int _n, int _m) :
n(_n), m(_m) {memset(a, -1, sizeof(a));}
friend inline matrix operator * (matrix a, matrix b)
{
matrix res = matrix(a.n, b.m);
for (int i = 1; i <= a.n; i++) for (int j = 1; j <= b.m; j++)
for (int k = 1; k <= a.m; k++)
if (a.a[i][k] != -1 && b.a[k][j] != -1)
res.a[i][j] = Max(res.a[i][j], a.a[i][k] + b.a[k][j]);
return res;
}
} F, A[32];
struct orz
{
int t, x, y;
} a[E];
inline bool comp(orz a, orz b)
{
return a.t < b.t;
}
int o(int u, int id) {return (u - 1) * 5 + id;}
int main()
{
#ifdef ONLINE_JUDGE
freopen("delicacy.in", "r", stdin);
freopen("delicacy.out", "w", stdout);
#endif
int x, y, z;
read(n); read(m); read(T); read(k);
for (int i = 1; i <= n; i++) read(c[i]);
A[0] = matrix(n * 5, n * 5); F = matrix(1, n * 5);
while (m--) read(x), read(y), read(z),
A[0].a[o(x, z)][o(y, 1)] = Max(A[0].a[o(x, z)][o(y, 1)], 1ll * c[y]);
for (int u = 1; u <= n; u++) for (int id = 1; id <= 4; id++)
A[0].a[o(u, id)][o(u, id + 1)] = 0;
F.a[1][o(1, 1)] = c[1];
for (int i = 1; i <= k; i++) read(a[i].t), read(a[i].x), read(a[i].y);
std::sort(a + 1, a + k + 1, comp);
a[0] = (orz) {0, 1, 0}; a[++k] = (orz) {T, 1, 0};
for (int i = 1; i <= 29; i++) A[i] = A[i - 1] * A[i - 1];
for (int i = 1; i <= k; i++)
{
for (int j = 29; j >= 0; j--) if ((a[i].t - a[i - 1].t >> j) & 1)
F = F * A[j];
if (F.a[1][o(a[i].x, 1)] > 0) F.a[1][o(a[i].x, 1)] += a[i].y;
}
return std::cout << F.a[1][o(1, 1)] << std::endl, 0;
}
Destiny
Solution
为了方便，选边改成选点（根不能选），即 \(u_i\) 到 \(v_i\) 的路径上（含 \(v_i\)，不含 \(u_i\)）至少要选一个点。
考虑一个 DP：\(f_{u,i}\) 表示 \(u\) 的祖先中选出的最深的点深度为 \(i\)，覆盖终点在 \(u\) 子树内的所有路径的方案数，需要满足 \(1\le i\le\max(1,dep_u-1)\)。
转移一：不选 \(u\) 点。（\(md_u\) 表示满足 \(v_i=u\) 的最大 \(dep_{u_i}\)）
\[f_{u,i}=\prod_{v\in son(u)}f_{v,i}\>\>\>(md_u<i\le dep_u)
\]
转移二：选上 \(u\) 点。
\[f_{u,i}+=f_{u,dep_u}\>\>\>(i<dep_u)
\]
之后如果 \(u\ne 1\) 就 \(f_{u,dep_u}\leftarrow0\)，就能得到 \(f_u\)。
这样做完答案就是 \(f_{1,1}\)，复杂度 \(O(n^2)\)。
注意到第一种转移式左右的下标不变，第二种转移是区间加，故可以使用线段树合并，维护加和乘标记，区间清 \(0\) 时只需删掉对应节点即可，\(O(n\log n)\)。
Code
#include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
template <class T>
inline T Max(const T &a, const T &b) {return a > b ? a : b;}
const int N = 5e5 + 5, M = N << 1, L = 6e7 + 5, EI = 998244353;
int n, m, ecnt, nxt[M], adj[N], go[M], dep[N], md[N], ToT;
struct node
{
int lc, rc, add, prod;
} T[L];
void add_edge(int u, int v)
{
nxt[++ecnt] = adj[u]; adj[u] = ecnt; go[ecnt] = v;
nxt[++ecnt] = adj[v]; adj[v] = ecnt; go[ecnt] = u;
}
void dfs(int u, int fu)
{
dep[u] = dep[fu] + 1;
for (int e = adj[u], v; e; e = nxt[e])
if ((v = go[e]) != fu) dfs(v, u);
}
void down(int p)
{
if (!T[p].lc) T[T[p].lc = ++ToT].prod = 1;
if (!T[p].rc) T[T[p].rc = ++ToT].prod = 1;
T[T[p].lc].prod = 1ll * T[T[p].lc].prod * T[p].prod % EI;
T[T[p].rc].prod = 1ll * T[T[p].rc].prod * T[p].prod % EI;
T[T[p].lc].add = (1ll * T[T[p].lc].add * T[p].prod + T[p].add) % EI;
T[T[p].rc].add = (1ll * T[T[p].rc].add * T[p].prod + T[p].add) % EI;
T[p].add = 0; T[p].prod = 1;
}
int query(int l, int r, int pos, int p)
{
if (!p) return 0;
if (l == r) return T[p].add;
int mid = l + r >> 1, res = pos <= mid ? query(l, mid, pos, T[p].lc)
: query(mid + 1, r, pos, T[p].rc);
res = (1ll * res * T[p].prod + T[p].add) % EI;
return res;
}
void del(int l, int r, int s, int e, int &p)
{
if (e < l || s > r) return;
if (s <= l && r <= e) return (void) (p = 0);
int mid = l + r >> 1; down(p);
del(l, mid, s, e, T[p].lc); del(mid + 1, r, s, e, T[p].rc);
}
int merge(int x, int y)
{
if (!x || !y) return 0;
if (!T[x].lc && !T[x].rc)
return T[y].prod = 1ll * T[y].prod * T[x].add % EI,
T[y].add = 1ll * T[y].add * T[x].add % EI, y;
if (!T[y].lc && !T[y].rc)
return T[x].prod = 1ll * T[x].prod * T[y].add % EI,
T[x].add = 1ll * T[x].add * T[y].add % EI, x;
down(x); down(y);
T[x].lc = merge(T[x].lc, T[y].lc);
T[x].rc = merge(T[x].rc, T[y].rc);
return x;
}
void change(int l, int r, int s, int e, int v, int &p)
{
if (e < l || s > r) return;
if (!p) T[p = ++ToT].prod = 1;
if (s <= l && r <= e) return (void) (T[p].add = (T[p].add + v) % EI);
int mid = l + r >> 1; down(p);
change(l, mid, s, e, v, T[p].lc);
change(mid + 1, r, s, e, v, T[p].rc);
}
int dp(int u, int fu)
{
int rt = 0; change(1, n, 1, n, 1, rt);
for (int e = adj[u], v; e; e = nxt[e], v = go[e])
if ((v = go[e]) != fu) rt = merge(rt, dp(v, u));
if (md[u]) del(1, n, 1, md[u], rt);
if (u > 1) change(1, n, 1, dep[u] - 1, query(1, n, dep[u], rt), rt),
del(1, n, dep[u], dep[u], rt);
return rt;
}
int main()
{
#ifdef ONLINE_JUDGE
freopen("destiny.in", "r", stdin);
freopen("destiny.out", "w", stdout);
#endif
int x, y;
read(n);
for (int i = 1; i < n; i++) read(x), read(y), add_edge(x, y);
dfs(1, 1); read(m);
while (m--) read(x), read(y), md[y] = Max(md[y], dep[x]);
return std::cout << query(1, n, 1, dp(1, 0)) << std::endl, 0;
}
Tears
Solution
这里提供一个分块的做法。
为了方便，下面 \(r_{i,1},r_{i,2},c_{i,1},c_{i,2}\) 分别用 \(lx,rx,ly,ry\) 代替。
考虑把二维矩形拆成 \(4\) 个前缀容斥的形式，设 \(f(x,y)\) 表示矩形 \((1,1)-(x,y)\) 内满足关系的点对数，\(g(lx_1,rx_1,ly_1,ry_1,lx_2,rx_2,ly_2,ry_2)\) 表示第一个点在矩形 \((lx_1,ly_1)-(rx_1,ry_1)\) 内，第二个点在矩形 \((lx_2,ly_2)-(rx_2,ry_2)\) 内，合法的点对数。
则大力容斥可以得到答案可以表示成：
\[f(rx,ry)-f(lx-1,ry)-f(rx,ly-1)+f(lx-1,ly-1)
\]
\[-g(1,lx-1,1,ry,lx,rx,1,ry)+g(1,lx-1,1,ly-1,lx,rx,1,ly-1)
\]
\[-g(1,rx,1,ly-1,1,rx,ly,ry)+g(1,lx-1,1,ly-1,1,lx-1,ly,ry)
\]
\[+g(1,lx-1,1,ly-1,lx,rx,ly,ry)
\]
\(f\) 可以直接二维数点，\(g(1,lx-1,1,ly-1,lx,rx,ly,ry)\) 的第一个矩形严格在第二个矩形左下方，可以直接用两个矩形内的点数乘起来。
于是问题转化成给定 \(y,l,r\)，求纵坐标 \(\le y\) 的区域内，第一个点的横坐标在 \([1,l-1]\)，第二个点的横坐标在 \([l,r]\) 的点对数。
考虑按 \(y\) 分块。设 \(y\) 在第 \(b\) 块内，分几类：、
（1）两个点来自不同的块，且都不在第 \(b\) 块：枚举第二个点所在的块，容易发现这种情况对答案的贡献可以描述成两个矩形内点数的乘积，直接计算即可。
（2）第二个点在第 \(b\) 块，第一个点不在第 \(b\) 块：与（1）类似，只不过第二个点的纵坐标有了个 \(y\) 的限制，这里可以暴力枚举第 \(b\) 块内的所有点进行统计。
（3）两个点都在第 \(i\ne b\) 块：由于一个块内的点数为 \(O(\sqrt n)\)，故对于一个特定的 \(i\)，本质不同的询问只有 \(O(n)\) 种，可以事先预处理。
（4）两个点都在第 \(b\) 块：暴力枚举第 \(b\) 块内的点即可。为了避免算顺序对的复杂度多 \(\log\)，需要把块内的点提前按 \(y\) 排序，每次询问时用双指针扫。
具体实现时可以离线后从小到大枚举 \(b\)，每到一个 \(b\) 就对所有相关询问都处理一遍，这样可以使得空间为 \(O(n+m)\)，具体细节见代码 jiejuediao 函数。
时间复杂度 \(O((n+m)\sqrt n)\)。
Code
#include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
typedef long long ll;
const int N = 1e5 + 5, M = N << 1, L = M << 1, E = 350;
int n, m, S, p[N], q[N], c1[M], c2[M], B[N], tot, bl[E], br[E], in[N], cur[N],
lx[M], rx[M], ly[M], ry[M], sum[N], cnt, a[E], b[E][E], lt[N];
ll ans[M], A[N], f[N];
void changeA(int x, ll v)
{
for (; x <= n; x += x & -x)
A[x] += v;
}
ll askA(int x)
{
ll res = 0;
for (; x; x -= x & -x) res += A[x];
return res;
}
void changeB(int x, int v)
{
for (; x <= n; x += x & -x)
B[x] += v;
}
int askB(int x)
{
int res = 0;
for (; x; x -= x & -x) res += B[x];
return res;
}
struct query
{
int id, t, l, r;
} que1[L];
void jiejuediao()
{
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= tot; i++)
{
cnt = 0;
for (int j = 1; j <= n; j++)
{
cur[j] = cur[j - 1]; lt[j] = lt[j - 1];
if (in[p[j]] == i) cur[j]++, a[++cnt] = j, lt[j] = cnt;
}
for (int j = 1; j <= cnt; j++)
for (int k = 1; k <= cnt; k++)
b[j][k] = b[j - 1][k] + b[j][k - 1] - b[j - 1][k - 1]
+ (p[a[j]] < p[a[k]]);
std::sort(a + 1, a + cnt + 1, [&](int x, int y) {return p[x] < p[y];});
for (int j = 1; j <= m; j++)
{
int l = lx[j] - 1, r = rx[j];
if (in[ry[j]] > i) ans[j] -= 1ll * (cur[r] - cur[l])
* sum[l] + b[lt[l]][lt[r]] - b[lt[l]][lt[l]];
if (in[ly[j] - 1] > i) ans[j] += 1ll * (cur[r] - cur[l])
* sum[l] + b[lt[l]][lt[r]] - b[lt[l]][lt[l]];
if (in[ry[j]] == i)
{
int s = 0;
for (int k = 1, h = 1, c = 0; k <= cnt && p[a[k]] <= ry[j]; k++)
if (l < a[k] && a[k] <= r)
{
s++;
while (h <= cnt && p[a[h]] < p[a[k]])
{
if (a[h] <= l) c++;
h++;
}
ans[j] -= c;
}
ans[j] -= 1ll * s * sum[l];
}
if (in[ly[j] - 1] == i)
{
int s = 0;
for (int k = 1, h = 1, c = 0; k <= cnt && p[a[k]] < ly[j]; k++)
if (l < a[k] && a[k] <= r)
{
s++;
while (h <= cnt && p[a[h]] < p[a[k]])
{
if (a[h] <= l) c++;
h++;
}
ans[j] += c;
}
ans[j] += 1ll * s * sum[l];
}
}
for (int j = 1; j <= n; j++) sum[j] += cur[j];
}
}
int main()
{
#ifdef ONLINE_JUDGE
freopen("tears.in", "r", stdin);
freopen("tears.out", "w", stdout);
#endif
int xl, xr, yl, yr;
read(n); read(m); S = sqrt(n);
for (int i = 1; i <= n; i += S) bl[++tot] = i,
br[tot] = i + S - 1 < n ? i + S - 1 : n;
for (int i = 1; i <= n; i++) read(p[i]), q[p[i]] = i,
in[i] = (i - 1) / S + 1;
for (int i = 1; i <= n; i++) f[i] = askB(p[i]), changeB(p[i], 1);
for (int i = 1; i <= m; i++)
{
read(xl); read(xr); read(yl); read(yr);
lx[i] = xl; rx[i] = xr; ly[i] = yl; ry[i] = yr;
que1[i] = (query) {-i, xl - 1, yl, yr};
que1[i + m] = (query) {i, xr, yl, yr};
}
std::sort(que1 + 1, que1 + (m << 1) + 1, [&](query a, query b)
{return a.t < b.t;});
memset(B, 0, sizeof(B));
for (int i = 1, j = 1; i <= (m << 1); i++)
{
while (j <= que1[i].t) changeA(p[j], f[j]), changeB(p[j], 1), j++;
ll delta = askA(que1[i].r) - askA(que1[i].l - 1);
int d1 = askB(que1[i].r), d2 = askB(que1[i].l - 1);
if (que1[i].id < 0) ans[-que1[i].id] -= delta, c1[-que1[i].id] = d2,
c2[-que1[i].id] -= d1 - d2;
else ans[que1[i].id] += delta, c2[que1[i].id] += d1 - d2;
}
jiejuediao();
for (int i = 1; i <= n; i++) p[i] = q[i];
for (int i = 1; i <= m; i++) std::swap(lx[i], ly[i]),
std::swap(rx[i], ry[i]);
jiejuediao();
for (int i = 1; i <= m; i++)
printf("%lld\n", ans[i] + 1ll * c1[i] * c2[i]);
return 0;
}
Meal
Solution
结论 \(1\)：若 \(m=n-1\) 则合法方案一定存在。
证明：容易发现最小的数不超过 \(k\)，最小数和最大数之和不少于 \(k\)（\(n\ge 2\)），当 \(n>2\) 时取走最小数加上最大数的一部分凑成 \(k\)，就能得到 \(n\) 和 \(m\) 都减少 \(1\) 的情况，然后继续这样的操作直到 \(m\) 变成 \(0\)。
于是 \(m\ge n-1\) 时可以加入 \(m-n-1\) 个 \(0\)，用 std::set 维护当前的数，就能做到 \(O(m\log m)\)。
结论 \(2\)：若 \(m=n-2\) 则可以把这 \(n\) 个数拆成两个满足 \(m=n-1\) 的集合。
证明：考虑在每次操作的两个数之间连边构成一个图，显然 \(n\) 点 \(n-2\) 边的图不连通，且存在一个连通块是树，让这棵树成为其中一个集合，就能达到目的。
一个子集 \(S\) 合法的条件为 \(\sum_{i\in S}d_i=(|S|-1)k\)，移一下项得 \(\sum_{i\in S}(k-d_i)=k\)。
可以通过 bitset 优化背包 DP 来得到是否存在这样的子集，把 DP 倒着推回去可以得到一个合法子集，这里的复杂度为 \(O(\frac{n^3}{\omega})\)。
然后对两个子集分别跑一遍 \(m=n-1\) 即可。
Code
#include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 505, M = 5e6 + 5;
int n, m, k, d[N];
std::bitset<M> f[N];
struct orz
{
int i, x, j, y;
friend inline bool operator < (orz a, orz b)
{
return a.x < b.x;
}
};
std::vector<orz> ans;
void nealchen(std::vector<orz> d, int m)
{
while (d.size() <= m) d.push_back((orz) {0, 0, 0, 0});
std::multiset<orz> pq;
for (int i = 0; i < d.size(); i++) pq.insert(d[i]);
while (m--)
{
std::multiset<orz>::iterator fi = pq.begin(), ls = pq.end(); ls--;
int t1 = ls->i, t2 = ls->x - (k - fi->x);
ans.push_back((orz) {fi->i, fi->x, ls->i, k - fi->x});
pq.erase(fi); pq.erase(ls); pq.insert((orz) {t1, t2, 0, 0});
}
}
void output()
{
for (int i = 0; i < ans.size(); i++)
{
if (ans[i].x) printf("%d %d ", ans[i].i, ans[i].x);
if (ans[i].y) printf("%d %d ", ans[i].j, ans[i].y);
puts("");
}
}
void work()
{
read(n); read(m); read(k); ans.clear();
for (int i = 1; i <= n; i++) read(d[i]);
if (m >= n - 1)
{
std::vector<orz> a;
for (int i = 1; i <= n; i++) a.push_back((orz) {i, d[i], 0, 0});
nealchen(a, m); return output();
}
std::vector<orz> ia, ib; f[0].reset(); f[0][n * k] = 1;
for (int i = 1; i <= n; i++)
{
f[i] = f[i - 1];
if (k - d[i] >= 0) f[i] |= f[i - 1] << k - d[i];
else f[i] |= f[i - 1] >> d[i] - k;
}
if (!f[n][(n + 1) * k]) return (void) puts("-1");
for (int i = n, cur = (n + 1) * k; i >= 1; i--)
if (f[i - 1][cur]) ia.push_back((orz) {i, d[i], 0, 0});
else ib.push_back((orz) {i, d[i], 0, 0}), cur -= k - d[i];
if (ia.size() > 1) nealchen(ia, ia.size() - 1);
if (ib.size() > 1) nealchen(ib, ib.size() - 1);
output();
}
int main()
{
#ifdef ONLINE_JUDGE
freopen("dish.in", "r", stdin);
freopen("dish.out", "w", stdout);
#endif
int T; read(T);
while (T--) work();
return 0;
}
Surreal
Solution
出题人：可能有的选手第一遍会看错成叶子能随便加。对于叶子能随便加的版本，大概会稍微好做一点点。
题目要求的就是是否对于所有的深度 \(h\) 都存在一棵树不能被所有模板树生长得到。
结论：深度为 \(h\) 的不能被生长得到的树若存在，则存在一棵树，满足这棵树能够在一条深度为 \(h\) 的链上的部分位置各插入一个叶子得到。
证明略。
显然地，有了这个结论之后，我们就只要保留具有这种结构的模板树。
一棵具有这种结构的树可以用一个数字串表示：从上到下，\(0\) 表示没有右子树，\(1\) 表示右子树为叶子，\(2\) 表示没有左子树，\(3\) 表示左子树为叶子，\(4\) 表示左右子树都为叶子。
这样每棵模板树都可以被表示成一个 \(0\sim3\) 的数字串（最后一个数可以为 \(4\)）。
这个 \(4\) 很讨厌，但不难发现在这种情况下模板树如果要生长，则这个 \(4\) 必然要变成 \(1\) 或 \(3\)，所以形如 \(s4\) 的模板树可以拆成两棵，即 \(s1\) 和 \(s3\)。
这样问题就转化成对于一个足够大的 \(l\)，是否满足所有串长为 \(l\) 的 \(0\sim3\) 数字串都包含模板串之一为前缀。
Trie 上 DFS 即可，复杂度是线性的。
Code
#include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 2e6 + 5, M = 1e7 + 5;
int n, cnt, lc[N], rc[N], sze[N], ToT;
bool is, f[M];
std::vector<int> seq[N];
struct trie
{
int son[4]; bool mark;
void init() {son[0] = son[1] = son[2] = son[3] = 0; mark = 0;}
} T[M];
void dfs(int u)
{
sze[u] = 1;
if (lc[u]) dfs(lc[u]), sze[u] += sze[lc[u]];
if (rc[u]) dfs(rc[u]), sze[u] += sze[rc[u]];
if (sze[lc[u]] > 1 && sze[rc[u]] > 1) is = 0;
}
void sfd(int u, int th)
{
if (lc[u] && !rc[u]) seq[th].push_back(0), sfd(lc[u], th);
if (sze[lc[u]] > 1 && sze[rc[u]] == 1) seq[th].push_back(1), sfd(lc[u], th);
if (rc[u] && !lc[u]) seq[th].push_back(2), sfd(rc[u], th);
if (sze[rc[u]] > 1 && sze[lc[u]] == 1) seq[th].push_back(3), sfd(rc[u], th);
if (sze[lc[u]] == 1 && sze[rc[u]] == 1)
seq[th].push_back(5);
}
void ins(std::vector<int> s)
{
int u = 1;
for (int i = 0; i < s.size(); i++)
{
if (!T[u].son[s[i]]) T[T[u].son[s[i]] = ++ToT].init();
u = T[u].son[s[i]];
}
T[u].mark = 1;
}
void solve(int u)
{
f[u] = T[u].mark; bool o = 1;
for (int c = 0; c < 4; c++)
{
if (T[u].son[c]) solve(T[u].son[c]);
o &= f[T[u].son[c]];
}
f[u] |= o;
}
void work()
{
int m; read(m); cnt = 0;
while (m--)
{
read(n);
for (int i = 1; i <= n; i++) read(lc[i]), read(rc[i]);
is = 1; dfs(1);
if (is) seq[++cnt].clear(), sfd(1, cnt);
}
T[ToT = 1].init();
for (int i = 1; i <= cnt; i++)
if (!seq[i].empty() && seq[i][seq[i].size() - 1] == 5)
{
seq[i][seq[i].size() - 1] = 1; ins(seq[i]);
seq[i][seq[i].size() - 1] = 3; ins(seq[i]);
}
else ins(seq[i]);
puts((solve(1), f[1]) ? "Almost Complete" : "No");
}
int main()
{
#ifdef ONLINE_JUDGE
freopen("surreal.in", "r", stdin);
freopen("surreal.out", "w", stdout);
#endif
int T; read(T);
while (T--) work();
return 0;
}
Road
不会，咕了。
