周作业 44

A - khba Loves to Sleep!

题意

给定 \([0,x]\) 上的 \(n\) 个点，你要选出 \([0,x]\) 上不同的 \(k\) 个点，使得从 \(n\) 个点中任意一个点出发，走到 \(k\) 个点中的任意一个的最小距离最大。输出方案。

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

分析

二分答案，然后贪心的放点。定义第 \(i\) 个点位置是 \(p_i\)，那么我们希望 \(p_i = p_{i-1}+1\)，但是如果存在一个点满足到 \(p_i\) 的距离不足 \(mid\)，那么就要令 \(p_i\) 为该点向后第 \(mid\) 个点，然后以此类推去判断。最后判断如果最后一个点超过了 \(x\)，那么不合法。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define il inline
#define N 200005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
int n, k, x, a[N], pos[N];
il bool check(int t){pos[0] = -1;for (int i = 1, j = 1; i <= k; i++){pos[i] = pos[i - 1] + 1;for (; j <= n && abs(a[j] - pos[i]) < t; j++) pos[i] = a[j] + t;}return (pos[k] <= x);
}
signed Main(){n = rd(), k = rd(), x = rd();for (int i = 1; i <= n; i++) a[i] = rd();sort (a + 1, a + n + 1), n = unique(a + 1, a + n + 1) - a - 1;check(10);int l = 0, r = x, ans = -1;while (l <= r){int mid = (l + r) >> 1;if (check(mid)) l = mid + 1, ans = mid;else r = mid - 1;}check(ans);for (int i = 1; i <= k; i++) printf ("%d ", pos[i]);puts("");return 0;
}
signed main(){for (int T = rd(); T--;) Main(); return 0;
}

B - Tree, TREE!!!

题意

定义 \(S_r\) 表示对于所有从 \(n\) 个点中选 \(k\) 个点的方案中，以 \(r\) 为根的 \(\operatorname{lca}\) 形成的集合。求 \(\sum |S_i|\)。

时间复杂度 \(O(n)\)。

分析

一眼题，考虑到 \(u \in S_r\) 当且仅当以 \(r\) 为根时 \(u\) 的子树大小 \(\ge k\)。于是枚举 \(u\) 和一个相邻点 \(v\) 即可。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define il inline
#define N 200005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
int n, k, sz[N];
vector <int> e[N];
ll ans;
void dfs(int u, int fa){sz[u] = 1;for (int v : e[u]) if (v != fa){dfs(v, u), sz[u] += sz[v];if (n - sz[v] >= k) ans += sz[v];}if (sz[u] >= k) ans += n - sz[u];
}
signed Main(){n = rd(), k = rd(), ans = n;for (int i = 1; i <= n; i++) e[i].clear();for (int i = 1, u, v; i < n; i++) u = rd(), v = rd(), e[u].push_back(v), e[v].push_back(u);dfs(1, 0), printf ("%lld\n", ans);return 0;
}
signed main(){for (int T = rd(); T--;) Main();return 0;
}

C - Price Tags

题意

给定一个序列 \(c_i\)。你要找到一个严格大于 \(1\) 的整数 \(x\)，定义 \(b_i = \lceil \frac{c_i}{x} \rceil\)，要使得收入最大。收入为 \(\sum b_i\)，减去 \(b_i\) 和 \(c_i\) 不同元素个数。

时间复杂度 \(O(n + V\log V)\)。

分析

调和级数板子题，考虑枚举 \(x\)，那么最后的 \(b_i \in [1,\lceil \frac{V}{x} \rceil]\)，于是枚举 \(b_i\)，利用前缀和计算即可，时间复杂度调和级数。

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define il inline
#define N 200005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
const int INF = 1e18;
int n, Y, s[N], t[N], ans;
signed Main(){n = rd(), Y = rd(), ans = -INF;for (int i = 1; i <= 200000; i++) s[i] = t[i] = 0;for (int i = 1, x; i <= n; i++) x = rd(), s[x]++, t[x]++;for (int i = 1; i <= 200000; i++) s[i] += s[i - 1];for	(int i = 2; i <= 200000; i++){int sum = - Y * n;for (int j = 1; i * (j - 1) < 200000; j++){int l = i * (j - 1) + 1, r = min(i * j, 200000ll);sum += j * (s[r] - s[l - 1]) + Y * min(s[r] - s[l - 1], t[j]);}ans = max(ans, sum);}printf ("%lld\n", ans);return 0;
}
signed main(){for (int T = rd(); T--;) Main();return 0;
}

D - Teleporters (Hard Version)

题意

有一个 \([0,n+1]\) 的数轴，其中 \([1,n]\) 各有一个传送器，使用第 \(i\) 个花费是 \(a_i\) 元。你一开始在 \(0\) 号点，有 \(c\) 元。你可以选择花费一元左右移动一步，或者使用当前位置的传送器，每个传送器只能使用一次，使用传送器可以传送到 \(0\) 或 \(n+1\)。问最多可以使用几个传送器。

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

分析

首先注意到使用一个传送器后，你可以任意选择你在 \(0\) 还是在 \(n+1\)，所以使用后面的传送器的代价就是 \(a_i + \min(i,n+1-i)\)，于是我们考虑枚举第一个传送器，然后计算可以使用多少个。计算是简单的，直接二分即可，注意要考虑当前枚举的传送器是否在前缀内。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define il inline
#define N 200005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
int n, c, a[N], val[N], id[N], pos[N], ans;
ll sum[N];
signed Main(){n = rd(), c = rd();for (int i = 1; i <= n; i++) a[i] = rd(), val[i] = a[i] + min(i, n - i + 1), id[i] = i, ans = 0;sort (id + 1, id + n + 1, [](int x, int y){return val[x] < val[y];});for (int i = 1; i <= n; i++) pos[id[i]] = i, sum[i] = sum[i - 1] + val[id[i]];for (int i = 1; i <= n; i++){int k = a[i] + i;if (k > c) continue;int t1 = upper_bound(sum + 1, sum + n + 1, c - k) - sum - 1, t2 = upper_bound(sum + 1, sum + n + 1, c - k + val[i]) - sum - 1;if (pos[i] <= t2) ans = max(ans, t2);else ans = max(ans, t1 + 1);}printf ("%d\n", ans);return 0;
}
signed main(){for (int T = rd(); T--;) Main();return 0;
}

E - Moving Dots

题意

定义一个数轴上的点集 \(S\) 的 \(f(S)\) 为，每个点向离自己最近的点的方向移动，距离相同向左，直到碰到其他点，最后所有点的位置种类数。给定一个点集 \(S\)，求 \(\sum_{T \subseteq S} f(T)\)。模 \(1e9+7\)。

时间复杂度 \(O(n^2\log n)\)。

分析

\(f(S)\) 的定义等价于确定方向后有几个连通块。一开始钦定为只有一个连通块，然后注意到如果两个点方向相反，那么就会多一个连通块。所以枚举两个点，求方向相反的方案数。设 \(d\) 为两个点距离，二分找到左边点向左的第一个距离超过 \(d\) 和向右第一个距离不小于 \(d\) 的点，使用二分，然后乘法原理即可。

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define il inline
#define N 3005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
const int P = 1e9 + 7;
int n, x[N], pw[N], ans;
signed main(){n = rd(), pw[0] = 1;for (int i = 1; i <= n; i++) x[i] = rd(), pw[i] = 2ll * pw[i - 1] % P;ans = (pw[n] - n - 1 + P) % P;for (int i = 1; i <= n; i++) for (int j = i + 1; j <= n; j++){int d = x[j] - x[i], l = lower_bound(x + 1, x + n + 1, x[i] - d) - x, r = lower_bound(x + 1, x + n + 1, x[j] + d) - x - 1;int tmp = 1ll * (pw[i - l] + P - 1) % P * (pw[r - j] + P - 1) % P * pw[l - 1] % P * pw[n - r] % P;ans = (ans + tmp) % P; }printf ("%d\n", ans);return 0;
}

F - Tree Colorings

题意

定义一棵树的一个染色方案是好的当且仅当满足以下条件。

• 只有 \(1,2,3\) 三种颜色。
• 根节点 \(1\) 颜色是 \(1\)。
• 所有 \(1,2\) 颜色点形成一个连通块。
• 所有 \(1,3\) 颜色点形成一个连通块。

现在给定一个 \(x\)，求点数最少的树，其染色方案为好的方案数恰好为 \(x\)，无解输出 \(-1\)。有 \(T\) 次询问。

时间复杂度 \(O(x\log x + T)\)。

分析

可以注意到 \(1\) 一定要形成一个连通块，考虑对于已知的树怎么求答案。设 \(f_u\) 表示 \(u\) 的子树，其中 \(u\) 的颜色为 \(1\) 的方案数。不难想到 \(u\) 的儿子 \(v\)，要么是 \(f_v\)，要么是全 \(2\) 或全 \(3\)，于是就是 \(f_u = \prod (f_v + 2)\)。

我们同样不难注意到一个点，就是方案数一定是奇数，因为如果是叶子，那么就是 \(f_u = 1\)，否则的话由于 \(f_v\) 是奇数，\(f_v + 2\) 是奇数，所以 \(f_u\) 是奇数。

接下来设 \(g_i\) 表示方案数为 \(i\) 的最小数量。考虑怎么考虑到所有树的形态，这是很经典的拼接，即把一棵树的根节点接到另一棵树的根节点上。假设这两棵树原本方案数是 \(f_1,f_2\)，现在把第二棵树接到第一棵树上，那么就是 \(f_1 \gets f_1 \times (f_2 + 2)\)。于是我们就想出来了转移方程。

\[g_x= \min_{y | x} g_y + g_{\frac{y}{x}-2} \]

初始 \(g_1 = 1\)，对于 \(2 | x\) 的情况 \(g_x = -1\)。转移枚举因数就是调和级数 \(O(x\log x)\)。

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define il inline
#define N 500005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
const int INF = 1e18;
int n = 500000, f[N];
vector <int> D[N];
signed main(){for (int i = 1; i <= n; i++) for (int j = 1; i * j <= n; j++) D[i * j].push_back(i);f[1] = 1;for (int i = 2; i <= n; i++){if (!(i & 1)) f[i] = -1;else{f[i] = INF;for (int x : D[i]) if (i / x > 2 && f[x] != -1 && f[i / x - 2] != -1) f[i] = min(f[i], f[x] + f[i / x - 2]);}}for (int T = rd(); T--;) n = rd(), printf ("%lld\n", f[n]);return 0;
}

G - Three Sequences

题意

给定序列 \(a\)，定义序列 \(b,c\) 合法当且仅当满足下列条件。

• \(b_i + c_i = a_i\)。
• \(b\) 单调不降，\(c\) 单调不升。

给定 \(a\)，求合法的 \(b,c\) 中的 \(\max(\max(b_i),\max(c_i))\) 最小值。同时还有 $Q 次操作，每次操作对于一段区间进行区间加 \(x\) 操作。

时间复杂度 \(O(n)\)。

分析

一上来以为是线段树，发现根本做不了，于是考虑不修改。

我们刻画一下条件，把 \(c\) 消掉，条件就是下面的。

\[\left\{\begin{matrix} b_{i-1} \le b_i \\ a_{i-1} - b_{i-1} \ge a_i - b_i \end{matrix}\right. \]

然后移项得 \(b_i - b_{i-1} \ge \max(0,a_i - a_{i-1})\)，而最小化的值是 \(\max(b_n,a_1-b_1)\)。于是对 \(a\) 差分，然后考虑到最小化 \(b_n - b_1\) 的值，因为设 \(b_n - b_1 = x\)，那么答案就是 \(\lceil \frac{x+a_1}{2} \rceil\)。最小化 \(x\) 就直接对 \(\max(a_i - a_{i-1},0)\) 求和即可，区间加就是修改至多两个位置的差分值，可以 \(O(1)\) 修改。注意答案要上取整，而 C++ 中直接转 int 是向 \(0\) 取整。

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define il inline
#define N 100005
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
int n, a[N], d[N], sum;
signed main(){n = rd();for (int i = 1; i <= n; i++) a[i] = rd();for (int i = 2; i <= n; i++) d[i] = a[i] - a[i - 1];for (int i = 2; i <= n; i++) sum += max(d[i], 0ll);printf ("%lld\n", (int)ceil((double)(a[1] + sum) / 2));for (int Q = rd(), l, r, x; Q--;){l = rd(), r = rd(), x = rd();if (l == 1) a[1] += x; else sum -= max(d[l], 0ll), d[l] += x, sum += max(d[l], 0ll);if (r < n) sum -= max(d[r + 1], 0ll), d[r + 1] -= x, sum += max(d[r + 1], 0ll);printf ("%lld\n", (int)ceil((double)(a[1] + sum) / 2));}return 0;
}

H - DFS Game

两个人在树上游戏。初始每个点上有一枚硬币，同时根节点 \(1\) 有一颗棋子。两人轮流操作，操作如下。

• 如果当前棋子的点有硬币，操作者拿走硬币。
• 否则，如果当前点有儿子有硬币，操作者选择一个有硬币的儿子，把棋子移动过去。
• 否则如果所有儿子都没有硬币，操作者把棋子移动到父亲。

两人都希望获得硬币最多，两人按最优决策操作，问先手会拿到几个硬币。

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

分析

首先想到设 \(f_u\) 表示 \(u\) 的子树内，先手可以拿到几个硬币，考虑转移。先手会拿起当前点的硬币，然后后手操作，此时后手会选择对自己有利的儿子，但是会出现选择完一棵子树后，决策权交换的情况。考虑到因为不操作完一棵子树不会出来，所以一棵子树总的操作次数是固定的，即 \(sz_u + 2(sz_u-1)\)，因为每个点会被拿一次，每条边走 \(2\) 遍。于是如果 \(sz_u\) 是奇数，那么会在进去出来后交换决策权。

现在我们考虑后手会怎么选。对于 \(sz_v\) 为偶数且 \(f_v \le sz_v - f_v\) 的儿子，后手一定会全选，因为每次选完决策权不变，且这些儿子对后手有利。而剩下的 \(sz_v\) 为偶数且 \(f_v > sz_v - f_v\)，后手一定不想要，所以会选择通过 \(sz_v\) 为奇数的儿子把决策权推给先手，然而先手也不想要，所以会再推给后手，如此操作，直到不存在 \(sz_v\) 为奇数的儿子为止。此时决策权在谁手上，谁就要拿走剩下的儿子。而对于中间 \(sz_v\) 为奇数的点，一定是优先选 \((sz_v - f_v) - f_v\) 大的，所以要一次排序，时间复杂度 \(O(n\log n)\)。

I - Routing

题意

给定一张无向图，你要对每个点选一个相邻的点作为辅助点。当从 \(u\) 出发找 \(v\) 时，如果 \(u,v\) 相邻，则完成寻找，否侧从 \(u\) 的辅助点出发找 \(v\)。问是否存在辅助点的设置方案，使得从 \(u\) 出发可以找到所有的 \(v\)。输出方案。

时间复杂度 \(O(n2^n)\)。

分析

我们定义辅助点为 \(f_u\)，那么我们会发现所有的 \(u \to f_u\) 形成了一颗基环树，然后要满足环和所有点相邻。想到的是枚举环，然后判断环是否合法。但是枚举环是困难的，因为我们无法快速判断若干个点是否可以形成环。于是想到 dp，设 \(f_{l,r,S}\) 表示一条链两端分别是 \(l,r\)，点集是 \(S\) 是否存在，加上转移是 \(O(n^32^n)\)。然后注意到 \(r\) 可以压在状态里，即 \(f_{l,S}\) 表示所有可以作为链的另一端的点的集合，此时就是 \(O(n^22^n)\)，然后考虑到 \(l\) 其实很不好，因为最后是环，所以 \(l\) 是什么我们不在乎，所以可以直接钦定 \(l = \min(S)\)，即 \(S\) 中编号最小的。此时时间复杂度 \(O(n2^n)\)。

找到环之后，考虑求方案。对于不在环上的点，因为一定和环有连接，可以直接指向环，而对于环上的点，可以直接利用 dp 的值来寻找最后一个点，然后删除。

最后时间复杂度 \(O(n2^n)\)。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define il inline
#define N 105
il int rd(){int s = 0, w = 1;char ch = getchar();for (;ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') w = -1;for (;ch >= '0' && ch <= '9'; ch = getchar()) s = ((s << 1) + (s << 3) + ch - '0');return s * w;
}
int n, fa[N], du[N], dep[N], col[N], tmp[N][N], flg = 1;
vector <int> e[N];
void dfs(int u){ for (int v : e[u]) dep[v] = dep[u] + 1, dfs(v); }
void dp(int u){if (fa[u] && du[u] == 1) col[u] = 1;for (int v : e[u]){if (col[u]) col[v] = 3 - col[u];dp(v);if (col[v] && u != 1){if (col[u] && col[u] + col[v] != 3) flg = 0;col[u] = 3 - col[v];}}
}
void cover(int u){if (!col[u]) col[u] = dep[u] % 2 + 1;for (int v : e[u]){if (u ^ 1) col[v] = 3 - col[u];cover(v);}
}
bool work(){dp(1), cover(1);if (!flg) return 0;cout << 2 << endl;for (int i = 2; i <= n; i++) printf ("%d ", col[i]); cout << endl;while (1){int x = rd();if (x == 1 || x == -1) return 1;int c1 = rd(), c2 = rd();if (c1 == 1) cout << 1 << endl;else cout << 2 << endl;}
}
signed main(){n = rd();for (int i = 2; i <= n; i++) fa[i] = rd(), e[fa[i]].push_back(i), du[fa[i]]++;dep[1] = -1, dfs(1);if (du[1] == n - 1){cout << 1 << endl;for (int i = 2; i <= n; i++) printf ("1 "); cout << endl;while (1){int x = rd();if (x == 1 || x == -1) return 0;int c = rd();cout << 1 << endl;}return 0;}if (work()) return 0;for (int i = 2; i <= n; i++) col[i] = dep[i] % 3 + 1;cout << 3 << endl;for (int i = 2; i <= n; i++) printf ("%d ", col[i]); cout << endl;while (1){int x = rd();if (x == 1 | x == -1) return 0;int c1 = 0, c2 = 0;for (int i = 1, t; i <= 3; i++){t = rd();if (t){if (c1) c2 = i;else c1 = i;}}if (!c2 || c1 % 3 + 1 == c2) cout << c1 << endl;else cout << c2 << endl;}return 0;
}