AtCoder Beginner Contest 432 ABCDEG 题目解析

A - Permute to Maximize

题意

给定三个个位数 \(A,B,C\)。

请找出将 \(A,B,C\) 按任意顺序排列并连接起来可以形成的所有三位数中的最大值。

思路

贪心可知，当数字长度一定时，可以优先让高位更大。因此对三个正整数排序后倒序输出即可。

代码

void solve()
{int a[3];cin >> a[0] >> a[1] >> a[2];sort(a, a + 3);cout << a[2] << a[1] << a[0];
}

---

B - Permute to Minimize

题意

给定一个正整数 \(X\)。

将 \(X\) 数位上的所有数字全部重新排列，在保证没有前导零的前提下，求能得到的整数的最小值。

思路

与上题相同，当数字长度一定时，可以优先让高位更小。

但由于本题存在数字 \(0\) 的情况，且题目要求不能出现前导零。

因此可以借助数位分解/字符串输入等方式统计每种数位出现的次数，然后先挑一个非 \(0\) 的最小正整数输出以作为最高位，最后将所有剩余数位按顺序从小到大输出即可。

代码

int cnt[10]; // 统计每个数位出现次数void solve()
{int n;cin >> n;while(n){cnt[n % 10]++;n /= 10;}for(int i = 1; i <= 9; i++) // 先取一个非零的最小数位输出if(cnt[i] > 0){cnt[i]--;cout << i;break;}for(int i = 0; i <= 9; i++) // 按从小到大的顺序输出剩余所有数位for(int j = 1; j <= cnt[i]; j++)cout << i;
}

---

C - Candy Tribulation

题意

你有无限量的两种糖果：小号糖果和大号糖果。

小号糖果的重量是 \(X\) 克，大号糖果的重量是 \(Y\) 克，保证大号糖果比小号糖果重。

有 \(N\) 个孩子，编号为 \(1\) 到 \(N\)。你决定给孩子们分发糖果以满足以下条件：

• 编号为 \(i\) 的孩子收到的两种糖果的总数量恰好是 \(A_i\)。
• 分给 \(N\) 个孩子的糖果的总重量都相等。

确定是否存在满足条件的分配方法。如果存在，求给出的大号糖果数量的最大可能值。

思路

我们假设 \(B_1, B_2, \dots, B_N\) 表示给每个孩子分配的大号糖果的数量。为了求出大号糖果数量的最大值，所以我们要尽可能保证 \(B\) 序列各项值尽可能大。

根据题意，\(B\) 序列需满足以下条件：

• \(0 \le B_i \le A_i\)
• 存在正整数 \(W\) 使得 \(\forall i \in [1, N]\)，有 \(X \cdot (A_i - B_i) + Y \cdot B_i = W\)

整理式子得 \(A_i\cdot X + B_i\cdot(Y-X) = W\)，对于任意 \(i, j \in [1,N]\)，均有：

\[\begin{aligned} A_i\cdot X + B_i\cdot(Y-X) &= A_j\cdot X + B_j\cdot(Y-X) \\ (A_i - A_j)\cdot X&= (B_j - B_i)\cdot(Y-X) \\ \frac{(A_i - A_j)\cdot X}{Y-X} &= B_j - B_i \end{aligned} \]

由于 \(A, B\) 两序列均为整数序列，可得任意两个 \(A\) 内元素的差值在乘上 \(X\) 后，都必须是 \(Y-X\) 的倍数，否则本题无解。

进一步观察式子 \(A_i\cdot X + B_i\cdot(Y-X) = W\)，明显当 \(W\) 固定时，\(A_i\) 越大，\(B_i\) 就会越小；\(A_i\) 越小，\(B_i\) 就会越大。

所以我们可以对 \(A\) 序列先从小到大排序，然后对于最小的 \(A_1\) 这一项，贪心选择可能取到的最大 \(B_1\) 来作为这个孩子获得的大号糖果数量，明显此时 \(B_1 = A_1\)。

由此，\(W\) 的数值便固定了下来，接下来只需要根据 \(W\) 计算后面每个孩子能获得多少个大号糖果即可，明显 \(B_i = \dfrac{W - A_i \cdot X}{Y-X}\)。

但如果某个孩子需要的糖果数量很多，使得 \(W \lt A_i \cdot X\)（即使全选小号糖果，重量也比 \(W\) 大），此时也需要判定为无解。

时间复杂度 \(O(N\log N)\)。

代码

typedef long long ll;int n, x, y;
ll a[200005];void solve()
{cin >> n >> x >> y;for(int i = 1; i <= n; i++)cin >> a[i];sort(a + 1, a + n + 1);for(int i = 2; i <= n; i++)if((a[i] - a[i - 1]) * x % (y - x) != 0) // 任意两人的糖果数*x 都必须是 y-x 的倍数{cout << -1;return;}ll ans = 0;ll sum = a[1] * y; // 贪心让糖果总数最少的人全拿大号糖果，总重量便可确定for(int i = 1; i <= n; i++){ll cnt = (sum - a[i] * x) / (y - x);if(sum < a[i] * x) // 即使全拿小号糖果，总重量也比 sum 大{cout << -1;return;}ans += cnt;}cout << ans;
}

---

D - Suddenly, A Tempest

题意

有一个无限大的二维网格。最初，如果单元格 \((x,y)\) 满足条件 \(0 \le x \le X-1\) 且 \(0 \le y \le Y-1\)，则其颜色为黑色，否则为白色。

\(N\) 场大风暴会在这个网格上依次出现。第 \(i\) 场大风暴会根据字符 \(C_i\) 和整数 \(A_i, B_i\) 所表示的规则来更新网格中每个单元格的颜色。

对于第 \(i\) 场大风暴：

• 如果 \(C_i = \texttt X\)，则横坐标 \(x \lt A_i\) 的所有单元格全都会往下移动 \(B_i\) 个单位，\(x \ge A_i\) 的所有单元格全都会往上移动 \(B_i\) 个单位。
• 如果 \(C_i = \texttt Y\)，则纵坐标 \(y \lt A_i\) 的所有单元格全都会往左移动 \(B_i\) 个单位，\(y \ge A_i\) 的所有单元格全都会往右移动 \(B_i\) 个单位。

定义两个黑色单元格 \(c_1, c_2\) 是相连的，当且仅当从单元格 \(c_1\) 出发，可以通过不断地移动到与当前位置相邻的黑色单元格上，最终到达单元格 \(c_2\)。

对于一个非空的黑色单元格集合 \(S\) ，当且仅当满足以下条件时，才能称作一个连通分量：

• \(S\) 中的任意两个单元格都是相连的。
• 不在 \(S\) 中的每个黑色单元格都不与 \(S\) 中的任何单元格相连。

在这 \(N\) 场大风暴发生后，请求出最终整个网格内的连通分量的数量，并按升序输出每个连通分量中的单元格数量。

思路

发现黑色矩形区域较大 （\(X, Y \in [1, 10^8]\)），所以过程中我们可以把每个黑色矩形区域当作一个整体进行维护，而不是单独维护每个黑色单元格。

又发现风暴的数量 \(N \le 14\)，每次经历风暴时，最坏情况下每个黑色矩形区域都恰好被分割为两个新的黑色矩形区域，但很明显在这样的操作下，最终黑色矩形区域的数量不会超过 \(2^N\) 个，所以这一步可以模拟暴力维护。

得到最终每个黑色矩形区域的位置信息后，考虑将相邻连通的矩形区域进行合并。这一步可以直接通过坐标判断平面内两矩形是否边界相接，而合并步骤则可以借助并查集来完成，在合并两集合的同时也合并两个集合所代表的矩形区域内的黑色单元格数量。

合并完成后取出每个集合所包含的黑色单元格数量，排序后输出即可。

时间复杂度 \(O(2^{2N} + 2^N \log 2^N)\)。

代码

typedef long long ll;struct rect
{int l, r, b, t;// 矩形的 左、右、下、上 边界
};int fa[33000]; // 并查集 存储父结点
ll cnt[33000]; // 并查集 同时维护当前集合内黑色单元格个数
int find(int p)
{return p == fa[p] ? p : (fa[p] = find(fa[p]));
}
void merge(int a, int b)
{a = find(a), b = find(b);if(a == b)return;fa[b] = a;cnt[a] += cnt[b]; // 将 b 集合合并到 a 集合内
}// 判断 a, b 两个矩形是否相邻
// 根据题意已知 矩形不可能有重合部分
bool check(rect &a, rect &b)
{if(a.r == b.l - 1 || b.r == a.l - 1) // 如果两矩形在水平方向上相邻return min(a.t, b.t) >= max(a.b, b.b); // 判断垂直边对应的两线段是否存在公共部分即可if(a.t == b.b - 1 || b.t == a.b - 1) // 如果两矩形在垂直方向上相邻return min(a.r, b.r) >= max(a.l, b.l); // 判断水平边对应的两线段是否存在公共部分即可return false;
}void solve()
{int n, x, y;cin >> n >> x >> y;vector<rect> G;G.push_back(rect{0, x-1, 0, y-1});while(n--){char c;int a, b;cin >> c >> a >> b;vector<rect> G2; // 存储风暴影响后的所有新矩形for(rect &re : G) // 对于原本的所有矩形{if(c == 'X'){if(re.r < a) // 整体在边界左侧，不会被分割，只会向下移动 b 个单位G2.push_back(rect{re.l, re.r, re.b - b, re.t - b});else if(re.l >= a) // 整体在边界右侧，不会被分割，只会向上移动 b 个单位G2.push_back(rect{re.l, re.r, re.b + b, re.t + b});else // 被分割{G2.push_back(rect{re.l, a - 1, re.b - b, re.t - b}); // 左半部分向下移动 b 个单位G2.push_back(rect{a, re.r, re.b + b, re.t + b}); // 右半部分向上移动 b 个单位}}else{if(re.t < a) // 整体在边界下侧，不会被分割，只会向左移动 b 个单位G2.push_back(rect{re.l - b, re.r - b, re.b, re.t});else if(re.b >= a) // 整体在边界上侧，不会被分割，只会向右移动 b 个单位G2.push_back(rect{re.l + b, re.r + b, re.b, re.t});else // 被分割{G2.push_back(rect{re.l - b, re.r - b, re.b, a - 1}); // 下半部分向左移动 b 个单位G2.push_back(rect{re.l + b, re.r + b, a, re.t}); // 上半部分向右移动 b 个单位}}}swap(G, G2); // 将 G2 作为新的黑色矩形集合}for(int i = 0; i < G.size(); i++) // 初始化并查集{fa[i] = i;cnt[i] = 1LL * (G[i].r - G[i].l + 1) * (G[i].t - G[i].b + 1);}for(int i = 0; i < G.size(); i++)for(int j = i + 1; j < G.size(); j++)if(check(G[i], G[j])) // 只要两个矩形有公共部分，则合并两集合merge(i, j);vector<ll> ans;for(int i = 0; i < G.size(); i++)if(i == find(i)) // i 是某个并查集的根ans.push_back(cnt[i]);sort(ans.begin(), ans.end());cout << ans.size() << "\n";for(ll &v : ans)cout << v << " ";
}

---

E - Clamp

题意

给定一个长度为 \(N\) 的整数序列 \(A=(A_1, A_2, \dots, A_N)\) 。

有 \(Q\) 次操作，请按顺序处理这些操作。每个操作的格式如下：

• 1 x y : 将 \(A_x\) 的值改为 \(y\) 。
• 2 l r：输出 \(\displaystyle \sum_{1\leq i\leq N} \max(l, \min(r, A_i))\) 的值。

思路

当 \(l \le r\) 时，发现操作 \(2\) 实际上是对于整个序列的所有元素，将小于 \(l\) 的改为 \(l\)，将大于 \(r\) 的改为 \(r\)，然后进行求和。

所以查询可以分为以下三部分：

• 值 \(\lt l\) 的数字数量 \(\times l\)
• 值 \(\gt r\) 的数字数量 \(\times r\)
• 值在 \([l, r]\) 范围内的数字总和

由于每个数字的数值范围均在 \([0, 5 \times 10^5]\) 以内，所以这三部分都可以采取直接维护值域的方式来求解。

对于前两部分，可以开一个计数数组用于维护整个数组中每种数字出现的次数，然后借助树状数组或线段树等数据结构来快速完成单点修改与区间查询操作。

对于第三部分，也可以开一个计数数组，用于维护整个数组中每种数字出现的总和，即 \(i\) 位置维护“数字 \(i\) 出现的次数 \(\times\) \(i\)”的结果，同样的借助上述高级数据结构来完成单点修改与区间查询操作。

需要注意的是：

• 题目中询问可能出现 \(l \gt r\) 的情况，此时根据公式可知所有数均为 \(l\)，直接输出 \(l \times n\) 即可。
• 如果采用树状数组进行维护，注意值域中存在 \(0\)，不进行特殊处理的话可能会在 update 操作时出现死循环。建议在树状数组内部将传入的下标 \(+1\)。

时间复杂度 \(O((N+Q)\log (\max A_i))\)。

代码

typedef long long ll;struct BIT
{ll tr[500005];int lowbit(int x){return x & -x;}void update(int p, int v){p++; // 下标偏移1while(p <= 500001){tr[p] += v;p += lowbit(p);}}ll query(int p){p++; // 下标偏移1ll r = 0;while(p > 0){r += tr[p];p -= lowbit(p);}return r;}ll query(int l, int r){return query(r) - query(l - 1);}
};BIT t1, t2;
// t1 维护指定值出现的数量
// t2 维护指定值出现的总和
int a[500005];void solve()
{int n, q;cin >> n >> q;for(int i = 1; i <= n; i++){cin >> a[i];t1.update(a[i], 1);t2.update(a[i], a[i]);}while(q--){int op, x, y;cin >> op >> x >> y;if(op == 1){t1.update(a[x], -1);t2.update(a[x], -a[x]);a[x] = y;t1.update(a[x], 1);t2.update(a[x], a[x]);}else{if(x <= y){ll suma = t1.query(0, x-1) * x;ll sumc = t1.query(y+1, 500000) * y;ll sumb = t2.query(x, y);cout << suma + sumb + sumc << "\n";}elsecout << 1LL * x * n << "\n";}}
}

---

G - Sum of Binom(A, B)

题意

给定一个长度为 \(N\) 的正整数序列 \(A=(A_1,A_2,\dots,A_N)\) 和一个长度为 \(M\) 的正整数序列 \(B=(B_1,B_2,\dots,B_M)\)。

求 \(\displaystyle \sum_{i=1}^{N} \sum_{j=1}^{M} \binom{A_i}{B_j}\) 的值取模 \(998244353\) 的结果。

这里，\(\displaystyle \binom{x}{y}\) 表示从 \(x\) 个对象中选择 \(y\) 个对象的组合方法数。特别的，如果 \(x \lt y\) ，答案为 \(0\) 。

思路

设 \(K\) 表示 \(A, B\) 两个整数序列内的最大值，设 \(\text{cnt}_\text{a}[i]\) 表示 \(A\) 内数字 \(i\) 的出现次数，\(\text{cnt}_{\text{b}}[i]\) 表示 \(B\) 内数字 \(j\) 的出现次数。

则原式可以看作：

\[\begin{aligned} \sum_{i=1}^{N} \sum_{j=1}^{M} \binom{A_i}{B_j} &= \sum_{i=1}^K\sum_{j=1}^i \binom{i}{j}\cdot \text{cnt}_\text{a}[i] \cdot \text{cnt}_\text{b}[j] \\ &= \sum_{i=1}^K\sum_{j=1}^i \frac{i!}{(i-j)! \cdot j!} \cdot \text{cnt}_\text{a}[i] \cdot \text{cnt}_\text{b}[j] \\ &= \sum_{i=1}^K i! \cdot \text{cnt}_\text{a}[i] \cdot \sum_{j=1}^i \frac{\text{cnt}_\text{b}[j]}{(i-j)! \cdot j!} \end{aligned} \]

令 \(k = i-j\)，即 \(i = j + k\)，则上式可以描述为：

\[\sum_{i=1}^K i! \cdot \text{cnt}_\text{a}[i] \cdot \sum_{j+k=i} (\frac{\text{cnt}_\text{b}[j]}{j!} \cdot \frac{1}{k!}) \]

注意到右侧累加公式此时与 \(j, k\) 两项值有关，且 \(j + k\) 的总和固定为 \(i\)，于是可以将两者相关的式子分别拆作两个独立的多项式，借助多项式卷积来统一维护。

定义多项式 \(\displaystyle f(x) = \sum\limits_{i=0}^K (\frac{\text{cnt}_\text{b}[i]}{i!} x^i)\)，\(\displaystyle g(x) = \sum\limits_{i=0}^K (\frac{1}{i!} x^i)\)，\(h(x) = f(x) \cdot g(x)\)，此时 \(h(x)\) 的 \(x^i\) 项系数便是 \(j + k = i\) 时累加公式的具体值。

由于答案需要对大质数进行取模运算，因此卷积采用快速数论变换 NTT 进行求解。

最终 \(\displaystyle \sum_{i=1}^K i! \cdot \text{cnt}_\text{a}[i] \cdot [\text{h(x) 的 }x^i\text{ 项系数}]\) 即为答案。

时间复杂度 \(O(N+M+K\log K)\)，其中 \(K = \max(\max(A_i), \max(B_j))\)。

代码

typedef long long ll;
const ll mod = 998244353;ll qpow(ll a, ll n)
{ll r = 1;while(n){if(n & 1)r = r * a % mod;a = a * a % mod;n >>= 1;}return r;
}int r[1 << 20];
void ntt(vector<int> &a, int lim, int b = 0)
{int i, j, k, l, *p, *q, u, v, w;for (i = 0; i < lim; ++i)if (i < r[i])swap(a[i], a[r[i]]);for (i = 1; i < lim; i = l)for (j = 0, l = i * 2, u = qpow(3, (mod - 1) / l); j < lim; j += l)for (k = 0, v = 1, p = &a[j], q = &p[i]; k < i; ++k, v = v * 1ll * u % mod)w = v * 1ll * q[k] % mod,q[k] = p[k] < w ? p[k] - w + mod : p[k] - w,p[k] = (p[k] += w) < mod ? p[k] : p[k] - mod;if (b)for (i = 0, u = qpow(lim, mod - 2), reverse(&a[1], &a[lim]); i < lim; ++i)a[i] = a[i] * 1ll * u % mod;
}
struct poly
{int l;vector<int> a;poly(int x) // 初始化为 x+1 项系数均为 1 的多项式{for (l = x; ~x; --x)a.push_back(1);}void mul(poly x){int i, lim;for (lim = 1, l += x.l; lim <= l; lim *= 2);for (i = 1; i < lim; ++i) // 处理蝴蝶变换r[i] = (r[i >> 1] >> 1) | ((i & 1) ? (lim >> 1) : 0);a.resize(lim), x.a.resize(lim), ntt(a, lim), ntt(x.a, lim);for (i = 0; i < lim; ++i)a[i] = a[i] * 1ll * x.a[i] % mod;ntt(a, lim, 1);}
};int n, m;
int a[500005], b[500005];
int cnta[500005], cntb[500005];ll fac[500005], inv[500005];
void init()
{fac[0] = 1;for(int i = 1; i <= 500000; i++)fac[i] = fac[i - 1] * i % mod;inv[500000] = qpow(fac[500000], mod - 2);for(int i = 499999; i >= 0; i--)inv[i] = inv[i + 1] * (i + 1) % mod;
}void solve()
{cin >> n >> m;for(int i = 1; i <= n; i++){cin >> a[i];cnta[a[i]]++;}for(int i = 1; i <= m; i++){cin >> b[i];cntb[b[i]]++;}init();poly f(500000), g(500000);for(int i = 0; i <= 500000; i++){f.a[i] = cntb[i] * inv[i] % mod;g.a[i] = inv[i];}f.mul(g); // conv f *= gll ans = 0;for(int i = 0; i <= 500000; i++)ans = (ans + fac[i] * cnta[i] % mod * f.a[i] % mod) % mod;cout << ans;
}