2024暑假集训第二章——广东

~~大型选妃现场~~

由于某些原因，不能透露集训的学校名称。

挑战：全文出现了几次“你玩原神吗”，数清者赠送AC_love的决绝一次
day -inf

从hl回来在家摆烂

成就：看完了《东方幻想万华镜》+巴黎奥运会开幕式，《东方永夜抄》E难度打通，洛谷变橙

day1 7.28

今天，我们来到了人杰地灵，物种丰富的学校，可以看出学校对学生吃苦耐劳的品质教育非常到位。家父评价：宿舍让我回忆起了曾经大学时期的青春往事（家父1992年上大学，上的军校）。

干湿不分离的卫生间+蹲厕+铁架床+没有电源+电话拨不出去+蚊帐成了马奇诺防线+非国标空调插头

我***********************************************

全国最美中学，看来名不虚传。感觉那个宿舍比八意永琳岁数还大，很有历史沧桑感。

¿xxxx中学，你玩原神吗？

可以看出宿舍的环境很有去城市化的美感，很显然，整个人都不好了。

用了不到半个小时弄好蚊帐和床铺，打败99%的同学

主线任务：survive（0/28）

day2 7.29

上午模拟赛，不幸的是第二题卡住了，于是后两题没做，t2写出了正解的方法，但是挂分了

最后100+20，寄了

中午去吃饭，可以看到楼梯上瀑布一般倾斜而下的水，鞋直接透了

终于知道为什么港片里的包租婆都穿拖鞋了/kel

谁家学校有鸭子啊

重点是鸭子竟然吃苏打饼干

有一种一群人抢省队名额的美感

鸭子都在卷，为什么我在摆

day3 7.30

上午模拟，人品爆炸

t4涉及莫反，麻了，啥也不会

焯！

小卖铺开了，这是好的

但是只有各种酸奶+milk+豆奶，还有那个咬着跟硅胶手机后盖一样的猪肉脯

为了纪念孙中山先生而建立的那个学校，你玩原神吗？

下午和HB，jyy，李某学找好一点的小卖铺，return -1

下午由于调不动题了，于是在洛谷上random_shuffle，看看你谷给我推了什么好东西

有好题，索性开写

upd：谁家机房不让带耳机啊？！

人脸识别一直不好用，麻了，于是狼狈地用智能手表扫码付钱

但是每个窗口都配备了扫码口但是就一个支持扫码

你玩原神吗？？？？？？？？

day4 7.31
上午继续模拟赛，第一题是个比较水的线段树，第二题......
计算几何你math了
于是用了一个下午恶补了一下计算几何以及向量外积
想起了一句话：whk滚出oi
upd：中午睡醒了发现下午三点半了，怎么会逝呢

day5 8.1

上午模拟

数学含量极高，有数学的时候暴力就完全失效了

不多说了

寄了
upd：谁家提高B组t2出黑题啊，而且为了防止盒题解还放了个蓬莱山辉夜作为背景

day6 8.2
上午没有模拟，订正

同时讲了一些很离谱的东西，状压dp，kmp，hash，线性规划，主席树

“对于非基变量要把它转化为基变量需要进行‘坠机’（转轴）操作”————李某学

有一说一，那些机房咋咋呼呼的xxs能不能去死啊！！！！！！！！！

下午拿到了手机，这里竟然是周末双休，这是好的

已经一年没体验过周六休息了
upd:单休，周六休息

day7 8.3

摆

day8 8.4

很显然，上午赤石

下午来到了机房，VP CF1991

建议改名construction force，全是构造

Kazdale有一个dp题单叫做：“前面忘了后面忘了中间忘了，总之只能度过一个相对失败的人生”

建议叫“早上赤石，晚上赤石，中午赤石，总之赤了一整天石”

day9 8.5

突然发现没有往博客里放一点学术性的东西
那就放一些吧
主席树专题，严格来说叫做主席“并查集”————Luogu P3402

点击查看代码

//写完主席树来写个“主席并查集”
#include<bits/stdc++.h>
#define re register
using namespace std;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 4e6+5;
int ls[maxn],rs[maxn],cnt=0,dep[maxn],fa[maxn],ed[maxn],n,m;
namespace ***
{
    inline void build(int x,int l,int r)
    {
        if(l==r)
        {
            fa[x]=l;
            return;
        }
        int mid = (l+r)>>1;
        build(ls[x]=++cnt,l,mid);
        build(rs[x]=++cnt,mid+1,r);
    }
    inline void change(int x,int l,int r,int pos)
    {
        if(l==r)
        {
            dep[x]++;
            return;
        }
        int mid = (l+r)>>1;
        if(pos<=mid)
        {
            change(ls[x],l,mid,pos);
        }
        else
        {
            change(rs[x],mid+1,r,pos);
        }
    }
    inline int qu(int x,int l,int r,int pos)
    {
        if(l==r)
        {
            return x;
        }
        int mid = (l+r)>>1;
        if(pos<=mid)
        {
            return qu(ls[x],l,mid,pos);
        }
        else
        {
            return qu(rs[x],mid+1,r,pos);
        }
    }
    inline void merge(int lst,int &rt,int l,int r,int pos,int f)
    {
        rt=++cnt;
        ls[rt]=ls[lst];
        rs[rt]=rs[lst];
        if(l==r)
        {
            fa[rt]=f;
            dep[rt]=dep[lst];
            return;
        }
        int mid = (l+r)>>1;
        if(pos<=mid)
        {
            merge(ls[lst],ls[rt],l,mid,pos,f);
        }
        else
        {
            merge(rs[lst],rs[rt],mid+1,r,pos,f);
        }
    }
    inline int find(int x,int pos)
    {
        int now=qu(x,1,n,pos);
        if(fa[now]==pos)
        {
            return now;
        }
        return find(x,fa[now]);
    }
}
using namespace ***;
int main()
{
    int a,b;
    n=read(),m=read();
    ***::build(ed[0]=++cnt,1,n);
    for(re int i=1;i<=m;i++)
    {
        int opt=read();
        if(opt==1)
        {
            ed[i]=ed[i-1];
            a=read(),b=read();
            int faa=find(ed[i],a),fb=find(ed[i],b);
            if(fa[faa]==fa[fb])
            {
                continue;
            }
            if(dep[faa]>dep[fb])
            {
                swap(faa,fb);
            }
            ***::merge(ed[i-1],ed[i],1,n,fa[faa],fa[fb]);
            if(dep[faa]==dep[fb])
            {
                ***::change(ed[i],1,n,fa[fb]);
            }
        }
        if(opt==2)
        {
            a=read();
            ed[i]=ed[a];
        }
        if(opt==3) 
        {
            a=read(),b=read();
            ed[i]=ed[i-1];
            int f1=find(ed[i],a),f2=find(ed[i],b);
            if(fa[f1]==fa[f2])
            {
                puts("1");
            }
            else 
            {
                puts("0");
            }
        }
    }
    return 0;
}

还有一道比较“凉心”的题目，在LCT处理完以后需要主席树维护生成的序列————P5385
出题人你玩原神吗
请三思后展开下面的代码

点击查看代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
inline int read()
{
   int x=0,f=1;
   char ch=getchar();
   while(ch<'0'||ch>'9')
   {
       if(ch=='-')
           f=-1;
       ch=getchar();
   }
   while(ch>='0' && ch<='9')
       x=x*10+ch-'0',ch=getchar();
   return x*f;
}
const int maxn = 1e6+5;
const int inf = 0x3f3f3f3f;
int n,m,q,seed,ear[maxn];
class LCT
{
    private:
    struct node
    {
        ll to,nxt;
    }e[maxn];
    ll son[maxn][2],fa[maxn],mi[maxn],minn[maxn];
    ll val[maxn],sta[maxn],r[maxn];
    inline ll unroot(ll x)
    {
        return son[fa[x]][0]==x or son[fa[x]][1]==x;
    }
    inline void update(ll x)
    {
        ll lt=son[x][0],rt=son[x][1];
        mi[x]=min(mi[lt],mi[rt]);
        if(mi[x]==mi[lt])
        {
            minn[x]=minn[lt];
        }
        else
        {
            minn[x]=minn[rt];
        }
        if(val[x]<=mi[x])
        {
            mi[x]=val[x];
            minn[x]=x;
        }
    }
    inline void pushr(ll x)
    {
        swap(son[x][0],son[x][1]);
        r[x]^=1;
    }
    inline void pushdn(ll x)
    {
        if(r[x])
        {
            if(son[x][1])
            {
                pushr(son[x][1]);
            }
            if(son[x][0])
            {
                pushr(son[x][0]);
            }
            r[x]=0;
        }
    }
    inline void rotate(ll x)
    {
        ll y=fa[x],z=fa[y],ls=(son[y][1]==x);
        if(unroot(y))
        {
            son[z][son[z][1]==y]=x;
        }
        son[y][ls]=son[x][ls^1];
        fa[son[y][ls]]=y;
        son[x][ls^1]=y;
        fa[y]=x;
        fa[x]=z;
        update(y);
        update(x);
    }
    inline void splay(ll x)
    {
        ll y=x,tot=0;
        sta[++tot]=y;
        while(unroot(y))
        {
            sta[++tot]=y=fa[y];
        }
        while(tot)
        {
            pushdn(sta[tot--]);
        }
        while(unroot(x))
        {
            y=fa[x];
            if(unroot(y))
            {
                ll z=fa[y];
                if((son[y][0]==x)^(son[z][0]==y))
                {
                    rotate(x);
                }
                else
                {
                    rotate(y);
                }
            }
            rotate(x);
        }
    }
    inline void access(ll x)
    {
        for(ll y=0;x;y=x,x=fa[x])
        {
            splay(x);
            son[x][1]=y;
            update(x);
        }
    }
    inline void buildroot(ll x)
    {
        access(x);
        splay(x);
        pushr(x);
    }
    inline void split(ll x,ll y)
    {
        buildroot(x);
        access(y);
        splay(y);
    }
    inline ll qu(ll x,ll y)
    {
        split(x,y);
        return minn[y];
    }
    inline ll find(ll x)
    {
        access(x);
        splay(x);
        while(son[x][0])
        {
            pushdn(x);
            x=son[x][0];
        }
        splay(x);
        return x;
    }
    inline void cut(ll x,ll y)
    {
        split(x,y);
        son[y][0]=fa[x]=0;
    }
    inline void link(ll x,ll y)
    {
        buildroot(x);
        fa[x]=y;
    }
    public:
    inline void work()
    {
        for(int i=0;i<=n;i++)
        {
            val[i]=mi[i]=inf;
            minn[i]=i;
        }
        ll tot=n;
        for(int i=1;i<=m;i++)
        {
            int u=read(),v=read();
            e[i]=(node){v,u};
            if(u==v)
            {
                ear[i]=i;
                continue;
            }
            else if(find(u)==find(v))
            {
                ll tmp=qu(u,v),x=val[tmp];
                ear[i]=x;
                cut(e[x].nxt,tmp);
                cut(e[x].to,tmp);
            }
            ++tot;
            mi[tot]=val[tot]=i;
            minn[tot]=tot;
            link(u,tot);
            link(v,tot);
        }
    }
}lct;
class BXL
{
    private:
    ll nod,siz[maxn*20],son[maxn*20][2],root[maxn];
    inline void update(ll pre,ll &now,ll l,ll r,ll v)
    {
        now=++nod;
        siz[now]=siz[pre]+1;
        if(l==r)
        {
            return;
        }
        ll mid = (l+r)>>1;
        if(v<=mid)
        {
            update(son[pre][0],son[now][0],l,mid,v);
            son[now][1]=son[pre][1];
        }
        else 
        {
            update(son[pre][1],son[now][1],mid+1,r,v);
            son[now][0]=son[pre][0];
        }
    }
    inline ll qu(ll pre,ll now,ll l,ll r,ll v)
    {
        if(l==r)
        {
            return siz[now]-siz[pre];
        }
        ll mid = (l+r)>>1;
        if(v<=mid)
        {
            return qu(son[pre][0],son[now][0],l,mid,v);
        }
        else
        {
            return qu(son[pre][1],son[now][1],mid+1,r,v)+
            siz[son[now][0]]-siz[son[pre][0]];
        }
    }
    public:
    inline void work()
    {
        for(int i=1;i<=m;i++)
        {
            update(root[i-1],root[i],0,m,ear[i]);
        }
        ll lst=0;
        while(q--)
        {
            ll l=read(),r=read();
            if(seed>0)
            {
                l=1ll*(l+1ll*seed*lst%m)%m+1;
                r=1ll*(r+1ll*seed*lst%m)%m+1;
            }
            if(l>r)
            {
                swap(l,r);
            }
            lst=n-qu(root[l-1],root[r],0,m,l-1);
            cout<<lst<<endl;
        }
    }
}***;
int main()
{
    n=read(),m=read(),q=read(),seed=read();
    lct.work();
    ***.work();
    return 0;
}

来这里一周了好像还没说住宿体验如何，那么简单写几句。
点击下载
下下来后可以在vscode下载markdown插件或者直接用typora打开

day10 8.6

麻了，继续赤石，略
但是经过我的实验，睡觉的时候在腰下垫着枕头（被子）或者侧躺睡觉可以有效缓解因为铁板床造成的腰疼问题。

day11 8.7

最赤石的一集，上午写完t1的暴力开始写t4的树上dp做法，结果因为没有统计链长趋势了，后来才知道，朴素dp $O (n^{3})$ 是绝对不可能通过的，甚至需要考虑容斥，后来sc尝试用点分树结果坠机了。

中午闲聊（被前来听课的小孩哥逼疯的第 $i$ 天）

zimo：我小学的时候哪有这般小孩咋呼。我刚上小学的时候老师就教我上课要保持安静

fd：他们从小就停课了应该没有老师这个概念

zimo：没老师难道没父母吗

sc1234：你怎么知道他们没有

建议改名：抛砖引玉

day12,13,14 8.8,8.9,8.10
稀松平常的三天，索性不更新了，期待下周

upd：做完了幽灵乐团（莫反“基础”练习题），感觉自己要去冥界了

day15 8.11
打比赛打爽了，上午noip模拟纯属赤石，下午hbcpc比赛，不太理解为什么就打了3道题却直接干到了rk155，晚上arc，第一次打这么人类智慧的比赛。

upd：第二天早上睡到了7点半，但是是一周来第一次早上吃饭，怎么会逝呢。

小炒食堂关了，不开心。

upd：本日记停更，煞笔集训，全是撤硕题目，后半段纯TM在水洛谷题库+铁牌导航

这一个月算是一个线性递推

while(date<=8/25/2024)
{
	if(rest)
	{
		rest=false;
		play(touhou);
		play(phone);
		play(flight_pilot); 
	}
	else
	{
		eat(s**t);
		if(!teacher(chd))listen(s**t);
		solve(luogu || bytoj);
	}
	if(date==Friday)
	{
		rest=true;
		
	}
	date++;
}