2024.10.16 模拟赛
2024.10.16 模拟赛
T1 divide
简要题意
给定一棵树的 \(n\) 个结点以及每个结点的 \(fa_i\)，每个点的点权 \(v_i\)，删除树中的两条边，将树拆分为三个非空部分。每个部分的权值等于该部分包含的所有节点的权值之和。出一种合理的拆分方案。根节点的 \(fa_i = 0\)
\(n≤10^6\)
solution
首先可以算出所有的点的点权和，如果不是 \(3\) 的倍数，那么一定不存在合法的方案。
令 \(g=\sum v_i/3\)。也就是说，我们只需要求出每个树的子树大小就行了。其实这个过程直接循环扫一遍就行。但是，由于要拆分，直接循环扫无法实现拆下去使子树大小减小的过程（实测得分为 45pts），所以直接 dfs，\(sum[i]\) 记录子树点权和。如果 \(sum[i]=g\) 就记录答案，并且切去当前子树令 \(sum[i]=0\)。最后合法位置超过三个则存在方案。否则输出 \(-1\)
#include <bits/stdc++.h>
#define rint register int
#define int long long
#define endl '\n'
using namespace std;
const int N = 2e6 + 5;
const int M = N << 1;
int n;
int fa[N], v[N];
int h[N], e[M], ne[M], idx;
int sum[N];
int ans[N];
int top;
int goal;
void add(int a, int b)
{
e[++idx] = b, ne[idx] = h[a], h[a] = idx;
}
void dfs(int x)
{
for (rint i = h[x]; i; i = ne[i])
{
int y = e[i];
dfs(y);
sum[x] += sum[y];
}
if (goal == sum[x])
{
ans[++top] = x;
sum[x] = 0;
}
}
signed main()
{
cin >> n;
int res = 0, root = 0;
for (rint i = 1; i <= n; i++)
{
cin >> fa[i] >> v[i];
res += v[i];
sum[i] = v[i];
if (fa[i] == 0) root = i;
else add(fa[i], i);
}
if (res % 3)
{
cout << -1 << endl;
return 0;
}
goal = res / 3;
dfs(root);
if (top > 2) cout << ans[1] << " " << ans[2];
else cout << -1 << endl;
return 0;
}
T2 color
题目大意
给定一个 \(n\) 个结点的树，每个节点都有颜色为黑或白，从黑色节点无法到达白色节点，反之亦然。每次染色操作可以选择一个节点 \(v\)，并改变节点 \(v\) 以及其所有可达同色节点的颜色。希望将树中的所有节点都染成同一种颜色，求最少操作次数。
\(n≤2 \times 10^5\)
solution
神仙题
放个样例，第一眼看过去，我的想法是维护类联通块的东西。如 \(2,1,3,8,9\) 为一个联通块。最后数黑色和白色联通块个数取 \(min\)。
结果大样例过不去。
很简单就能 hack 掉，给一个一直黑白交错的非常长单链，随便接一个特别短的黑白交错的支链，上面那种做法就不行了。因为答案会比正解小。
那怎么做呢？
从特殊到一般，假设这是一条链。那么答案就是设黑白交替的次数为 \(cnt\)，答案为 \(⌊\frac{cnt}{2}⌋\)。那么对于一棵树，其实就是在这条链上加一些分支。
那么，如果我这条链，为黑白交替次数最多的一条链，对于这棵树的答案就等于对于这条链的答案。因为操作这条链的时候，其他链条的染色也一定会随着这条链的染色而颜色统一。原因为支链的黑白交错次数少并且染色操作为联通着就能染色。
所以，只需要类比求树的直径来求这条黑白交错次数最多的链条即可。这里使用两次 dfs，代码容易实现。先求出对于 \(x\) 黑白交错次数最多的链条远处端点为 \(y\)，再求出对于 \(y\) 的最远端点 \(z\)，那么 \(y->z\) 即为所求，然后求出 \(cnt\)，即可求出答案。
复杂度 \(O(n)\)
#include <bits/stdc++.h>
#define rint register int
#define int long long
#define endl '\n'
using namespace std;
const int N = 2e5 + 5;
const int M = 4e5 + 5;
int n;
int a[N];
int h[N], e[M], ne[M], idx;
int dist, ed;
void add(int a, int b)
{
e[++idx] = b, ne[idx] = h[a], h[a] = idx;
}
void dfs(int x, int father, int w)
{
if (w > dist)
{
dist = w;
ed = x;
}
for (rint i = h[x]; i; i = ne[i])
{
int y = e[i];
if (y == father) continue;
dfs(y, x, w + (a[x] != a[y]));
}
}
signed main()
{
cin >> n;
for (rint i = 1; i <= n; i++) cin >> a[i];
for (rint i = 1; i < n; i++)
{
int a, b;
cin >> a >> b;
add(a, b);
add(b, a);
}
dfs(1, 0, 0);
dist = 0;
dfs(ed, 0, 0);
cout << (dist + 1) / 2 << endl;
return 0;
}
T3 count
简要题意
对于一个长度为 \(n\) 的小数（包括小数点）执行最多 \(k\) 次四舍五入，四舍五入最多执行到小数点处，不于整数位进行四舍五入。求最后答案的最大值。
\(n≤2 \times 10^5,k≤10^9\)
solution
这个题卡了很久，因为卡在执行四舍五入操作上了。因为我在担心当前四舍五入是否优秀，后来才发现，我所担心的，类似于把 \(3.98\) 四舍五入成 \(4.08\).........（\(8\) 先不动跳过去，然后四舍五入 \(3.9\)）
\(k\) 根本不用管它，复杂度瓶颈与它无关，它的上限不会影响操作的执行，但是下限会。
执行过程为，找到第一个大于等于 \(5\) 的位置执行四舍五入，此时一定是最优的，从此处开始四舍五入即可。每四舍五入一次 \(k--\)，如果最后结束操作时如果 \(k<1\) 就说明整数位也进行了一次四舍五入，输出的时候开头加个 \(1\) 即可。
#include <bits/stdc++.h>
#define rint register int
#define int long long
#define endl '\n'
using namespace std;
int n, m;
string s;
signed main()
{
cin >> n >> m; cin >> s;
int pos = s.find('.');
int k = pos + 1;
while (k < s.size() && s[k] < '5') k++;
if (k == s.size())
{
cout << s << endl;
return 0;
}
s = s.substr(0, k); //后边一定会被四舍五入成 0
k--, m--; //进了一次位
while (k >= 0)
{
if (s[k] != '.')
{
s[k]++;
if (s[k] < '5') break; //进位进不动了
if (s[k] <= '9')
{
if (!m || k < pos) break;
s[k] = '0';
m--;
}
else s[k] = '0';
}
k--;
}
if (k < 0) s = "1" + s;
while (s.back() == '0') s.pop_back();
if (s.back() == '.') s.pop_back();
cout << s << endl;
return 0;
}
T4 change
简要题意
给定一个长度为 \(n\) 的非负整数序列 \(a_1,a_2,…,a_n\)。其中的所有元素将被逐个封印。具体封印顺序可以用一个 \(1\)∼\(n\) 的排 \(b_1,b_2,…,b_n\) 来描述，第 \(i\) 个被封印的元素即为 \(a_{b_i}\)
完成 \(n\) 个任务，第 \(i\) 个任务是：对于完成前 \(i\) 次封印的序列，请你找到序列中的一个连续子序列（可以为空），使得该子序列不含任何被封印的元素，且子序列内各元素之和尽可能大，输出这个子序列元素和的最大可能值。空序列元素和为 \(0\)。
\(n≤10^5\)
solution
正解是并查集进行贪心
但是我们可以进行一个投机取巧
这个题其实就是在求最大子序列和，但是中间有些位置不能选。那么我们将不能选的位置设置成无穷小就行了。这样就就算选了这个位置，也不会改变最终答案，因为选了它也不是最大的，这样就可以正常使用线段树进行维护了。
剩下的就是板子了
#include <bits/stdc++.h>
#define rint register int
#define int long long
#define endl '\n'
#define ls p << 1
#define rs p << 1 | 1
using namespace std;
const int N = 1e5 + 5;
const int M = 2e6 + 5;
int n, m;
int w[N];
struct node
{
int l, r;
int tmax, lmax, rmax, sum;
} t[M];
void push_up(node &p, node &l, node &r)
{
p.sum = l.sum + r.sum;
p.lmax = max(l.lmax, l.sum + r.lmax);
p.rmax = max(r.rmax, r.sum + l.rmax);
p.tmax = max({l.rmax + r.lmax, l.tmax, r.tmax});
}
void push_up(int p)
{
push_up(t[p], t[ls], t[rs]);
}
void build(int p, int l, int r)
{
if (l == r)
{
t[p] = {l, r, w[r], w[r], w[r], w[r]};
return ;
}
t[p] = {l, r, 0, 0, 0, 0};
int mid = (l + r) >> 1;
build(ls, l, mid);
build(rs, mid + 1, r);
push_up(p);
}
void change(int p, int x, int v)
{
if (t[p].l == x && t[p].r == x)
{
t[p] = {x, x, v, v, v, v};
return ;
}
int mid = (t[p].l + t[p].r) >> 1;
if (x <= mid) change(ls, x, v);
else change(rs, x, v);
push_up(p);
}
node query(int p, int l, int r)
{
if (t[p].l >= l && t[p].r <= r) return t[p];
int mid = (t[p].l + t[p].r) >> 1;
if (r <= mid) return query(ls, l, r);
else if (l > mid) return query(rs, l, r);
else
{
node left = query(ls, l, r);
node right = query(rs, l, r);
node res;
push_up(res, left, right);
return res;
}
}
signed main()
{
cin >> n;
for (rint i = 1; i <= n; i++) cin >> w[i];
build(1, 1, n);
m = n;
while (m--)
{
int y;
cin >> y;
change(1, y, -1e14);
cout << max(0ll, query(1, 1, n).tmax) << endl;
}
return 0;
}
