The Trip of Fantasia / Beijing

导语 - 2024/12/11

三年前，我第一次踏进 CSP-J/S 初赛的考场，看着令人绝望的指针式笛卡尔树，我失去了向前迈进一步的机会。

两年前，我第二次踏进 CSP-J/S 初赛的考场，在获得了不错的成绩后，我第一次踏进了复赛考场，但因自身实力的不足而靠对总司令的哀求仅拿到 \(65\) 分。

一年前，在经过了看起来非常充足的准备后，我第二次踏进复赛考场，但在面对那个外表普通却令人胆寒的游戏时，我没有想出正确的解法。就算有第三题那样仅靠耐心就能解决的问题，我也因耐心的缺失而失去了再向前走一步的机会。那年，我失去了两位朋友。我感到迷茫，为什么其他人都拿到了一等，而我不能。

我对这门竞赛的看法似乎发生了一点改变。

今年，在抛弃一切可以抛弃的包袱之后，我抱着“干完这票就退役”的觉悟第三次来到了复赛考场。在决斗中胜利后，我赶到附近的一处高速，耐心地完成了超速检测装置的调试。随后，一向无法理解艺术高深的我无法在短时间内想出完美的染色方案，但与去年不同，我有耐心。就算无法在规定时间内完成所有的染色，我也总能完成一部分。尽管最后我仍在擂台游戏中败下阵来，我也不会后悔了，因为我的表现配得上我的努力。

得到分数后，我发现我终于获得了 NOIP 的体验资格。同样的，我也已经做好了结束这一切的准备，但这次的旅程，相对而言，出乎意料地顺利——在前 \(25\) 分钟，我靠着从梦熊周赛中学来的管他对不对先打一发试试的原则，在第一次实现中选择正确性并不显然的贪心算法，并在不调试的情况下完美地符合了编辑字符串的所有要求。在接下来的 \(25\) 分钟内，吸取上次 CSP 的经验教训，我拿出草稿纸进行演算，并成功地在 \(3\) 分钟内推出了正确的算式，随后再次成功地在不调试的情况下为遗失的赋值找回了它们的归宿。此刻，我明白我已经没有任何后退的余地了，接下来，每多拿一分，都是对过去自我的突破。在尝试重新理解“树的遍历”方法无果后，我快速地将目光转移到我相对更为擅长的领域：查询。在完成对树上查询业务逻辑的理解后，我明确了我无法设计出效率最高的查询方法这一事实，转而使用之前某次洛谷月赛学到的结论，使用 \(3\) 个 ST 表完成了 \(O(n\log n+\sum (r-l+1-k+1))\) 的算法，拿到了本题最无脑的暴力分 \(32\) 分。接下来，在剩余的 \(2\) 个小时内，我坐在电脑前与那棵“边树”进行最后的谈判。然而谈判破裂，我只得从它所拥有的众多美丽形态中提取最为微不足道的一条铁链和一朵菊花。

我向来是一个悲观的人。比赛结束后，我自认为，就算我一份不挂，我的旅程也到此为止了。而最终的分数也确实与我的期望保持一致。

但，在看到了云斗学院的成绩单后，我发现了一个惊人的事实——我好像卡进前 \(20\%\) 了。

而后，我们的教练向所有取得一等的选手发出了去北京集训的邀请。在订好了机票后，我知道，一场崭新的旅途开始了。

Day -1 - 2024/12/13

来到了北京。晚自习。

晚餐不太好吃。

虽然没有教练在场，住的地方也不是宿舍而是更好一点的公寓，用的还是自己的电脑，但整个自习室弥漫着一股气息。

令人窒息的气息。

我不知道这是为什么，但这里与学校的环境完全不同。这次，我能感受到的不是合作，而是博弈。所有在场的人都在进行一场无声的博弈。

我本以为信息学比文化课轻松得多，但这里，显然不是这样的。给我一种来到了高三自习室的感受。

况且，我也要完成自己的“任务”。

Day 2 / Slavery - 2024/12/14

这里的生活非常奇怪。

尽管住宿条件好了一些，但缺少了一些很重要的东西。

而且，监视无处不在。

我说不了很多。

Day 3 / Failure - 2024/12/15

THUPC, 4/13。

懒得说了。

没有任何价值。

Day 5 / Rekindle - 2024/12/17

似乎恢复了一些，然后今天打了暴力。

\(30+40+40+20=130\)，尽管仍然没有任何 AC，但至少坐回了中位数的位置。

熟悉的感觉又回来了。

Day 6 / Sparkle by lxl - 2024/12/18

lxl 你讲课讲得好啊（赞赏

没时间写了，就这样吧。

Day 7 / From Static to Balancing - 2024/12/19

今天，我第一次独立完成无旋 Treap 的实现。

特此纪念。

#include <cstdio>
#include <random>
using namespace std;
const int N = 1.1e6 + 10, V = 1 << 30;
using uint = unsigned int;
struct st
{
    int sn[2], va, siz, rep;
    uint pri;
};
st tr[N];
int n, m, idx, rt, res;
random_device rd;
mt19937 mt(rd());
template <typename _Tp> inline void read(_Tp &x)
{
    static char ch;
    while (ch = getchar(), !isdigit(ch))
        ;
    x = (ch ^ 48);
    while (ch = getchar(), isdigit(ch))
        x = (x << 3) + (x << 1) + (ch ^ 48);
}
template <typename _Tp, typename... _Args> inline void read(_Tp &x, _Args &...args)
{
    read(x);
    read(args...);
}
int create(int v)
{
    idx++;
    tr[idx].va = v;
    tr[idx].siz = tr[idx].rep = 1;
    tr[idx].pri = mt();
    return idx;
}
void split(int x, int v, int &l, int &r)
{
    if (!x)
    {
        l = r = 0;
        return;
    }
    if (tr[x].va <= v)
    {
        l = x;
        split(tr[x].sn[1], v, tr[x].sn[1], r);
        tr[x].siz = tr[tr[x].sn[0]].siz + tr[tr[x].sn[1]].siz + tr[x].rep;
        return;
    }
    r = x;
    split(tr[x].sn[0], v, l, tr[x].sn[0]);
    tr[x].siz = tr[tr[x].sn[0]].siz + tr[tr[x].sn[1]].siz + tr[x].rep;
}
int merge(int x, int y)
{
    if (!x or !y)
        return x | y;
    if (tr[x].pri > tr[y].pri)
    {
        tr[y].siz += tr[x].siz;
        tr[y].sn[0] = merge(x, tr[y].sn[0]);
        return y;
    }
    tr[x].siz += tr[y].siz;
    tr[x].sn[1] = merge(tr[x].sn[1], y);
    return x;
}
void insert(int v)
{
    int l = 0, mid = 0, r = 0;
    split(rt, v - 1, l, r);
    split(r, v, mid, r);
    if (!mid)
        mid = create(v);
    else
        tr[mid].rep++, tr[mid].siz++;
    rt = merge(merge(l, mid), r);
}
void del(int v)
{
    int l = 0, mid = 0, r = 0;
    split(rt, v - 1, l, r);
    split(r, v, mid, r);
    tr[mid].rep--, tr[mid].siz--;
    if (!tr[mid].rep)
        mid = 0;
    rt = merge(merge(l, mid), r);
}
int query_va(int x, int v)
{
    if (!x)
        return 0;
    if (tr[x].va == v)
        return tr[tr[x].sn[0]].siz;
    if (tr[x].va > v)
        return query_va(tr[x].sn[0], v);
    return tr[tr[x].sn[0]].siz + tr[x].rep + query_va(tr[x].sn[1], v);
}
int query_rnk(int x, int rk)
{
    if (rk >= tr[tr[x].sn[0]].siz and rk < tr[tr[x].sn[0]].siz + tr[x].rep)
        return tr[x].va;
    if (rk < tr[tr[x].sn[0]].siz)
        return query_rnk(tr[x].sn[0], rk);
    return query_rnk(tr[x].sn[1], rk - tr[tr[x].sn[0]].siz - tr[x].rep);
}
int query_pr(int x, int v)
{
    if (!x)
        return 0;
    if (tr[x].va >= v)
        return query_pr(tr[x].sn[0], v);
    return max(tr[x].va, query_pr(tr[x].sn[1], v));
}
int query_ps(int x, int v)
{
    if (!x)
        return V;
    if (tr[x].va <= v)
        return query_ps(tr[x].sn[1], v);
    return min(tr[x].va, query_ps(tr[x].sn[0], v));
}
void print(int x, int dep = 0)
{
    if (!x)
        return;
    print(tr[x].sn[0], dep + 1);
    printf("r %d %d %d %d\n", tr[x].va, tr[x].rep, tr[x].siz, dep);
    print(tr[x].sn[1], dep + 1);
}
int main()
{
    read(n, m);
    for (int i = 1, x; i <= n; i++)
    {
        read(x);
        insert(x);
    }
    for (int i = 1, op, x, la = 0; i <= m; i++)
    {
        read(op, x);
        x ^= la;
        if (op == 1)
        {
            insert(x);
            continue;
        }
        if (op == 2)
        {
            del(x);
            continue;
        }
        if (op == 3)
            la = query_va(rt, x) + 1;
        if (op == 4)
            x--, la = query_rnk(rt, x);
        if (op == 5)
            la = query_pr(rt, x);
        if (op == 6)
            la = query_ps(rt, x);
        res ^= la;
    }
    printf("%d\n", res);
}

Day 8 / Lost and Found - 2024/12/20

庄严肃穆。

屏息瞻仰。

眼前一亮。

失而复得。

我对您表达由衷的感谢，因为您给了我一个教训，亦给了我一次机会。

感谢您，国家博物馆。

Day 10 / Rebirth Given by WSL - 2024/12/22

之前，在录制梦熊模拟赛的实况时，我的电脑出现了一些问题，导致运行速度大幅下降，连运行 A+B 都需要长达 0.8s 的时间。但经过大量实验，我发现大量的时间被消耗在了创建进程上。于是，我产生了下载 WSL 的想法。

完成一些必要的配置后，我随机拿出一个程序运行其附带的样例。用时，0ms。

这才是我的电脑的真正性能。

Day 11 / The First Balance - 2024/12/23

得分 \(25+100+30=155\)。

平衡树在比赛中的第一次成功运用。

后面忘了。

总之这是我继学会使用线段树后在数据结构方面的又一重大里程碑。

Day 13 / End

就快结束了。

明天就要离开北京了。

也算是有些收获吧。

下一站就是西安了。

第一次出省集训就这么迅速地落下帷幕，让我猝不及防。

前面又是一大批的文化课考试。

好累啊。

但是还有一件更近的事情。

看着电脑屏幕上显示的 EC-Final 2024 邀请函，我这样想。

Compete Against the East, Coming Soon.