2024信友队智灵班春季 Test1 总结

最新推荐文章于 2025-05-05 14:10:20 发布

UnderTheTime

最新推荐文章于 2025-05-05 14:10:20 发布

阅读量2.1k

点赞数 28

分类专栏： 2024 信友队春季总结 OI题解文章标签： c++ 算法图论数据结构深度优先

本文链接：https://blog.csdn.net/UnderTheTime/article/details/137987461

版权

OI题解同时被 2 个专栏收录

34 篇文章

订阅专栏

2024 信友队春季总结

7 篇文章

订阅专栏

4月模考

死亡回放模考时间线

1:30 比赛开始，读 T1 宇宙爆炸 的题
1:50 自己手模了几组样例，得出了一个错误结论，打出了第一版错误代码，然后上交（ $\color{red}\text{Wrong\ Answer\ 20}$ ）
中间拿了 T2 逃狱风云 的部分分（ $\color{red}\text{Wrong\ Answer\ 10}$ ，最终分数），之后在想 T3 奇怪物语，然后推出需要用到二进制，但是想不出来，交了一个暴搜（？（ $\color{blue}\text{Time\ Limit\ Exceeded\ 20}$ ）
3:00 返回去检查 T1 宇宙爆炸 正确性，发现果然有问题！迅速修改了一下，把栈改成队列，再交了一发（ $\color{red}\text{Wrong\ Answer\ 60}$ ）
然后发现还是有问题！于是又改了改交了一发（ $\color{green}\text{Accepted\ 100}$ ）
可是我不自信啊！就把部分分改成了暴力，然后暴力挂了！（ $\color{red}\text{Wrong\ Answer\ 65}$ ，最终分数）
后面的时间要么在发呆，要么在狂想 T3 奇怪物语，中间好不容易意识到写个递推拿的分更多，但是 $5\times 10^7$ 的空间复杂度我开成了 long long（ $\color{blue}\text{Time\ Limit\ Exceeded\ 0}$ ，最终分数）
T4 东部世界 就没有去推了qwq

死因分析错误点分析

应该多去拿每个题的部分分的，简单的式子都去推一下！
暴力也得去验证是否正确！
应该要意识到空间复杂度的影响！
题目中给的提示得最大化使用！

死亡证明成绩

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

遗书各题错误思路 & 正解

T1 宇宙爆炸

给定一个由等量的 $0$ 和 $1$ 组成的环 $s$ ，各有 $n$ 个。对于每一个 $1$ ，如果其逆时针方向上第一个元素为 $0$ ，则它们会被一起删除，环会重新接上，这个过程一直重复直到不存在可以删除的元素。现在要求出一些位置，使得在这些位置插入一个 $1$ 后，这个 $1$ 不会被删除。

对于所有数据，保证： $1\le n\le 10^6$ ， $s_i\in\{0,1\}$ 。

错误思路

就不该加暴力！也不知道暴力哪错了……

正解

场上想的：遍历两遍环，开一个队列存当前这个环（不同起点），在队列里执行湮灭操作；在第二遍遍历的时候，如果发现将 $x$ 加入队列后发生湮灭，且湮灭完了队列为空，则说明 $x$ 后面一个元素是安全的。这很好想：如果某一时刻还剩下的元素没有被湮灭完，那么此时加入肯定会代替后面的某个元素进行湮灭操作。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
char s[maxn << 2]; int n;
int q[maxn << 3],ans[maxn << 1],tot; int l,r;
int main() {
    freopen("bigbang.in","r",stdin);
    freopen("bigbang.out","w",stdout);
    scanf("%d%s",&n,s + 1);
    n <<= 1; 
    for (int i = 1;i <= n;i ++)
        s[i + n] = s[i];
    l = 1,r = 0;
    for (int i = 1;i <= (n << 1);i ++) {
        while (l <= r && q[l] <= i - n) l ++;
        if (l > r) { q[++ r] = i; continue; }
        if (s[q[r]] == '1' && s[i] == '0') {
            r --;
            if (l > r && i > n) ans[++ tot] = i - n;
        } else q[++ r] = i;
    }
    sort(ans + 1,ans + tot + 1);
    int x = unique(ans + 1,ans + tot + 1) - ans - 1;
    for (int i = 1;i <= x;i ++) printf("%d%c",ans[i]," \n"[i == x]);
    return 0;
}

T2 逃狱风云

各有 $n$ 个犯人、盒子和纸条，编号均为 $1\to n$ 。每张纸条随机放入不同的每个盒子里。每个犯人都需要按照一定策略在 $n$ 个盒子中挑选 $k$ 个打开，如果没有看见自己编号的纸条则所有人都将被处决。否则全员释放。求在最优策略下全员释放的概率。犯人与犯人之间无影响。

提示：最优策略为： $i$ 号犯人先打开 $i$ 号盒子，然后根据看到的纸条编号打开对应编号的盒子，直到 $k$ 次用完或看到自己的纸条。

错误思路

压根不觉得这个提示是最优策略，以为只是针对于该样例而言可能的一个策略。然后就没有了，拿了 $10$ pts部分分。

正解

按照提示给定的策略，按照盒子与纸条的关系建一张图 $G$ ，如果 $i$ 号盒子中放着 $j$ 号纸条，则 $i$ 像 $j$ 连一条有向边。 $G$ 中一共 $n$ 个点、 $n$ 条边，且每个点各有一条入边、出边。 $G$ 一定由若干个互不相交的环组成。如果所有环的大小均不大于 $k$ ，那么所有犯人都能通过 $k$ 步走到自己编号的点上。则题目转化为求 $n!$ 种图中所有环的大小都不大于 $k$ 的概率。

令 $f_i$ 表示 $i$ 个点的图中，所有环大小均不大于 $k$ 的张数， $g_i$ 表示概率。显然 $g_i=\cfrac{f_i}{i!}$ ，且对于 $i\le k$ ， $f_i=i!,g_i=1$ 。转移 $f_i$ 时枚举包含第 $i$ 个点的环的大小 $j$ （ $j\le k$ ），则这个环不包含 $j$ 会有 $A^{j-1}_{i-1}$ 种形态，剩下 $i - j$ 个点合法的方案数为 $f_{i-j}$ ，故转移方程为：
$f_i=\sum^k_{j=1}A^{j-1}_{i-1}\times f_{i-j}=\sum^k_{j=1}\cfrac{(i-1)!}{(i-j)!}f_{i-j}$
此时把 $f_i$ 推广到 $g_i$ ，可以得到最终的递推式：（把 $(i - 1)!$ 提到求和之前）
$\begin{align}g_i&=\cfrac{1}{i!}f_i\\&=\cfrac{1}{i!}\sum^k_{j=1}\cfrac{(i-1)!}{(i-j)!}f_{i-j}\\&=\cfrac{(i-1)!}{i!}\sum^k_{j=1}\cfrac{f_{i-j}}{(i-j)!}\\&=\cfrac{1}{i}\sum^k_{j=1}g_{i-j}\end{align}$
后面的求和部分可以在计算 $g$ 的时候前缀和，预处理出 $\cfrac{1}{i}$ 的逆元，复杂度 $O (n)$ 。预处理逆元的方法：也是递推，初始 $inv_1=1$ ，递推式为： $inv_i=((P-\lfloor\cfrac{P}{i}\rfloor)\times inv_{P\bmod i})\bmod P$ 。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 1e6 + 5;
int n,k;
const int P = 998244353;
ll sum[maxn],g[maxn],inv[maxn];
int main() {
    freopen("prison.in","r",stdin);
    freopen("prison.out","w",stdout);
    scanf("%d%d",&n,&k);
    inv[1] = g[1] = sum[1] = 1;
    for (int i = 2;i <= k;i ++)
        inv[i] = ((P - P / i) * inv[P % i]) % P,
        g[i] = 1, sum[i] = (sum[i - 1] + 1) % P;
    for (int i = k + 1;i <= n;i ++)
        inv[i] = ((P - P / i) * inv[P % i]) % P,
        g[i] = inv[i] * ((sum[i - 1] - sum[i - k - 1]) % P + P) % P,
        sum[i] = (sum[i - 1] + g[i]) % P;
    printf("%lld",g[n]);
    return 0;
}

T3 奇怪物语

有 $Q$ 次询问，每次询问给定一个数 $N$ ，求有多少种方法，使得从 $1$ 开始只通过 $+1/\times 2/\times2+1$ 三种操作若干次后能得到 $N$ 。 $Q\le 200$ ， $N\le 10^{18}$ 。

错误思路

前 $50$ pts 用的递推，后面用暴搜 + 记忆化，但是没有去算 $5\times 10^7$ 还开 long long 的空间复杂度，最终导致又 MLE 又 TLE……😦

正解

对于转移方程 $f(i)=f(\lfloor\cfrac{i}{2}\rfloor)+f(i-1)$ ，考虑使用矩阵优化（可以看看这篇博客），宗旨即为：构造一个答案矩阵和转移矩阵，通过转移矩阵的矩阵快速幂与答案矩阵相乘加速转移。对于两个矩阵：
$$
A_{n\times m}=
\begin{bmatrix}
a_{1,1}& a_{1,2}& \cdots & a_{1,m} \
a_{2,1}& a_{2,2}& \cdots & a_{2,m} \
\vdots & \vdots & \ddots & \vdots \
a_{n,1}& a_{n,2}& \cdots & a_{n,m}
\end{bmatrix}\ \ ,\ \

B_{m\times p}=
\begin{bmatrix}
b_{1,1}& b_{1,2}& \cdots & b_{1,p} \
b_{2,1}& b_{2,2}& \cdots & b_{2,p} \
\vdots & \vdots & \ddots & \vdots \
b_{m,1}& b_{m,2}& \cdots & b_{m,p}
\end{bmatrix}
$$
对他们进行矩阵乘法运算得到 $C_{n\times p}$ （可见，矩阵乘法得到的答案矩阵长宽与 $A, B$ 的顺序有关，故矩阵乘法不具有交换律，但是有结合律，所以能用快速幂加速）： $C(i,j)=\sum^m_{k=1}A(i,k)\times B(k,j)$ 。

以一个经典的题目为例：

求斐波那契数列的第 $n$ 项 $F (n)$ 。 $n\le 10^{18}$ 。

对于此题，我们维护的答案矩阵即为：
$Ans(n)=\begin{bmatrix}F(n-1)&F(n-2)\end{bmatrix}$
当然也可以竖过来写，效果几乎相同，转移矩阵即为：
$M=\begin{bmatrix}1&1\\1&0\end{bmatrix}$
$F (1) = F (2) = 1$ ，所以 $Ans(3)=\begin{bmatrix}1&1\end{bmatrix}$ ，要求的 $F (n)$ 即为 $Ans(3)\times M^{n-2}$ 得到的矩阵的第一行第一列元素。可以把乘法过程写出来看看原理。而就像任何数乘上 $1$ 都不变一样，矩阵中的 $1$ 即为朝向右下角的对角线上全为 $1$ 、其余为 $0$ 的正方形矩阵。

回到本题。因为
$f(i+1)=f(i)+f(\lfloor\cfrac{i+1}{2}\rfloor=f(i)+f(\lceil\cfrac{i}{2}\rceil))$
考虑维护的答案矩阵为
$F(i)=\begin{bmatrix}f(i) \\f(\lceil\cfrac{i}{2}\rceil) \\f(\lceil\cfrac{i}{4}\rceil) \\\vdots \\f(1) \end{bmatrix}$
转移时，对于所有非负整数 $k$ ，满足 $\lceil\cfrac{i+1}{2^k}\rceil=\lceil\cfrac{i}{2^k}\rceil$ 或 $\lceil\cfrac{i+1}{2^k}\rceil=\lceil\cfrac{i}{2^k}\rceil+1$ 。对于前者，转移方程为 $f(\lceil\cfrac{i+1}{2^k}\rceil)=f(\lceil\cfrac{i}{2^k}\rceil)$ ；对于后者，转移方程为 $f(\lceil\cfrac{i+1}{2^k}\rceil)=f(\lceil\cfrac{i}{2^k}\rceil+1)=f(\lceil\cfrac{i}{2^k}\rceil)+f(\lceil\cfrac{i}{2^{k+1}}\rceil)$ 。如果某个 $k_0$ 满足第一种情况，那么对于所有的 $k\ge k_0$ 都会满足第一种情况。所以只需考虑最小的 $k_0$ 即可，两种情况被 $k_0$ 所分割。而后一种情况成立，当且仅当 $2^k$ 能整除 $i$ ，等价于 $i$ 的二进制下末尾的 $0$ 的个数大于等于 $k$ 。于是 $k_0$ 只和 $\operatorname{lowbit}(i)$ 有关。

提一嘴：对一个竖着的只有一列的矩阵 $M$ 去乘转移矩阵时，欲使转移过程中 $M_i+M_{i+1}$ 即相邻两项求和，只需在转移矩阵中对应位置 $(i, i + 1)$ 处把 $0$ 改成 $1$ 即可。我们设从 $F (i)$ 转移到 $F (i + 1)$ 的转移矩阵为 $M (i)$ ，使得 $F(i+1)=F(i)\times M(i)$ ，显然 $M (i)$ 长宽均为 $\lceil\log i\rceil$ 。同理 $M (i)$ 中添 $1$ 的位置也只和 $\operatorname{lowbit}(i)$ 有关。所以最终的 $M$ 画出来一定长成：对角线上前一段会有 $2$ 个 $1$ ，后一段会有 $1$ 个 $1$ ，对应之前的两种情况。所求的 $F (n)$ 即为
$F(n)=\Big(\prod_{i=n-1}^1M(i)\Big)\times F(1)$
利用树状数组的思想，找到一个 $m$ 使得 $2^m$ 是小于等于 $n - 1$ 的最大 $2$ 的整数次幂，那么
$\begin{align} \Big(\prod_{i=n-1}^1M(i)\Big)\times F(1)&=\Big(\prod^{2^m}_{i=n-1}M(i)\Big)\Big(\big(\prod^1_{i=2^m-1}M(i)\big)\times F(1)\Big)\\&=\Big(\prod^1_{i=n-2^m-1}M(i)\Big)\Big(\big(\prod^1_{i=2^m-1}M(i)\big)\times F(1)\Big) \end{align}$
这里将大于 $2^m$ 的下标都减去 $2^m$ ，前后不改变 $\operatorname{lowbit}$ 的值，则转移矩阵也相同。最后，我们考虑预处理出每一个 $M(2^m)\times M(2^m-1)\times\dots\times M(1)$ 的值，我们设其为 $P(2^m)$ 。先预处理出 $M(2^m)$ 的值，则
$\begin{align}P(2^m)&=(M(2^{m-1}-1)\times \dots \times M(1))\times M(2^{m-1})\times (M(2^{m-1}-1)\times \dots \times M(1))\\&=P(2^{m-1})\times M(2^{m-1})\times P(2^{m-1})\end{align}$
对于计算最终的 $f (n)$ ，即 $F (n)$ 的第一行，对于 $n$ 二进制上第 $i$ 位为一时， $F(n)\gets M(2^i)\times P(2^i)\times F(n)$ 。这个过程代替了快速幂。计算时从右往左计算（矩阵乘法的结合律），可以降低每一轮乘法的时间复杂度。

预处理 $M, P$ 花去 $O(\log^4n)$ ，回答每一轮花去 $O(\log^3n)$ ，总时间复杂度 $O(\log^4n+q\log^3n)$ 。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll MOD = 998244353;
const ll maxn = 1e18;
const int maxm = 60;
struct Mat { // 矩阵板子
    ll a[maxm + 5][maxm + 5];
    int n,m;
    Mat(int x = maxm,int y = maxm) {
        n = x, m = y;
        for (int i = 1;i <= n;i ++)
            for (int j = 1;j <= m;j ++)
                a[i][j] = 0;
    }
    void draw(int k0) {
        for (int i = 1;i < k0;i ++) // 相邻的求和
            a[i][i] = a[i][i + 1] = 1;
        for (int i = k0;i <= m;i ++) // 其余直接等号等过去
            a[i][i] = 1;
    }
    Mat operator* (const Mat &X) const {
        Mat res = Mat(n, X.m);
        for (int i = 1;i <= res.n;i ++)
            for (int j = 1;j <= res.m;j ++)
                for (int k = 1;k <= m;k ++)
                    (res.a[i][j] += a[i][k] * X.a[k][j] % MOD) %= MOD;
        return res;
    }
} M[maxm + 5], P[maxm + 5], F;
int Q; ll n;
void init() {
    F = Mat(maxm,1);
    for (int i = 1;i <= F.n;i ++)
        F.a[i][1] = 1;
}
int main() {
    freopen("stranger.in","r",stdin);
    freopen("stranger.out","w",stdout);
    for (int i = 1;i <= maxm;i ++) // 转移矩阵
        M[i].draw(i + 1);
    for (int i = 1;i <= P[1].n;i ++) // 开始预处理累乘
        P[1].a[i][i] = 1ll;
    for (int i = 2;i <= maxm;i ++)
        P[i] = P[i - 1] * M[i - 1] * P[i - 1];
    scanf("%d",&Q);
    while (Q --) {
        scanf("%lld",&n);
        init();
        for (int i = maxm;i > 0;i --) { // 快速幂的变相写法
            if (((n - 1) >> (i - 1)) & 1)
                F = M[i] * (P[i] * F);
        }
        printf("%lld\n",F.a[1][1] % MOD);
    }
    return 0;
}