2024年8月4日 加训

2024年8月4日 加训

A

$$\lvert S\cap T\rvert \in V_{f(T)}$$

对于一个 $T$，限制形如 $T$ 中的元素有 $V_{f(T)}$ 个，求 $T$ 的大小为各种的子集，并将其设置为不合法

$g(S)$ 集合 $S$ 是否合法

规约不来。不会

正解

枚举 $S$，然后相应地规约限制

B

看起来像支配一类的问题.不是交换相邻

没思路，什么牛魔题

正解

确实是支配，你需要观察到交换 $A, B$，交换 $B, C$ 相当于可以交换 $C, D$。

于是需要交换的得形成一个连通块，你进一步考虑怎么搞最小生成树之类的

C

只有一个合法 $m$

若 $k = 1$，$m = n\times \max$，这个时候至少要 $n$ 次询问得到 $\max$

$m$ 是 $\max$ 的倍数，考虑找出 $\max$，这题只需要找到 $m$，所以只需判断是否有一个合法 $m$

花费 $n - 1$ 次找到 $\max$。

然后询问 $n$ 次 $k\max$，假设 $k_1$ 得到 $r_1$，$k_2$ 得到 $r_2$。

整个序列的最大和为 $n \times \max$，显然答案小于 $n/k \times \max$。

对 $n / k$ 种答案分别查询 $k$ 次即可

why? WA? 查询的时候没判断询问是否合法

D

首先得到若干连通块，和桥

首先一定要连接成连通块，所以建桥的费用是 $c\times (components - 1)$

components 内部的桥，考虑分成左右两部分，考虑分配成尽量相等的两份，这玩意应该很 NP，只能背包

于是考虑怎么快速背包，背包复杂度都爆炸了。不会，下一题

这题 $m$ 搞这么大干锤子

正解

草，直接背包 $n^2/\omega$ 居然可以过。

E

本质不同的子串数量

如何区分，保证任意两个都不同

如果有相同的两对组合，显然寄了，无法区分

如果没有，显然直接结束游戏，因为你自己建个sam出来就好了，时间复杂度 $O(len * n) = O(27000) = O(1)$。

先搞个 X，还得区分前后。来个 XO？

这怎么做，本质不同子串有什么很好的做法吗？我只会在 SAM 上统计啊哥们

难道说，对于 0/1 串，只要翻转不同，本质不同子串数量就不同

010

0, 1, 01, 10, 010

110

0, 1, 10, 11, 110

对字符串长度限制比较松

对于第 $i$ 个串，随机是不是对的？

笑死，直接随机过了

s[i].push_back((rng() % 8) ? (i & 1 ? 'X' : 'O') : (i & 1 ? 'O' : 'X'));

生成器如上，考虑在字符串中插入一些连续段，这样比较好区分你是第几个串，因为连续的多了，本质不同的就少了，这样长度带来的影响比较大，所以能区分。

此外，对奇偶分类连续段的字符是 X 或 O，这样能长度相差为 30 的串基本不可能判断不出来

建议赛后看正解

正解

这题正解就是随机，Hard Version 是构造 XOXXX... 的串，理由是这玩意不重复，能区分前后，并且好计算本质不同子串数目。

F

给出一个双射函数，求反函数

给出一个函数值，求点

初始括号序列合法，最终也合法

不会

正解

先考虑括号树上的权值，如下图：

注意儿子是从左到右的顺序的。

于是这会生成一个括号序列，并且我们知道其对应的权值：

()((()()(())))
01111222222333

考虑怎么通过上面这个括号序列，确定下面的数字。

首先起始的是 $0$，接下来一定都大于等于 $0$，当出现右括号时，其匹配的一定是最先出现的左括号，并且权值是左括号权值 $+1$，故可通过如下流程确定：

int cur = 0;
queue<int> Q;
for (int i = 0; i < n; ++i) {
	char ch = s[i];
    if (ch == '(') {
        val[i] = cur;
        Q.emplace(cur);
    } else {
        val[i] = Q.front() + 1;
        Q.pop();
    }
    cur = val[i];
}

接下来考虑如何利用上面的两个信息还原树。我们知道，每一个左括号都代表了一个节点，其儿子的左括号一定出现在这个点的右括号之后，出现在其兄弟的右括号之前。此外，同样的，权值为 $v$ 的右括号匹配的是第一个未被匹配且权值为 $v-1$ 的左括号。

流程如下：

queue<int> Q[max_val];
vector<int> son(n);
int tot = 0, fa = 0;
for (int i = 0; i < n; ++i) {
    char ch = s[i];
    int v = val[i];
    if (ch == '(') {
        int x = ++tot;	// 当前节点的编号
        fat[x] = fa;
        son[fa].push_back(x);
        Q[v].emplace(x);
    } else {
        fa = Q[v - 1].front();	// 当前节点作为父亲
        Q[v - 1].pop();
    }
}
for (int i = 0; i <= tot; ++i) reverse(begin(son[i]), end(son[i]));	// 真实情况是倒序