HZ游记

HZ 游记

---

Day -1

收拾东西，准备出发。

话说这几天一直比较懒，也没什么心情和效率学习，颓废好几天了，希望到衡水以后能感觉好点。

不知道衡水有没有妹子

非常想看看衡水的样子，但是又害怕封闭式教学QWQ。

不过不知道为什么总感觉，接下来在衡水除了学OI还会得到些很重要的东西。

（预言flag）

QAQ

---

Day 0

晕车1小时到南站，差点吐到车上。

到了以后一个人也没没到，开始调教输入法。

看Alan火柴人一直到Cyber_tree十点多来。

车上玩一会阿瑞斯病毒玩一会群星有点晕，Cyber_tree巨佬在旁边吃零食看漫画追番。

（白嫖了薯片）

路上：莫名其妙拉着Cyber_tree和我去餐车逛街了（我就看看，不买）。

然而下动车以后一下不快乐了起来。

火车站出站口一群黑车拉生意，想到知乎上一个问题：

Q:女人如何才能让男人为你挣风吃醋？

A:去火车站打黑车。

于是和星光0000、SpadeA261一起在YPJ弄车的时候快乐玩起了双人三人跳一跳（然而每一次都是我死）

来车以后怕晕车于是安静在副驾驶听歌。

到HZ后发了个朋友圈，仿星光0000的文案：

成功到达

下一步

成功逃跑

然后放了一下行李突然就被叫走去上课，网络流。

啊这我还没吃午饭

上课，碰到久仰的巨佬赵思远（竟然就坐我旁边！！！）、杨卓凡，高俊垚、吴孟周。

SPFA他们竟然不读死趴法

不过最后1h太饿了都没好好听课

早知道就在餐车真香了……

去了食堂，意外发现HZ没有我想象的那么卷，没人吃饭的时候学习，都在看奥运（食堂电视），不过他们也没多长吃饭时间。

发现HZOI有妹子

发现HZ电脑比SDFZ还烂

发现HZ校服很简单但显身材

发现HZ女孩子还挺有颜值

发现我想买一套HZ校服

晚上回机房打代码。

交流了一会Linux，写了一会负圈没成功去找A神要了道上下界网络流的题。

题解

显然这道题就是每条雪道下界为 $1$ 的最小流，那么按照上下界网络流的套路，先钦定下界流量。之后再通过超级源汇点补全亏欠的流量，之后 $t->s$ Dinic将可行流转化为最小流。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=300,INF=0x7fffffff,M=11000;
int n,dis[N],m,s,t,head[N],cnt=1,cur[N],in[N],out[N],S,T,xs,xt,ans,dep[N];
bool inq[N],vis[N];
struct bian
{
    int nxt,to,w,c;
}b[M];
void add(int u,int v,int w)
{
    b[++cnt].nxt=head[u];
    b[cnt].to=v;
    b[cnt].w=w;
    head[u]=cnt;
}
void make(int u,int v,int w)
{
    add(u,v,w);
    add(v,u,0);
}
queue<int> q;
bool bfs()
{
    while(!q.empty())q.pop();
    for(int i=1;i<=T;i++)    dep[i]=INF,cur[i]=head[i];
    q.push(xs);
    dep[xs]=1;
    int i,v;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        i=head[u];
        while(i)
        {
            v=b[i].to;
            if(dep[v]>dep[u]+1&&b[i].w>0)
            {
                dep[v]=dep[u]+1;
                q.push(v);
            }
            i=b[i].nxt;
        }
    }
    return dep[xt]!=INF;
}
int dfs(int u,int minn)
{
    if(u==xt)
    {
        ans+=minn;
        return minn;
    }
    int i=cur[u],v,tmp=minn,used=0;
    while(i)
    {
        cur[u]=i;
        v=b[i].to;
        if(b[i].w>0&&dep[v]==dep[u]+1)
        {
            tmp=dfs(v,min(minn-used,b[i].w));
            if(tmp>0)
            {
                used+=tmp;
                b[i].w-=tmp;
                b[i^1].w+=tmp;
                if(used==minn)
                    break;
            }
        }
        i=b[i].nxt;
    }
    return used;
}
void Dinic()
{
    while(bfs())
    {
        dfs(xs,INF);
    }
}
int main()
{
    scanf("%d",&n);s=n+1,t=s+1,S=t+1,T=S+1;
    for(int i=1,v;i<=n;i++)
    {
        make(s,i,INF);
        make(i,t,INF);
        scanf("%d",&m);
        for(int j=1;j<=m;j++)
        {
            scanf("%d",&v);
            in[v]++;
            out[i]++;
            make(i,v,INF-1);
        }
    }
    for(int i=1;i<=t;i++)
    {
        if(in[i]>out[i])
            make(S,i,in[i]-out[i]);
        else if(in[i]<out[i])
            make(i,T,out[i]-in[i]);
    }
    make(t,s,INF);
    xs=S,xt=T;
    Dinic();
    int tmp=b[cnt].w;
    ans=0;b[cnt].w=b[cnt^1].w=0;
    xs=t,xt=s;
    Dinic();
    printf("%d\n",tmp-ans);
    return 0;
}
/*
8
1 3
1 7
2 4 5
1 8
1 8
0
2 6 5
0
*/

\(9:30\)

YPJ叫我们回宿舍楼铺床，还有 \(30mins\) 熄灯，路上：

“你们只有 \(10mins\) 铺床 \(10mins\) 洗漱。”

“那就是还有 \(10mins\) 打游戏。”

“你立刻退役还有 \(2\) 年时间打游戏。”

回宿舍铺床后还剩 \(15mins\)。上个厕所发现厕所积水漫过脚后跟，一只袜子没了QWQ。

随便刷牙洗脸后只剩 \(5mins\) 了，而此时大部分同学才刚刚铺完床。然而最早洗漱的我也没时间洗脚。

对哦，宿舍楼漏水&淋浴的水速高达 \(15滴/s\)

伴随着筷子敲铁碗要饭似的声音，熄灯了。

刺激

忽然衡中教练来收手机，然后YPJ来收手机，不过好像没真收？

吓得我把手机塞到了床垫下 没有的事

睡上铺，晚上被空调吹到腿抽筋，冷，很晚才睡着。

在衡水的第一天朴实无华的结束了。

SDFZ的食堂宿舍机房配置质量上比HZ强。

另一个发现是，没有发现HZ人放学路上看书（反倒是SDFZ某些卷王在这么干），但是他们几乎没有见他们说闲话，宿舍里也只有我们SDFZ的两间有声音，吃饭和洗漱几乎都是十几分钟解决，之后立刻六亲不认地消失。

---

Day 1

\(5:30\) 起床早自习，在大家都神志不清的时候放了一首电音。

你别说还开心了点（

去码，不知道为啥博客园登不上，于是随便写了写后去吃饭。

然后一直码到 \(9:00\) （QAQ我滥用 \(LateX\)）

讲卡特兰数&范德蒙恒等式&二项式反演，衡中巨佬们纷纷AK，HKHcutest一旁懵逼。

感觉数学比网络流难多了QWQ为啥他们听得懂数学听不懂网络流（当时候我网络流自学的QWQ）

不过上课时困炸了什么也没学到而且还在溜号。

算了还是先去写完负圈然后写上下界网络流去了，数学自己看看OI-WIKI算了。

消圈

题解

这道题有点迷。。。

基本思想是，对于负数费用的边，将其强制满流，即下界等于上界。

讲师：

对于这种情况，负边对答案无影响，但是会计入，所以这个算法有时候会假。

但是实际上并不会假。

因为消圈算法中会反向建立一条 \(1->t\) 的边，流量1,费用8。在上下界网络流的超级源汇点中会流过，所以花费还是 \(0\)。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=4000,INF=0x7fffffff,M=150000;
int n,dis[N],m,s,t,head[N],cnt=1,cur[N],S,T,xs,xt,d[N],ans,cost;
bool inq[N],vis[N];
struct bian
{
    int nxt,to,w,c;
}b[M];
void add(int u,int v,int w,int c)
{
    b[++cnt].nxt=head[u];
    b[cnt].w=w;
    b[cnt].c=c;
    b[cnt].to=v;
    head[u]=cnt;
}
void make(int u,int v,int w,int c)
{
    add(u,v,w,c);
    add(v,u,0,-c);
}
queue <int> q;
bool SPFA()
{
    for(int i=1;i<=T;i++)
    {
        dis[i]=INF;
        cur[i]=head[i];
    }
    inq[xs]=1;
    q.push(xs);
    dis[xs]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        inq[u]=0;
        int i=head[u],v;
        while(i!=0)
        {
            v=b[i].to;
            if(b[i].w>0&&b[i].c+dis[u]<dis[v])
            {
                dis[v]=dis[u]+b[i].c;
                if(!inq[v])
                {
                    inq[v]=true;
                    q.push(v);
                }
            }
            i=b[i].nxt;
        }
    }
    return dis[xt]!=INF;
}
int dfs(int u,int minn)
{
    if(u==xt)
    {
        vis[xt]=1;
        ans+=minn;
        return minn;
    }
    int i=cur[u],v,tmp=minn,used=0;
    vis[u]=1;
    while(i)
    {
        cur[u]=i;
        v=b[i].to;
        if(b[i].w>0&&dis[v]==dis[u]+b[i].c&&(vis[v]==0||v==xt))
        {
            tmp=dfs(v,min(minn-used,b[i].w));
            if(tmp>0)
            {
                cost+=b[i].c*tmp;
                used+=tmp;
                b[i].w-=tmp;
                b[i^1].w+=tmp;
                if(used==minn)
                    break;
            }
        }
        i=b[i].nxt;
    }
    return used;
}
void Dinic()
{
    while(SPFA())
    {
        vis[xt]=1;
        while(vis[xt])
        {
            memset(vis,0,sizeof(vis));
            dfs(xs,INF);
        }
    }
    return;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&s,&t);S=n+1;T=S+1;
    for(int i=1,u,v,w,c;i<=m;i++)
    {
        scanf("%d%d%d%d",&u,&v,&w,&c);
        if(c>=0)
        {
            make(u,v,w,c);
        }
        else
        {
            make(v,u,w,-c);
            d[u]-=w;
            d[v]+=w;
            cost+=w*c;
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(d[i]>0)
            make(S,i,d[i],0);
        else
            make(i,T,-d[i],0);
    }
    xs=S,xt=T;
    make(t,s,INF,0);
    Dinic();
    ans=0;
    xs=s,xt=t;
    Dinic();
    printf("%d %d\n",ans,cost);
    return 0;
}

中午搭蚊帐耗时50mins还用塑料袋卷了两条绳子QAQ。

写一下午无限之环未果，晚上继续然后吴孟周巨佬来讲了树形DP，听讲效率还可但不想写代码。

然后继续写无限之环。

晚上回去晚了，超级快的速度洗了冷水澡，然后睡觉去了。

打开手机手电筒铺床，刚说了一句闲话，忽然听见YPJ说：

一人玩一个手机？都交上来。

害怕。

衡水的完整一天结束了。

我发现HZ食堂是真的好。。。

虽然价格上跟SDFZ差不多，但是

好吃

见到直接用肉填满的手抓饼直接泪奔。

导致伙食费翻倍虽然伙食费就很多

顺带一提YPJ饭卡名字是张紫琪xswl。

虽然我的饭卡是坤坤。

---

Day 2

\(5：30\) 起了，放的还是昨天那首。

但我觉得每天换一首我可能就会更开心了。

上下铺梯子巨硌，每天上下床都做高危险动作。

上午继续码无限之环。

真成无限之环了艹

几乎Debug完以后，发现有一些情况当时将这个题没有说，而我傻傻地直接按照讲得建图写了没多想。

发现问题，瞬间丧失全部斗志开始颓浮生物语。

不得不说树姐姐写得真是好。

开始写了一点树的重心写了一半写不下去，还是想改出来无限之环。

改了一会又开始颓浮生。

颓完一篇以后去找A神详细分析了一下无限之环还有没有补救余地，发现只能进行重构代码级别的大改。

丧失斗志，继续颓浮生。

然后就被YPJ看到了。

教育后恢复部分动力全力冲了一道星际竞速。

爆蛋后再次丧失全部斗志。

然后吃饭睡觉打豆豆。

下午来的时候是1道题没调出来，1道题没写完，还有1道题要重构的烂摊子。

还好包里翻出来的太原拿过来的茶pai短暂安抚了我一下。

上课，构造题，听课还可以，最后一点点有点懵。

衡中发西瓜了开开心心去吃。（A神差一点就第一次吃的比我快了）

（好想和A神天天AA吃饭）

然后打算写一下HZ游记进入状态，然后输入法挂了。

然后颓起了知乎又被YPJ看到了。

重启，写游记。

先调一个星际竞速。

2 hours later.

我TMD调了TMD两个小时的TMD的星际TMD竞速，最后发现TMD命名空间和TMD全局变量TMD定义TMD重复？？？

讲真感觉虽然class写出来很难看而命名空间比较间接但是class难出锅。

提交记录刷屏了

18：48，写一点博客进入状态然后写几个构造题吧。

如果有HZ人看到这里，可不可以告诉我一下，去哪里买到你们的校服QAQ

一些杂事：

1. 以目前的情况看，再过一周就可以吃全衡中食堂了。（真不愧是收集控）
2. 这几天一直在机房教学楼、宿舍和食堂游走，其他地方完全不认识，天黑一点都会迷路。。。想找份HZ地图看看。
3. 从太原带来的饮料喝光了，缺乏补给。
4. 表情包不在这里，感觉博客写起来没那味儿。
5. 博客园每天早晨都莫名其妙无法登录。
6. 宿舍墙上掉粉，已经毁了一身衣服了QWQ。现在睡觉小心翼翼。
7. 感觉确实蚊帐没卵用。仅有的作用是让你感觉睡在晶莹剔透的水晶棺材里更梦幻了。

Cyber_Tree:配上你的粉色被子更梦幻

HKHcutest:是的呢还有我红嫩嫩的枕头和粉嫩嫩的少女心呢～

于是Cyber_Tree吐了

事实证明别人恶心你时最好的反击方法就是比他更恶心

就到这里吧～，写几道构造题去了！

写了一道游戏

题解

此题考虑完全图的三元环个数，取最大的小于等于 $n$ 的完全图,然后枚举新建一个点向 $n-1$ 个点、$n-2$ 个点、$n-3$ 个点、……、$2$ 个点连边。
最后剩下的点（寥寥无几）通过不断新建一个点向1、2连边解决。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
inline int read() {
    int z = 0, w = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            w = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        z = z * 10 + ch - '0';
        ch = getchar();
    }
    return z * w;
}
int n, m, tot;
bool b[1000][1000];
int main() {
    n = read();
    for (int i = 3; i <= 0x7fffffff; i++) {
        if (i * (i - 1) * (i - 2) / 6 > n)
            break;
        m = i;
    }
    for (int i = 1; i <= m; i++) {
        for (int j = 2; j <= m; j++)
            b[i][j] = 1;
    }
    n -= m * (m - 1) * (m - 2) / 6;
    for (int i = m - 1; i >= 2; i--) {
        if (n >= (i * (i - 1) / 2)) {
            n -= i * (i - 1) / 2;
            m++;
            for (int j = 1; j <= i; j++) {
                b[j][m] = 1;
                b[m][j] = 1;
            }
        }
    }
    while (n) {
        m++;
        b[2][m] = b[m][1] = b[1][m] = b[m][2] = 1;
        n--;
    }
    printf("%d\n", m);
    for (int i = 1; i <= m; i++) {
        for (int j = i + 1; j <= m; j++) {
            printf("%d ", b[i][j]);
        }
        puts("");
    }
    return 0;
}

写

Errich-Tac-Toe

时，差不多码完的时候，忽然HZ教练走进来说可以开始颓废了。

全SDFZ人都感到很魔幻

全HZ人好像也感到很魔幻

反正就是我和Cyber_Tree开开心心去踢球了，其他人去打篮球了，HZ人打羽毛球和乒乓球的居多，但是大部分人还留在机房。

踢球的时候意外在衡中操场发现了青蛙！

我印象里青蛙大概有我手那么大，然而我们见到青蛙大约只有长5厘米宽2~3厘米这样子，但是其他的所有方面都和我印象里的青蛙一模一样。

和青蛙一起做了10个蛙跳

回宿舍，大家都要冲冷水澡（因为没有热水），全宿舍除了我和星光0000都跑到别的空宿舍用洗澡间了。

于是我找到SpadeA261的房间暴力进入 。

回宿舍，自己放了每天早晨听到的电音

睡觉。

讲真和我印象里的河北不一样，比如说在衡水第一次见到真正的浓雾（不是雾霾，货真价实的水汽）。还第一次见到青蛙～

生态要比SDFZ好很多。

另外，衡水的蝉超级吵闹，但是偶尔有一阵子所有的蝉全停下来，或者忽然安静许多，很有意思。

顺带一提，发现衡水留在机房的人集体褪三国杀、音游。但平常没见他们玩过。

附集训作息时间表

上午

5:35起床洗漱

6:00到机房

6:40去食堂吃饭

7:00到机房

12:10去食堂吃饭

下午

1:50到机房被

6:00去食堂吃饭

6:30到机房

9:40回宿舍

10点熄灯睡觉

---

Day 3

起床，来机房写博客，吃饭 。

\(5:30\) 起床以后迟到了一会才到了机房，然而所有衡水人早已到达，我在机房也从来没见过有衡水人上OI以外的网站。

然而我却会颓知乎

也许HZ有人水洛谷，那我就看不出来了。

想到一个情景：

两个人坐在衡中路边，凝视着人来人往：

“你是不是觉得衡中是一台打机器，这里每个人都是零件，遵循着机械的规则，没有人有自己的自由。”

“不，我是在想，衡中女生的小腿好粗。”

Errich-Tac-Toe题解

把格子按照 $(i+j)%3$ 分类，发现如果有两类格子，同一类颜色相同，这两类颜色不同，那么必定平局( 能想出这个东西的人真是个人才)，然后做出3种方案即可，注意选择3种方案时，更改的格子不要重复，要满足总和为 $k$ 。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=500;
inline int read()
{
    int z=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){z=z*10+ch-'0';ch=getchar();}
    return z*w;
}
int T,n,ans[3],opt;
char s[N][N];
int main()
{
    T=read();
    while(T--)
    {
        ans[0]=ans[1]=ans[2];
        n=read();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s[i]+1);
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(!((i+j)%3))
                {
                    if(s[i][j]=='X')
                    {
                        ans[0]++;
                    }
                    else if(s[i][j]=='O')
                    {
                        ans[2]++;
                    }
                }
                else if((i+j)%3==1)
                {
                    if(s[i][j]=='O')
                    {
                        ans[0]++;
                    }
                    else if(s[i][j]=='X')
                    {
                        ans[1]++;
                    }
                }
                else if((i+j)%3==2)
                {
                    if(s[i][j]=='O')
                    {
                        ans[1]++;
                    }
                    else if(s[i][j]=='X')
                    {
                        ans[2]++;
                    }
                }
            }
        }
        if(ans[0]<=ans[2]&&ans[0]<=ans[1])
        {
            opt=1;
        }
        if(ans[1]<=ans[0]&&ans[1]<=ans[2])
        {
            opt=2;
        }
        if(ans[2]<=ans[1]&&ans[2]<=ans[0])
        {
            opt=3;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(!((i+j)%3))
                {
                    switch(opt)
                    {
                        case 1:
                            putchar(s[i][j]=='.'?'.':'O');
                            break;
                        case 2:
                            printf("%c",s[i][j]);
                            break;
                        case 3:
                            putchar(s[i][j]=='.'?'.':'X');
                            break;
                    }
                }
                else if((i+j)%3==1)
                {
                    switch(opt)
                    {
                        case 1:
                            putchar(s[i][j]=='.'?'.':'X');
                            break;
                        case 2:
                            putchar(s[i][j]=='.'?'.':'O');
                            break;
                        case 3:
                            printf("%c",s[i][j]);
                            break;
                    }
                }
                else if((i+j)%3==2)
                {
                    switch(opt)
                    {
                        case 1:
                            printf("%c",s[i][j]);
                            break;
                        case 2:
                            putchar(s[i][j]=='.'?'.':'X');
                            break;
                        case 3:
                            putchar(s[i][j]=='.'?'.':'O');
                            break;
                    }
                }
            }
            puts("");
        }
    }
    return 0;
}
/*
3
3
.O.
OOO
.O.
6
XXXOOO
XXXOOO
XX..OO
OO..XX
OOOXXX
OOOXXX
5
.OOO.
OXXXO
OXXXO
OXXXO
.OOO.

*/

---

Mine Sweeper II

Mine Sweeper II题解

不难意会到，可以把B改成和A一模一样或者完全相反，取步数小的。
给个证明完全相反的权值等价于正常权值？

代码

    #include<bits/stdc++.h>
    using namespace std;
    const int N=1100;
    int n,m,ans[2];
    char a[N][N],b[N][N];
    int c(char x)
    {
        return x=='X'?'.':'X';
    }
    int main()
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%s",a[i]+1);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%s",b[i]+1);
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(a[i][j]!=b[i][j])
                    ans[0]++;
                else
                    ans[1]++;
            }
        }
        if(ans[0]<ans[1])
        {
            for(int i=1;i<=n;i++)
            {
                printf("%s\n",a[i]+1);
            }
        }
        else
        {
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=m;j++)
                {
                    putchar(c(a[i][j]));
                }
                puts("");
            }
        }
        return 0;
    }
    /*
    2 4
    X..X
    X.X.
    X.X.
    .X..
    X.XX
    .X..
    */

上午 \(8:30-12：00\)讲期望DP，几乎懵逼，只立刻学会了打表找决策单调性。

先写完构造再说。

写一下午题，效率略差。

晚上听巨佬WMZ讲课，数位DP,虽然学过，但非常懵逼。

我好差呀。

吴孟周刷博客太刺激了

OI至高算法，只要XIN队算法打满，保证所有比赛 rk1，碾爆标程，让对手望尘莫及。

为 XIN队 献上 H1！

圣经永不过时

---

Day 4

阅读量竟然已经130了，略开心。

但是别光看不点赞啊！

博客就抖个机灵别当真。

昨天晚上做了一个有极为宏大历史背景的震撼的梦，起来时恍如隔世。

早晨去搬电脑了，希望这回机子能收到广播。（换的第三台电脑）

上午考试，T1一下大意忘了单个循环节内一数字不会重复出现，写了一个带线段树可以做能重复出现的情况。

本来是怕调不出来了，忽然仿佛想到FAKE佬的教诲：“你想正式考试不用数据结构吗？不想平常模拟赛就得写数据结构。写过一次你就有信心了。”

然后我花20mins才搞出了一颗单点修改区间查询线段树。

不过真的是我第一次在考场上用出数据结构~Cheers!!!

虽然只过了T1，rk9 ，但实现了从无到有的突破，开心。

T1代码

#include<bits/stdc++.h>
#define ll long long
#define lowbit(x) (x&(-x))
using namespace std;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
inline ll readll()
{
    ll s=0;int w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int _max(int a,int b)
{
    return a>b?a:b;
}
ll _maxll(ll a,ll b)
{
    return a>b?a:b;
}
int _min(int a,int b)
{
    return a<b?a:b;
}
const int N=1100000,M=200;
const ll INF=0x7fffffffffffffff;
ll n,ans,num[M],l,r,len,L,R,f[N],num2[M];
int t1,A,B,C,D,s[N],pre[M],zhan[N],top;
struct xds
{
    int l,r;
    ll mx;
}t[N<<2];
void up(int p)
{
    t[p].mx=_maxll(t[p*2].mx,t[p*2+1].mx);
}
ll query(int p,int x)
{
    if(t[p].r<=x)
    {
        return t[p].mx;
    }
    ll res=0;
    if(t[p*2].l<=x)
        res=_maxll(res,query(p*2,x));
    if(t[p*2+1].l<=x)
        res=_maxll(res,query(p*2+1,x));
    up(p);
    return res;
}
void change(int p,int x,ll v)
{
    if(t[p].l==x&&t[p].r==x)
    {
        t[p].mx=v;
        return;
    }
    if(t[p*2].r>=x)
        change(p*2,x,v);
    else
        change(p*2+1,x,v);
    up(p);
}
void build(int p,int l,int r)
{
    t[p].l=l;
    t[p].r=r;
    if(l==r)
    {
        return;
    }
    int mid=(l+r)/2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
    up(p);
}
int main()
{
    //freopen("in.in","r",stdin);
    //freopen("out1.out","w",stdout);
    n=readll();
    t1=read();A=read();B=read();C=read();D=read();
    s[1]=t1;pre[t1]=1;
    for(int i=2;i<=n;i++)
    {
        s[i]=A*s[i-1]*s[i-1]+B*s[i-1]+C;
        s[i]=s[i]%D;
        if(!pre[s[i]])
        {
            pre[s[i]]=i;
        }
        else
        {
            L=l=pre[s[i]];
            r=i-1;
            len=r-l+1;
            break;
        }
    }
    if(l!=0&&r!=0)
    {
        for(int i=l;i<=r;i++)
        {
            num[s[i]]++;
        }
        for(int i=2,tr;i<=len;i++)
        {
            tr=r+(i-2)*len;
            for(int j=1;j<=len;j++)
            {
                s[tr+j]=s[l-1+j];
                if(tr+j>n)
                    break;
            }
        }
        R=r+(len-1)*len;
        if(R>n)
            R=n;
        for(int i=0;i<D;i++)
        {
            num[i]*=((n-R)-(n-R)%len)/len;
        }
        for(int i=0;i<(n-R)%len;i++)
        {
            num2[s[l+i]]++;
        }
    }
    if(!R)
        R=n;
    zhan[0]=-0x7fffffff;
    build(1,1,R);
    for(int i=1;i<=R;i++)
    {
        if(s[i]>=zhan[top])
        {
            zhan[++top]=s[i];
            f[i]=top;
            change(1,top,num[s[i]]);
            //printf("%lld ",f[i]);
            f[i]+=query(1,top)+num2[s[i]];
            ans=_maxll(ans,f[i]);
        }
        else
        {
            int le=1,ri=top,mid;
            while(le<ri)
            {
                mid=(le+ri)/2;
                if(zhan[mid]<=s[i])
                {
                    le=mid+1;
                }
                else
                {
                    ri=mid;
                }
            }
            change(1,le,0);
            f[i]=le;
            //printf("%lld ",f[i]);
            zhan[le]=s[i];
            change(1,le,num[s[i]]);
            f[i]+=query(1,le)+num2[s[i]];
            ans=_maxll(ans,f[i]);
        }
    }
    printf("%lld\n",ans);
    return 0;
}
/*
10
1 1 3 5 37
*/

下午有点烂。差不多是4小时抄题解改两题。

T2题解

分层图同余最短路，我学了个半调子，大意就是背包通过同余将极大的容积变小（同余最小物品的体积），SPFA优化DP。（STD里最后的一种算法不会）
顺便一膜SZS巨佬。

T2代码

#include<bits/stdc++.h>
#define ll long long
#define int long long
using namespace std;
const int N=60;
int n,m,l,c,v[N],pos,minn=0x3f3f3f3f3f3f3f3f;
int dis[10005],cnt[10005];
queue<int>q;
bool in[10005];
inline ll readll()
{
    ll s=0;int w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
void SPFA(){
    memset(dis,0x3f,sizeof(dis));
    memset(cnt,0x3f,sizeof(cnt));
    dis[0]=cnt[0]=0;
    in[0]=1;
    q.push(0);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        in[x]=0;
        for(int i=1;i<=n;++i)
        {
            int y=(x+v[i])%minn;
            if(v[i]>=l&&cnt[x]>=c) break;
            if(dis[y]>dis[x]+v[i])
            {
                dis[y]=dis[x]+v[i];
                if(v[i]>=l)
                   cnt[y]=cnt[x]+1;
                if(!in[y])
                    q.push(y),in[y]=1;
            }
            else if(dis[y]==dis[x]+v[i])
            {
                if(cnt[y]>cnt[x]+(v[i]>l))
                {
                    cnt[y]=cnt[x]+1;
                    if(!in[y])
                    {
                        q.push(y);
                        in[y]=1;
                    }
                }
            }
        }
    }
}
signed main(){
    n=readll();m=readll();
    for(int i=1;i<=n;++i)
    {
        v[i]=readll();
        minn=min(minn,v[i]);
    }
    l=readll();
    c=readll();
    sort(v+1,v+n+1);
    SPFA();
    for(int i=1,x;i<=m;++i){
        scanf("%lld",&x);
        if(dis[x%minn]<=x) puts("Yes");
        else puts("No");
    }
    return 0;
}

T3题解

统计黑点的贡献。线段树DFS序上维护子树。

T3代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define int long long
using namespace std;
const int MAXN=1e5+5;
int n,m,w[MAXN];
bool vis[MAXN];
int to[MAXN<<1],nxt[MAXN<<1],pre[MAXN],cnt=0;
void add(int u,int v){
    ++cnt,to[cnt]=v,nxt[cnt]=pre[u],pre[u]=cnt;
}
int in[MAXN],out[MAXN],fa[MAXN],dfn=0;
void dfs(int x){
    in[x]=++dfn;
    for(int i=pre[x];i;i=nxt[i]){
        int y=to[i];
        if(y==fa[x]) continue;
        fa[y]=x;
        dfs(y);
    }
    out[x]=dfn;
}
int tr[MAXN<<2],laz[MAXN<<2];
void down(int k){
    tr[k<<1]=max(tr[k<<1],laz[k]);
    tr[k<<1|1]=max(tr[k<<1|1],laz[k]);
    laz[k<<1]=max(laz[k<<1],laz[k]);
    laz[k<<1|1]=max(laz[k<<1|1],laz[k]);
    laz[k]=0;
}
void update(int k,int l,int r,int opl,int opr,int val){
    if(opl<=l&&r<=opr){
        tr[k]=max(tr[k],val);
        laz[k]=max(laz[k],val);
        return ;
    }
    if(laz[k]) down(k);
    int mid=(l+r)>>1;
    if(opl<=mid) update(k<<1,l,mid,opl,opr,val);
    if(opr>mid) update(k<<1|1,mid+1,r,opl,opr,val);
    tr[k]=max(tr[k<<1],tr[k<<1|1]);
}
int query(int k,int l,int r,int opt){
    if(l==r) return tr[k];
    if(laz[k]) down(k);
    int mid=(l+r)>>1;
    if(opt<=mid) return query(k<<1,l,mid,opt);
    else return query(k<<1|1,mid+1,r,opt);
}
signed main(){
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;++i){
        scanf("%lld",&w[i]);
    }
    for(int i=1,u,v;i<n;++i){
        scanf("%lld%lld",&u,&v);
        add(u,v),add(v,u);
    }
    dfs(1),vis[0]=1;
    for(int i=1;i<=m;++i){
        char opt[10];
        int v,ans;
        scanf("%s%lld",opt,&v);
        if(opt[0]=='M'){
            update(1,1,n,in[v],out[v],w[v]);
            vis[v]=1;
            while(vis[fa[v]]!=1){
                update(1,1,n,in[fa[v]],in[v]-1,w[fa[v]]);
                update(1,1,n,out[v]+1,out[fa[v]],w[fa[v]]);
                v=fa[v];
            }
        }else{
            ans=query(1,1,n,in[v]);
            if(!ans) ans=-1;
            printf("%lld\n",ans);
        }
    }
    return 0;
}

巨佬高俊垚终于回我了，开心。

另外：

HZ的小伙伴们来找我说几句话吧，每天穿着一个非常亮&显眼的橘色衣服的，非常颓废的就是QWQ。

晚上可以听AC自动机或字符串杂题，本来想复习AC自动机，但是大家都去听了杂题，于是我就也跟着去了，结果啥也不会听懂率小于1%。

还有：

你们怎么能把我第一段的别的收获说成是妹子呢？？？明明是难得正经的一点感悟。

真要能在HZ收获妹子还至于在SDFZ混成酱紫

再补一段。

啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊刚刚往前面一转悠发现好几台机子背景是一个蓝不拉几的星球坠落背景。

社死现场。

社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了杜死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了社死了。

艹

刚刚小眼告诉我这件事的时候我听成了吴巨佬看我博客了。

直接害怕。

我发神经千万别让神犇看见。

我觉得我游记里关于HZ的内容应该有许多和事实不一样的地方

你们不可以评论一下指出来吗QAQ

---

Day 5

昨天晚上不知道哪个憨憨开了空调强风，于是正对风口的发烧了。

但是上午还是去看了看题，感觉T1折半搜索，没写就熬不住了。

老师带我去医务室，还问有没有做核酸。

其实到衡水集训然后还发烧然后做核酸这也没几个人经历过吧。

但最后并没有做核酸。

躺着养病。

下午感觉好点，测温比上午高1℃，39多。

晚上40℃。

巨佬Rings给我带了中午的饭，感动。

Cyber_tree带了晚饭，感动。

教练也带了晚饭QAQ，还是很感动。

爸妈直接往衡水赶过来了，开心，很温暖，感觉跟他们打电话时候那么不耐烦好对不起……

一年级的时候，家住顶楼，屋顶漏水，下雨天直接水打进来，一屋子没有床，拿铁架子支起来睡觉，一屋子只有一个塑料管水龙头。

然后我发烧了7天，最高两天40摄氏度。

最严重的那一天，晚上我忽然醒过来，说我梦到在机场，有很多飞机，周围的人都穿着黑（还是白衣服 忘了）衣服，互相不说一句话，忙着上飞机。

我那时没坐过一次飞机，因此一直很想坐飞机。我说我要上飞机啦。听见我妈说

爸爸妈妈还在这，你不要去坐飞机。

我半睡半醒的时候，听见她一直在说，一直听见几十次。

放了一些纯音，很安静。这个学期听了很多杂乱的歌，到头来还是纯音能让人安定下来，安静地享受。

10:00 37.5°C。

谢谢大家。

---

Day 5

上午本来打算正常上课，但是教练把我赶回去了。

然后睡了一上午。

由于吃了超多发汗药，所以没有一件衣服不被汗浸透，一股汗味。

前文提到过，衡水自然条件好。

但是这不是你在纱窗卡槽上漏洞然后不开窗户快一周依然天天有10+蚊子的理由！！！

DKY巨佬：我来HZ第一天就想回去了。

下午有点闲，玩了一个galgame，《他人世界末》。

一秒出戏的场景以前的话我肯定是不敢公开宣称我玩galgame怕被人看见，

超感动的剧情但是现在我在一个FZ和HZ人都看的博客里这么写，

花了很久打出好结局。也许是现实太残酷，于是放弃现实接纳幻想了吧……

晚上去校园里转一转，找到了巨佬GJY告诉我的卖校服的地方但并没有卖校服的。

贴几张图。

附中学费每年800￥

挺直了腰杆!

---

Day 6

没有女生礼服的话怎么给A神女装

HKH好了，但没完全好。

干出来以下一系列失智行为：

中午，对Cyber_Tree嘲讽了霍格沃茨办学质量差。

然后又对赶来讨论红楼梦的A神说：我早就看他们那一帮烂人不～顺～眼～了～终于被抄家了喔豁嚯哈哈哈哈太开心了。

过了5分钟：

为什么没抄干净抄家都抄不干净？？？我真为可怜的封建统治阶级感到悲哀。

昨天晚上认定【数据删除】双向恋4个，太渣了根本洗不清。

不要太贪心～～～

对教练：啊哈哈要是我在HZi检查出新冠就很有意思了

教练：Excuse me???

为啥核酸检测感觉一股苦黄瓜味？

HKHcutest：QAQ

---

Day 7

没人看我游记了我过气了

上午考试状态：

哈哈哈哈哈哈哈哈你看这个窗帘是蓝色的好开心啊哈哈哈

哈哈哈哈哈哈哈哈你看这个水瓶是红色的好开心啊哈哈哈

哈哈哈哈哈哈哈哈你看这个鼠标是黑色的好开心啊哈哈哈

哈哈哈哈哈哈哈哈你看这个帽子是绿色的好开心啊哈哈哈

哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈我是个垃圾我好开心呀

于是只有胡写的T1 80p有分。

然后并不想改T2/3，于是去写了猪国杀。

没写完又回来写T3。

没写完又回来写猪国杀。

没写完又回来写T3。

没写完又回来写猪国杀。

没写完又回来写T3。

没写完又回来写猪国杀。

没写完又回来写T3。

没了

真没了

不要再看了没有别的东西了

你想翻就随你了

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

……

你浪费了多长时间？QAQ

ZKX AK IOI！

YCX AK IOI！

我不会推式子的

于是T3抄上了别人的公式，真香。

然后各种符号错误一直懵逼，调好久。

T2用了没人用的状压DP做法。

上题解：

T1Smooth题解

代码

#include<bits/stdc++.h>
using namespace std;
const int N=20,M=11000000,zhi[50]={0,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67};
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int k,d;
queue<long long> q[N];
signed main()
{
    d=read();k=read();
    for(int i=1;i<=d;i++)
    {
        q[i].push(zhi[i]);
    }
    long long minn=1;
    int mp;
    for(int i=2;i<=k;i++)
    {
        minn=0x7fffffffffffffff;
        for(int j=1;j<=d;j++)
        {
            if(minn>q[j].front())
            {
                minn=q[j].front();
                mp=j;
            }
        }
        q[mp].pop();
        for(int j=mp;j<=d;j++)
        {
            q[j].push(minn*zhi[j]);
        }
    }
    printf("%lld\n",minn);
    return 0;
}

T2Six题解

最多六个质因子，一个质因子最多分6批加入，所以状态S每3位表示第i个质因子在哪一批被加入，0表示未被加入，7表示已经加入两次。
$f[j]+=f[i]*zhuanyishu[k]$

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int mod=1e9+7;
long long n,c[10],d[10],tot,ans,m,f[1100000],va[1100000];
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int _min(int a,int b)
{
    return a<b?a:b;
}
signed main()
{
    n=read();
    int x=n;
    for(int i=2;i*i<=x;i++)
    {
        if(x%i==0)
        {
            tot++;
            while(x%i==0)
            {
                x/=i;
                d[tot]++;
            }
        }
    }
    if(x!=1)
        d[++tot]=1;
    m=(1<<(tot*3));
    for(int i=1;i<(1<<tot);i++)
    {
        va[i]=1;
        for(int j=1;j<=tot;j++)
        {
            if((i>>(j-1))&1)
                va[i]*=d[j];
        }
    }
    f[0]=1;
    for(int i=0,ne_ad,no_hz,gt;i<m;i++)//newadd,nohuzhi
    {
        if(!f[i])
            continue;
        ans=(ans+f[i])%mod;
        for(int j=1;j<(1<<tot);j++)
        {
            ne_ad=no_hz=0;gt=i;
            for(int k=1;k<=tot;k++)
            {
                int s2=i>>(3*(k-1))&7,s1=(j>>(k-1))&1;
                if(!s2&&s1)
                {
                    ne_ad=k;
                    break;
                }
            }
            for(int k=1;k<=tot;k++)
            {
                int s2=i>>(3*(k-1))&7,s1=(j>>(k-1))&1;
                if(s1&&s2)
                {
                    if(s2==7)
                        goto disallow;
                    if(!no_hz)
                        no_hz=s2;
                    else if(no_hz!=s2)
                        goto disallow;
                }
            }
            for(int k=1;k<=tot;k++)
            {
                int s2=i>>(3*(k-1))&7,s1=(j>>(k-1))&1;
                if(s1)
                {
                    if(s2)
                        gt|=7<<(3*(k-1));
                    else
                        gt|=ne_ad<<(3*(k-1));
                }
            }
            f[gt]=(f[gt]+f[i]*va[j]%mod)%mod;
            disallow:;
        }
    }
    printf("%lld\n",ans-1);
    return 0;
}

T3Walker题解

随机选两组，高斯消元算出答案（直接推式子也可）
解出来

\[\begin{align}
&\sin(\theta)\times scale \\&
\cos(\theta)\times scale \\&
dx \\&
dy
\end{align}\]

把这个带入原数据检查是不是一半合法。

代码

#include<bits/stdc++.h>
#define ld long double
ld epx=1e-5;
using namespace std;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int n,p1,p2,tot;
struct posi
{
    long double x[5],y[5];
}p[110000];
ld _fabs(ld x)
{
    if(x<0)
        return -x;
    return x;
}
signed main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        scanf("%Lf%Lf%Lf%Lf",&p[i].x[0],&p[i].y[0],&p[i].x[1],&p[i].y[1]);
    }
    for(int i=1;i<=60;i++)
    {
        tot=0;
        p1=rand()%n+1;
        do
        {
            p2=rand()%n+1;
        }while(p1==p2);
        /*
        a=scale*sinO
        b=scale*cosO
        c=dx
        d=dy
        a=(x1-x2)(y1'-y2')-(x1'-x2')(y1-y2)
        /
        (x1-x2)^2+(y1-y2)^2
        b=(x1-x2)(x1'-x2')+(y1'-y2')(y1-y2)
        /
        (x1-x2)^2+(y1-y2)^2
        x1=p[p1].x[0];
        x2=p[p2].x[0];
        x1'=p[p1].x[1];
        x2'=p[p2].x[1];
        y1=p[p1].y[0];
        y2=p[p2].y[0];
        y1'=p[p1].y[1];
        y2'=p[p2].y[1];*/
        //printf("%Lf %Lf %Lf %Lf\n",p[p1].x[0],p[p2].x[0],p[p1].y[0],p[p2].y[0]);
        ld a=((p[p1].x[0]-p[p2].x[0])*(p[p1].y[1]-p[p2].y[1])-(p[p1].x[1]-p[p2].x[1])*(p[p1].y[0]-p[p2].y[0]))
        /
        ((p[p1].x[0]-p[p2].x[0])*(p[p1].x[0]-p[p2].x[0])+(p[p1].y[0]-p[p2].y[0])*(p[p1].y[0]-p[p2].y[0]));
        ld b=((p[p1].x[0]-p[p2].x[0])*(p[p1].x[1]-p[p2].x[1])+(p[p1].y[1]-p[p2].y[1])*(p[p1].y[0]-p[p2].y[0]))
        /
        ((p[p1].x[0]-p[p2].x[0])*(p[p1].x[0]-p[p2].x[0])+(p[p1].y[0]-p[p2].y[0])*(p[p1].y[0]-p[p2].y[0]));
        ld c=p[p1].x[1]-b*p[p1].x[0]+a*p[p1].y[0];
        ld d=p[p1].y[1]-a*p[p1].x[0]-b*p[p1].y[0];
    //    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;
        for(int i=1;i<=n;i++)
        {
            ld t1=p[i].x[0]*b-p[i].y[0]*a+c;
            ld t2=p[i].x[0]*a+b*p[i].y[0]+d;
            if(_fabs(t1-p[i].x[1])<epx&&_fabs(t2-p[i].y[1])<epx)
                tot++;
            if(tot>n/2)
                break;
            //cout<<tot<<endl;
        }
        if(tot>n/2)
        {/*
            double scale=sqrt(ds*ds+dc*dc);
            double thy=acos(dc/scale);
            if(fabs(sin(thy)*scale-ds)>0.00001) thy=-thy;
            printf("%.10lf\n%.10lf\n%.10lf %.10lf\n",thy,scale,dx,dy);*/
            ld sc=sqrt(a*a+b*b);
            ld jd=acos(b/sc);
            if(_fabs(sin(jd)*sc-a)>epx)
                jd=-jd;
            printf("%.10Lf\n%.10Lf\n%.10Lf %.10Lf\n",jd,sc,c,d);
            break;
        }
    }
    return 0;
}

晚上宿舍，教练来问有什么没适应的。

我说饮料。

教练说就饮料吗

然后就走了。

感觉会有惊喜

想起来在FZ上课上到一半发冰激凌。

距离上一次打球踢球已经很久了，大家都很想颓废，

---

Day 8

上午考出暑假最烂，挂135分。原因：T1没取够模，T2看题不仔细。

看T1题面过程中忽然想到……

他看着他刚刚开枪打死的人。他恨吗？不，这里有远比躺在地上的这位更令人憎恶的东西，但他也不知道他为什么开枪。他总感觉那人没死，说不定在什么时候会悄悄地冲着他脑袋来上一枪，他还活着，但感觉已经被很多人杀过，也杀过所有人。他不知道的是，他处在既活着又死了的状态，仅仅是出题人喜欢。

写草稿：

设 \(f[i]\) 表示 \(i\) 号猎人死的期望。

等等，有点不对劲……

T1Hunter T2Defence题解

第两题官方题解都很棒，T2无思维难度故不写题解

T1代码

#include<bits/stdc++.h>
#define lowbit(x) (x&(-x))
using namespace std;
const int N=110000,mod=998244353;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int _min(int a,int b)
{
    return a<b?a:b;
}
int n,w[N],sum[2000000],id[N],change[2000000],num[2000000],MX;
long long f[2000000],ans[N],inc[2000000];
long long quick_pow(long long a,long long b)
{
    long long res=1;
    while(b)
    {
        if(b&1)
        {
            res=res*a%mod;
        }
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int count(int x)
{
    int res=0;
    while(x)
    {
        if(x&1)
            res++;
        x>>=1;
    }
    return res;
}
int main()
{
    n=read();
    long long sum=0;
    for(int i=1;i<=n;i++)
    {
        w[i]=read();
        sum=sum+w[i];
        sum%=mod;
        if(i>=2)
            ans[1]+=w[i]*quick_pow(w[i]+w[1],mod-2)%mod;
        ans[1]%=mod;
    }
    ans[1]++;
    printf("%lld\n",ans[1]);
    return 0;
}

T2代码

#include<bits/stdc++.h>
#define lowbit(x) (x&(-x))
using namespace std;
const int N=110000,INF=0x7fffffff;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int _min(int a,int b)
{
    return a<b?a:b;
}
int _max(int a,int b)
{
    return a>b?a:b;
}
int root[N],tot,n,m,q,ans[N];
vector<int> b[N];
struct xds
{
    int s[2],num,l,r,mx;
}t[N*30];
void update(int p)
{
    t[p].mx=0;
    int ls=t[p].s[0],rs=t[p].s[1];
    if(ls&&rs)
    {
        t[p].mx=_max(t[p].mx,t[rs].l-t[ls].r-1);
    }
    t[p].num=t[ls].num+t[rs].num;
    if(ls)
        t[p].l=t[ls].l,t[p].mx=_max(t[p].mx,t[ls].mx);
    else t[p].l=t[rs].l;
    if(rs)
        t[p].r=t[rs].r,t[p].mx=_max(t[p].mx,t[rs].mx);
    else t[p].r=t[ls].r;
    return;
}
void add(int &p,int x,int tl,int tr)
{
    if(!p)
    {
        p=++tot;
    }
    if(tl==x&&tr==x)
    {
        t[p].l=x;
        t[p].r=x;
        t[p].num=1;
        return;
    }
    int mid=(tl+tr)/2;
    if(x<=mid)
        add(t[p].s[0],x,tl,mid);
    else
        add(t[p].s[1],x,mid+1,tr);
    update(p);
}
void merge(int a,int b,int tl,int tr)
{
    int mid=(tl+tr)/2;
    if(!b||!a)
        return;
    if(tl==tr)
    {
        t[a].num|=t[b].num;
        return;
    }
    if(!t[a].s[0]&&t[b].s[0])
    {
        if(t[b].s[0])
            t[a].s[0]=t[b].s[0];
    }
    else if(t[b].s[0])
        merge(t[a].s[0],t[b].s[0],tl,mid);
    if(!t[a].s[1])
    {
        if(t[b].s[1])
            t[a].s[1]=t[b].s[1];
    }
    else if(t[b].s[1])
        merge(t[a].s[1],t[b].s[1],mid+1,tr);
    update(a);
}
void dfs(int u,int fa)
{
    if(!root[u])
        root[u]=++tot;
    for(auto v:b[u])
    {
        if(v==fa)
            continue;
        dfs(v,u);
        merge(root[u],root[v],1,m);
    }
    if(!t[root[u]].num)
        ans[u]=-1;
    else
        ans[u]=_max(t[root[u]].l-1+m-t[root[u]].r,t[root[u]].mx);
}
int main()
{
    n=read();m=read();q=read();
    for(int i=1,u,v;i<n;i++)
    {
        u=read();v=read();
        b[u].push_back(v);
        b[v].push_back(u);
    }
    for(int i=1,x,v;i<=q;i++)
    {
        x=read();v=read();
        add(root[x],v,1,m);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++)
    {
        printf("%d\n",ans[i]);
    }
    return 0;
}

T3Connect题解

巨佬YZF讲的太好了。反向考虑最大保留集。 $f[i][j]$ 表示 $i$ 集合点已经处理过，当前链的头为 $j$ ，每次将一个联通快连向链头，或者拓展一个链头。

T3代码

差不多是抄。

#include<bits/stdc++.h>
using namespace std;
const int N=17;
int f[1<<(N-1)][N],to[1<<(N-1)][N],sum[1<<(N-1)],dis[N][N];
int n,m;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int _max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    n=read();m=read();
    for(int i=1,u,v,w;i<=m;i++)
    {
        u=read();v=read();w=read();
        dis[u][v]=dis[v][u]=w;
    }
    for(int i=1;i<(1<<n);i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                if((i>>(j-1)&1)&&(i>>(k-1)&1))
                    sum[i]+=dis[j][k];
            }
        }
        sum[i]/=2;
    }
    for(int i=1;i<(1<<n);i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                if((i>>(k-1)&1)&&dis[j][k])
                    to[i][j]+=dis[j][k];
            }
        }
    }
    memset(f,-0x7f,sizeof(f));
    f[1][1]=0;
    for(int i=1;i<(1<<n);i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(f[i][j]==-2122219135)
                continue;
            for(int k=1;k<=n;k++)
            {
                if(dis[j][k]&&(!((i>>(k-1))&1)))
                {
                    f[i|(1<<(k-1))][k]=_max(f[i|(1<<(k-1))][k],f[i][j]+dis[j][k]);
                }
            }
            int s=i^((1<<n)-1);
            for(int k=s;k;k=(k-1)&s)
            {
                f[i|k][j]=max(f[i|k][j],f[i][j]+to[k][j]+sum[k]);
            }
        }
    }
    printf("%d\n",sum[(1<<n)-1]-f[(1<<n)-1][n]);
    return 0;
}

中午来了发现学校刷机了。

我300行猪国杀。。。

MDZZ。

SDFZ宿舍：我们每天晚上都会举出一大堆证据证明今天晚上该颓废（打球踢球）了。

今天又是没有打球的一天呢。

紧急加更

曾经：

现在：

---

Day 9

A神的祈祷

可爱

---

Day 10

忙的不行先鸽着

T1Dove 打扑克

水题。实际上可能的状态数小于 \(\sqrt n\)

(原因：\(1+2+3+...+n=\frac{1}{2} n(1+n)\))然后开个vector或者set记录状态即可了。

T1代码

T2Cicada 与排序

ycx_T2

\(g[i]\) 表示某个数字到 \(i\) 位置的概率。

\(f[i][j][0/1][0/1]\) 表示归并排序中，左区间某个数字的第 \(i\) 项，和右区间某个数字的第 \(j\) 项比较的概率，1为 \(i\) 已经为左/右区间最后一个相等的数字，代码中压掉了这两维。

\[f[i][j]=\frac{f[i-1][j]+f[i][j-1]}{2}
\]

T2代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=600,mod=998244353,inv2=499122177;
int n,f[N][N],g[N],h[N],a[N],b[N],posl,posr,pos[N],ans;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
void slove(int l,int r,int pos,int w)
{
    if(l==r)
    {
        g[l]=1;
        return;
    }
    for(int i=l;i<=r;i++)
        b[i]=a[i];
    sort(b+l,b+1+r);
    b[l-1]=0;
    b[r+1]=0;
    int st=0,en=0,mid;
    for(int i=l;i<=r;i++)
    {
        if(b[i]!=b[i-1]&&b[i]==w)
            st=i;
        if(b[i]!=b[i+1]&&b[i]==w)
            en=i;
    }
    mid=(l+r)/2;
    if(pos<=mid)
    {
        slove(l,mid,pos,w);
        for(int i=l;i<=mid;i++)
            b[i]=a[i];
        sort(b+l,b+1+mid);
        b[l-1]=b[mid+1]=0;
        for(int i=l;i<=mid;i++)
        {
            if(b[i]!=b[i-1]&&b[i]==w)
                posl=i;
            if(b[i]!=b[i+1]&&b[i]==w)
                posr=i;
        }
        int num=0;
        for(int i=mid+1;i<=r;i++)
        {
            if(a[i]==w)
                num++;
        }
        for(int i=0;i<=posr-posl;i++)
        {
            for(int j=0;j<=num-1;j++)
            {
                h[st+i+j]=(h[st+i+j]+g[posl+i]*f[i][j]%mod*inv2%mod)%mod;
            }
            int sum=0;
            if(!num)
                sum=1;
            else
            {
                for(int j=0;j<=i;j++)
                    sum=(sum+f[j][num-1])%mod;
                sum=sum*inv2%mod;
            }
            h[st+i+num]=(h[st+i+num]+g[i+posl]*sum)%mod;
        }
        for(int i=l;i<=r;i++)
            g[i]=0;
        for(int i=st;i<=en;i++)
        {
            g[i]=h[i];h[i]=0;
        }
    }
    else
    {
        slove(mid+1,r,pos,w);
        for(int i=mid+1;i<=r;i++)
            b[i]=a[i];
        sort(b+mid+1,b+1+r);
        b[mid]=b[r+1]=0;
        for(int i=mid+1;i<=r;i++)
        {
            if(b[i]!=b[i-1]&&b[i]==w)
                posl=i;
            if(b[i]!=b[i+1]&&b[i]==w)
                posr=i;
        }
        int num=0;
        for(int i=l;i<=mid;i++)
        {
            if(a[i]==w)
                num++;
        }
        for(int i=0;i<=posr-posl;i++)
        {
            for(int j=0;j<=num-1;j++)
            {
                h[st+i+j]=(h[st+i+j]+g[posl+i]*f[i][j]%mod*inv2%mod)%mod;
            }
            int sum=0;
            if(!num)
                sum=1;
            else
            {
                for(int j=0;j<=i;j++)
                    sum=(sum+f[j][num-1])%mod;
                sum=sum*inv2%mod;
            }
            h[st+i+num]=(h[st+i+num]+g[i+posl]*sum)%mod;
        }
        for(int i=l;i<=r;i++)
            g[i]=0;
        for(int i=st;i<=en;i++)
        {
            g[i]=h[i];h[i]=0;
        }
    }
    return;
}
signed main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
    }
    f[0][0]=1;
    for(int i=1;i<=n;i++)
    {
        f[i][0]=f[i-1][0]*inv2%mod;
        f[0][i]=f[0][i-1]*inv2%mod;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            f[i][j]=(f[i-1][j]+f[i][j-1])*inv2%mod;
        }
    }
    for(int i=1;i<=n;i++)
    {
        memset(g,0,sizeof(g));
        memset(h,0,sizeof(g));
        slove(1,n,i,a[i]);
        

T3Cicada 拿衣服

其实完全不需要题解说的链表，暴力数组就好，然而我还是用了。
显然，对于每个右端点， $or-and$ 在一定连续左端点区间内是不变的。而且随着右端点增大，左端点连续， $or-and$ 不变的区间只会拓展。
暴力枚举右端点，对于每一个左边连续不变的区间，暴力更新它的 $or$ 和 $and$ 值。然后在其区间内二分最小的 $min-max$ （满足单调），贪心选择答案。

T3代码

#include<bits/stdc++.h>
#define lowbit(x) (x&(-x))
using namespace std;
const int N=2220000,INF=0x7fffffff;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
inline int _max(int a,int b)
{
    return a>b?a:b;
}
inline int _min(int a,int b)
{
    return a<b?a:b;
}
int n,k,a[N],ansl,ansr,len,stm[N][22],sti[N][22],cnt=0;
struct xds
{
    int l,r,mx,lz;
}t[N<<2];
void build(int p,int l,int r)
{
    t[p].l=l;
    t[p].r=r;
    if(l==r)
    {
        return;
    }
    int mid=(l+r)/2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
}
void update(int p)
{
    t[p].mx=_max(t[p*2].mx,t[p*2+1].mx);
    return;
}
void pushdown(int p)
{
    if(t[p].lz)
    {
        t[p*2].mx=_max(t[p*2].mx,t[p].lz);
        t[p*2+1].mx=_max(t[p*2+1].mx,t[p].lz);
        t[p*2].lz=_max(t[p*2].lz,t[p].lz);
        t[p*2+1].lz=_max(t[p*2+1].lz,t[p].lz);
    }
    return;
}
void edit(int p,int l,int r,int v)
{
    if(l<=t[p].l&&t[p].r<=r)
    {
        t[p].mx=_max(t[p].mx,v);
        t[p].lz=_max(t[p].lz,v);
        return;
    }
    pushdown(p);
    if(l<=t[p*2].r&&t[p*2].l<=r)
        edit(p*2,l,r,v);
    if(l<=t[p*2+1].r&&t[p*2+1].l<=r)
        edit(p*2+1,l,r,v);
    return;
}
int query(int p,int l,int r)
{
    if(l<=t[p].l&&t[p].r<=r)
    {
        return t[p].mx;
    }
    pushdown(p);
    if(l<=t[p*2].r&&t[p*2].l<=r)
        return query(p*2,l,r);
    else
        return query(p*2+1,l,r);
}
struct lis
{
    int pre,nxt,r,xo,an;
}lb[N];
int main()
{
    n=read();k=read();
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
        stm[i][0]=sti[i][0]=a[i];
    }
    for(int j=1;j<=20;j++)
    {
        for(int i=1;i<=n;i++)
        {
            stm[i][j]=_max(stm[i][j-1],stm[i+(1<<(j-1) )][j-1]);
            sti[i][j]=_min(sti[i][j-1],sti[i+(1<<(j-1) )][j-1]);
        }
    }
    build(1,1,n);
    for(int r=1;r<=n;r++)
    {
        for(int i=cnt;i;i=lb[i].pre)
        {
            lb[i].xo|=a[r];
            lb[i].an&=a[r];
        }
        lb[cnt].nxt=cnt+1;
        cnt++;
        lb[cnt]={cnt-1,0,r,a[r],a[r]};
        for(int i=cnt;i;i=lb[i].pre)
        {
            if(lb[lb[i].pre].xo-lb[lb[i].pre].an==lb[i].xo-lb[i].an&&cnt>2)
            {
                lb[lb[i].pre].nxt=lb[i].nxt;
                lb[lb[i].nxt].pre=lb[i].pre;
                lb[lb[i].pre].r=lb[i].r;
            }
        }
        for(int i=1,le,ri,mid,lg,anss=0;i;i=lb[i].nxt)
        {
            anss=0;
            le=lb[lb[i].pre].r+1;
            ri=lb[i].r;
            lg=log2(r-ri+1);
            if(lb[i].xo-lb[i].an+_min(sti[ri][lg],sti[r-(1<<lg)+1][lg])-_max(stm[ri][lg],stm[r-(1<<lg)+1][lg])<k)
                continue;
            while(le<=ri)
            {
                mid=(le+ri)/2;
                lg=log2(r-mid+1);
                if(lb[i].xo-lb[i].an+_min(sti[mid][lg],sti[r-(1<<lg)+1][lg])-_max(stm[mid][lg],stm[r-(1<<lg)+1][lg])>=k)
                {
                    anss=mid;
                    ri=mid-1;
                }
                else
                {
                    le=mid+1;
                }
            }
            if(anss)
            {
                edit(1,anss,r,r-anss+1);
                break;
            }
        }
    }
    for(int i=1,tmp;i<=n;i++)
    {
        tmp=query(1,i,i);
        printf("%d ",tmp!=0?tmp:-1);
    }
    puts("");
    return 0;
}

---

Day 11

考场T1/2/4正解然而只写出了T1。

这几天考得相当烂超级丢人。

上午非常不想改题。

中午和SpadeA261一起去给饭卡充钱。

一边聊天一边走，然后：

HKHcutest：到哪了

SpadeA261：我不是跟你走的？

HKHcutest：哈？

红色为当时位置。

但是：

于是在校园里转悠过的HKH成功利用他的经验问到了路。

返回：

如图，HKHcutest的路径颜色由黑至蓝，SpadeA261的路径颜色由红至黄，求两人路径长度。

---

由于马上饭卡就不能充钱了，而我们可能得在衡水滞留一段时间，所以下午大家一起充钱。

莫名其妙谈到逃离HZ的问题。

HKHcutest:嘁，HZ的墙上连个电网都没有，SDFZ的墙上还有电网虽然不通电就是吓吓人。只要你从xxx到xxx，通过xxx到xxx就可以轻易翻出去了！

其他人:你怎么这么熟练啊

---

HKH:你看HZ旁边有个大飞机你直接溜过去开飞机回太原就好了。

Cyber_tree:开坦克啊开什么飞机

fake佬:屁，你看那个牛那么精神直接骑牛回去才牛批。

HKH:不，开坦克有可能会和骑牛的撞上，只有飞机早早飞上去才有生还希望。

---

实际操作:

HKH开着飞机发现过于难操作于是一头栽到急驶的坦克上，残骸平移着把牛推进了HZ河里。

顺便一提昨晚HZ下雨，HZ河决堤了……

---

Day 12

中午突然食堂不开，大家一起回宿舍喝水。

不是，好像HZ人对突然饿肚子这事已经习以为常了？？？

晚饭换食堂，吃完HZ食堂全部种类的事业：完成->未完成。

SpadeA261和Natural_Horse在机房玩叉子。

然后叉子掉落到地上。

Natural_Horse去洗叉子。

于是全厕所人看着Natural_Horse举着叉子走进厕所。

好像要大吃一顿

---

Day 13

T1打地鼠 题解

CSP-J T1题

T1代码

#include<bits/stdc++.h>
using namespace std;
const int N=3000;
inline int read()
{
    int s=0,w=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
int n,k,a[N][N],sum[N][N],ans;
char p[N];
int main()
{
    n=read();k=read();
    for(int i=1;i<=n;i++)
    {
        scanf("%s",p+1);
        for(int j=1;j<=n;j++)
        {
            sum[i][j]=sum[i][j-1]+p[j]-'0';
        }
    }
    for(int j=1;j<=n;j++)
    {
        for(int i=1;i<=n;i++)
        {
            sum[i][j]+=sum[i-1][j];
        }
    }
    for(int i=k;i<=n;i++)
    {
        for(int j=k;j<=n;j++)
        {
            if(sum[i][j]-sum[i][j-k]-sum[i-k][j]+sum[i-k][j-k]>ans)
            {
                ans=sum[i][j]-sum[i][j-k]-sum[i-k][j]+sum[i-k][j-k];
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

T2竞赛图 题解

对于一个强连通分量 $s$ ,设它所有出边并集为 $t$ 则 $s \cup t‘,t’\subseteq t$ 一定不强联通，竞赛图缩点后一定是一个链，所以可以分成划出两个点集，使得不强联通。

T1代码

T1打地鼠 题解

CSP-J T1题

T1代码

这篇博客里有4个彩蛋！有一定难度，可以来找找看。

彩蛋1：无人发现

彩蛋2：SpadeA261误打误撞反应BUG时发现。

彩蛋3：SpadeA261破解

彩蛋4：

有趣的事：大不美列坚说：你看，这个××wx，肯定是微信的意思，所以他把××机惨了！！！

---

深夜SpadeA261与其妹妹通话：

妹妹:哥哥我想你了！

SpadeA261:好可爱啊！

妹妹：哥哥我想你了！

SpadeA261：我也想你了！

一旁的HKHcutest想到：“我的妹妹不可能这么可爱”

后来知道是弟弟。

QAQ。

难过。

---

和两人一起去送酸奶，出门时被大喊：“快更HZ游记！”

感觉自己火了（

---

SpadeA261：HKHbest只没有给我起外号。

HKHbest：那叫你周大爷吧。

SpadeA261：我还小……

HKHbest：那就周小爷吧……

SpadeA261：我TM

周楷轩谐音JOKER轩

Cyber_tree：叫他小王（JOKER）。。。。。。吧。

HKHcutest：小王。。。。。。吧。

---

Day 13

上午刷新最低成绩，两次叉了自己的正解。

哭兮兮。

下午是13天以来首次放假！！！

中午睡很晚，起来众巨佬打牌。然后我去拼团剧本杀，成功盘出凶手但是另外5个猪队友一直扯皮导致没能凶手逃了（气）。

然后想又双叒叕试着追一部番（一直想但每一回都被劝退），看了JOJO第一集，成功又双叒叕被劝退。

对A神：你看你不懂得打热水的效率，不要在温水头接水，去开水头接一点点水，然后就可以去冷水那边开两个大水龙头去接快的一批。

然后在接冷水的时候水龙头流出了黄色的不明液体。

像极了……

---

Day 14

T2少考虑了100>60。

《关于HKH对着YPJ大喊一句巨佬听说YPJ回来了？？？》

《关于HKH洗完澡然后吕老师说你咋还光着个腚这件事》

---

Day 15

有人被猫抓了。

大家不要去不安全逗猫。

这几天经常播放关于阿富汗的新闻，这里贴一篇文。

挂美国飞机的人掉下去了哦霍霍西贡铁拳有人知道嘛

真「水博客」

戈尔巴乔夫的真实身份是咒术师。

“帝国裂解大阵”是他毕生的心血，“献祭苏联”是完成该阵的必要条件，而美苏争霸则是咒术的映射，在咒术结构中形成对应关系。一场必败的冷战是一曲二十世纪的悲歌，是一段反法西斯的续集，是一招逆天大咒的起手式。

他背负骂名也要和美利坚同归于尽，只有这样地球才能从霸权噩梦中得救。

咒成之日，便是头顶地图咒印裂解之时，美国将会分崩离析，遭受苏联当年同样下场。

“苏联死了，为什么你还活着！”

全世界都在质问戈尔巴乔夫这句话，每当他想起这样的质问，他的嘴唇都会颤抖，眼眶湿润，欲言又止。

他知道答案，却不能回答。

苏联解体后，漂亮的女孩儿们被卖往西欧，训练有素的军人成了黑手党，精良的武器被低价贩卖去换取日用品，反法西斯的伟大历史被窃取。世界因为全球霸权的拱手相让而变得黑白颠倒。

1991年后的世界，他看在眼里，疼在心里。

骂声如海啸般扑来，他好想被这股巨浪吞噬，可他犯下的罪恶，决东海之波流恶难尽。事已至此，他知道做什么都是于事无补。“苏联死了，我为什么还活着！”他这句答不出来的质问，心里一直有着答案。

答案在他和苏联祭祀们共同完成的阵法里，答案在莫斯科郊外大先知的水晶球里，答案在一个可期的未来，答案在不远的过去。

那年戈尔巴乔夫还年轻，头上的地图还藏在头发里，帝国裂解大阵的基本布局早已完成。当他知道最后的祭品是自己的祖国时，他崩溃了。“不，我不能这样做！”他哭着向祭祀们请求，他不想成为祖国的罪人。

“为了世界和平，你必须这样做。当初赫鲁晓夫没有按下发射按钮，证明军事上的同归于尽不可行。此时你必须担起责任，阻止新法西斯帝国的诞生。”

“我明白！可我无法亲手毁掉我的祖国。”

大祭祀安慰他道：“你可以骗自己说是为了追求苏联人民的自由民主啊。”“那不是狗吗！”祭祀啊了一声，心知难为眼前的这位年轻人了。他泪眼汪汪得轻抚戈尔巴乔夫的头发，地图咒印在头上如风吹草低见牛羊般隐现。

大祭司语重心长得说道：“我也不想让独自背负这样的痛苦。可你是帝国裂解大阵的阵眼转世，这件事非你不可。孩子，对不起。”

戈尔巴乔夫流着眼泪说道：“汪！汪汪汪，汪汪！汪汪汪！！！”

大祭司抱着少年戈尔巴乔夫哭成了一团。

从此，一个苏联的煞星就此诞生了。

还记得那年圣诞节，他默默的对自己许下誓言。“苏联请等等我，我会让美国去地下陪你。”

随着克林姆林宫降下了一面镰锤红旗，莫斯科的冬天更冷了。

苏联解体时，老布什曾经接到戈尔巴乔夫的一封信。拿到信的他说了这样一句话“这里面每一个字我都认识，可连起什么意思我却看不懂。”

当时人们说这封信是戈尔巴乔夫祈求美国援助兑现的求助信，而老布什巧妙得装傻避开了这些纠缠，任由苏联粉碎得七零八落。一时间在资本主义阵营中传为佳话。

但事实上并非如此，事后老布什猛然间惊觉，这封信是帝国裂解大阵的“邀请函”。其信件内容用了异世界的语法，导致人类虽然认识上面的英文单词，却无法通顺得在脑内形成理解。当他意识到真相的时候已经为时已晚，帝国裂解大阵已经通过美国领导人锁定了美国本土。

知晓真相的人总是痛苦的。老布什从没有觉得自己是最幸运的美国总统，反而是最危险的一届。因为接下来的日子里，布什家族只能接连发起战争，以异国人血祭的方式对抗戈尔巴乔夫的灭国阵法，为美国强行续命。

布什家族的咒术，早在老布什在北京工作的时候已经臻于化境。当时他寻访华夏仙山拜访名师，终于在一座仙山上偷师禁术，炼一出式沥血天劫咒，此咒可用他国鲜血为帝国续命，但代价昂贵，不是师父不教，是老前辈不想见苍生涂炭。老布什也明白这一点，如今也是不得已才用了这禁术，后来的911恐怖袭击就是这咒的代价。

2001年，被老布什偷师禁术的老道正在看电视，他看着荧幕中世贸大厦的崩塌，流着泪原谅了这个来自异国的偷师崽子。

后来北京的十万仁波切，皆在暗中找寻当年老布什留下的法术残骸，只为一睹禁术修习者的风采。他们表面上为填补富人心灵空缺而来，实际心中有着更大的遗憾。

布什家族到了小布什一代则更进一步。911之后，小布什冒天下之大不韪，为了一罐洗衣粉也要发动战争，哪怕中东找不到任何利益。同时布什家族也透露了一些信息给民主党，促成了两党联手。后来奥巴马也变得好战，不是没有道理。甚至骗到诺贝尔和平奖来加持咒术，以延国祚。

老布什垂垂老矣，曾在生命的最后三年内警告布什家族的人，不要让特朗普上位。

子孙纷纷不解。老布什说道：“你们有没有发现，他说的话颠三倒四不像人话？”

“当然，全国人民都发现了。”

“那是异世界语法的痕迹，如同一个人带着方言口音说话。”

“这.......难道是......”

“没错，他是前苏联祭祀召唤而来的异世界法师，是帝国裂解大阵的灵媒，快阻止他！不要让他上位.....否则....帝国将会土崩瓦解。”

从那以后，布什家族虽身在共和党核心，却也是最反对特朗普的家族，有时比民主党还要反对他。

而特朗普至今不知许多通俄门的黑料并不单单来自民主党的操弄，也有自家党派的贡献。

自特朗普成功得当选，每天都在消耗国家的霸权和国际影响力。

别看他平日一副斗犬之相，而其任期内没有发动任何战争，不给血咒增加任何咒力，甚至还想要撤兵回国，为此不知为承受了多大的政治压力。

2020年，他不惜牺牲美国人的性命也要连任，这不是没有道理的。

可惜天劫咒的第二天劫来得太早，副作用和帝国裂解大阵的咒力发生了叠加效应，溢出效果溅射全世界。没错，就是那个Cov-19。

美国作为承咒国首当其冲，承受最大伤害。也因为这场新冠大疫害死了太多了美国百姓，不然特朗普连任是板上钉钉的事。

时也、命也，可能老天只愿意给他四年的机会吧，把握得如何事在人为了。

就在国家倾危之际，布什家族暂退历史舞台，民主党接起护国大旗。这时国家已经露出颓败之相。

众议院代号Witch的女人连任了，国家需要灵力颇深的她掌控局面。

彼时，她终于发现了特朗普的真面目，如果让这个房地产总统走完一整个任期，帝国裂解大阵将会进入尾声，到时候不会有任何魔法可以将其停下。咏唱打断术正是她的拿手好戏。

于是她振臂一呼，“弹劾，罢免！赶走特朗普！不要让他走完一个完成的任期！立刻行动！Nowwwww！”

民主党一众纷纷响应。危急时刻，九大法官齐力召唤美国的隐藏宪法，发现该宪法所记载，异世界的语言并不享有美利坚合众国的言论自由，咒语咏唱更不适用。

这下美国各界资本纷纷表态，要集体打断特朗普的咏唱，禁止他用异世界语言召唤阴兵。为了避免特朗普在社交媒体上布置阵法，阻止他咏唱那咒术，推特、Facebook、甚至黑黄站接连对特朗普进行账号封禁。

一场围剿特朗普的行动开始了。特朗普看着退潮的红脖支持者，倍感压力。他明白自己大势已去，他只希望戈尔巴乔夫能行动快一点。

地球的另一端。挡住了上万次的暗杀的戈尔巴乔夫，坐在了多国间谍和特工的尸体上，目露疲惫。看着被魔法吓疯的美国特工幸存者，自顾自得说道：“我比你更希望戈尔巴乔夫死去，但不是现在。”

随即房间中一声惨叫，血污在窗户上泼洒，夸张得像泼墨风景画。

克格勃的幽灵小队走了进去，进行了妥善的善后。把暗杀者的痕迹抹杀得像是从未存在过一样。

戈尔巴乔夫行尸走肉般从房间里走来，莫斯科的阳光竟是那么刺眼。还需要等多久？一切就快要结束了吧。

戈尔巴乔夫翻看手机里华盛顿被攻破的新闻，初露笑容。

那个叫戈尔巴乔夫的男人可以去死了。

主要是没什么想说的又不能空着所以随意转点

Cyber_tree被我安利了galgame开心

总算见到传闻里干啥的时候都拿着书在看的人了，衡中刻板印象诚不我欺。

对了，诚不我欺哪个字是宾语前置标志来着……

好像没有宾语前置标志

这两天都没人找彩蛋了诶最简单那个你们竟然都没找到

---

Day 16

彩蛋攻略：

彩蛋1：Ctrl+A仔细找

彩蛋2：上文的一大堆“社死了”里面藏了一个“杜死了”，杜字是第18组第一个，指向我的洛谷博客1801。

彩蛋3：F12找到我的博客副标题，和这篇博客的摘要组合起来可以得到一个洛谷云剪贴板地址。

什么你找不到？拿我的洛谷个签去查啊。

彩蛋4：上文有一段我看什么什么东西是什么颜色，神经病一样非常开心。F12找到那四个颜色对应的RGB编号，连起来即为我博客园一篇分类在“彩蛋”里的博客的密码。

挺难的吧

---

Day INF

8月31日，收到了私信问校服要多少码，然后我没看见，错失买校服大好时机。

难过但我不会放弃的