nszkay

2026icpc河南省赛

Sun, 24 May 2026 00:00:00 GMT

刚刚在许昌学院结束了2026河南省赛，那按照惯例我来对这两天时间做个总结。本次比赛由zueb公费旅游参赛，在此感谢学校政策支持。本次比赛前瞻没关注，赛事群没进。本场比赛230支河南本科参赛队伍。按照前10%，30%，60%取出金，银，铜。zueb由xcpc算竞队出2支去年原班人马金牌队，与隔壁acm集训队2支正常参赛，一支女队。我的目标是不当男生队倒数第1，这样总显得占用比赛名额了。周六中午到许昌学院，第一天物资照片热身赛老规矩。但是好像没有照片。然后一起去“胖东来”玩，我不理解的是一个超市有什么玩的，去生鲜区看看螃蟹贝壳鱼后去楼上apple店玩macbookneo这个质感还是不错的。随后去本地司机推荐的烧烤，排了1个多小时的队伍，也没感觉多惊艳。然后就回酒店了。先跟gjz研究研究http请求，然后开始对之前学过的技能树。发现自己之前写的代码现在都很难以理解，诸如线段数，组合数学，图论好多内容的代码都不太能写了。然后跟gjz讨论了回spfa找最短路是否可以有负边权。

正式赛开始跟zhl洗脑了一会想念张雪峰老师，这次我有做题，那可以简单讲讲比赛过程。开始xwc，zhl去写了b题的签到在7min过后，随后我去写f签到，然后我去写e题，大致就是去 i的阶乘和，从1到n。对答案mod10000，根据2 * 5 = 10,4 * 10=40 6 * 15 =90,8 * 20 =160.可以知道当i>=20的时候i的阶乘mod10000等于0.也就是最多跑常数20次，由于我很怂不敢交跟zhl交流后还是交了49min过后，xwc去看c题大模拟，我跟zhl做先后手博弈。枚举数组求出能整除多少次2，放到数组，排序，去重拿到最大的两个值，都是偶数后手必胜，反正先手必胜。但是我已经唐到数组去重都不会了。在wa后，调一下在221min,2发提交通过。随后xwc跟zhl去c题开始模拟。我去了次厕所想到了i题树上启发式合并的做法。随后抢电脑去写i题。我看L题过的多，让zhl，xwc去看L题，先放下c题。我用两层动态数组去做启发式合并，处理过程带一个nlogn的快速排序，这个时间复杂度必然超时，我想先吃一发，发现wa了。随后梦游一会开始用map优化vector的nlogn排序，然后在longlong这里吃一发罚时后221min3A此题后去帮他们看L题，看到xwc在处理构建生成树过程进行无关边权插入计算权值尽然舍精度对xwc行为狂喷。喷醒xwc后我上机重构此题随后wa一发后，我开始双端队列改vector,long long->int ,double->long double吃罚时，然后我写了先把图生成好最小生成树，得到升序边权集合，开始枚举无关边权插入，为什么这样写，guess一下。随后285min4a。随后烟雾弹到结束。随后给zueb做一波烟雾弹。最后完成了男生队不是倒1的任务。

感觉现在水平这方面真是菜的不行了，看之前写的那些算法，都显得陌生，只能做一下guess，贪心题了。

对于许昌学院办赛我纯玩就不过多评价了。滚榜后就回去跟队友烧烤啤酒了。我们23年xcpc见。

2026ccpc河南省赛

Sun, 10 May 2026 00:00:00 GMT

距沈阳站后的半年内，仨人加一起写的题数两只手应该就能算出来。但现在我们这场比赛完全以玩为目的。所以我们打的非常放松。

赛前，前瞻分析

本场比赛河南省内参赛队伍331支，34张金牌，102-34张银牌，204-102张铜牌。66支打星队伍。这应该是我参与竞争力最小的一场ccpc了。按上赛季区域赛rating分数,我们队在18名，按照区域赛奖牌排名我们在13名。但是我们队现状就是，两位23级的，已经半年没有训练。一个22级的已经一年半没训练了。实际上水平都已经退化成婴儿了。

之前看到mjl拍的武汉volg，所以我也尝试了一下，等以后有时间发出来吧。 --写于2026.5.8晚

好了现在ccpc省赛比完了，打了个铜牌。回学校到图书馆直接就给小作文生成一下，那我简单说一下感受吧。 5月7日晚上，给压在桌子角的模版拿出来。然后简单聊聊天。今早8点跟阔别已久的队友碰个面。一个说昨天他玩到凌晨4点。一个说他打三角洲打到凌晨三点半。然后打个车就转移到郑轻了。之后先吃个早餐。然后到赛场前跟zyf聊聊天，就直接进去比赛了。整体上没有开幕式，没有签到。一天赛程主打一个迅速。本身今年的所有比赛是没打算参加的。但转念一想，娱乐参赛跟队友一起去玩玩也挺好，毕竟以后就没那个机会了。

赛时，我先看L题，感觉扩展欧几里得可做，求出一个同余方程，然后算边界。之后本场比赛我就消失了。另外三个题都是他们两个去做的。我题目都没看，全程都沉浸在数学跟吃全队的火腿肠。对的我们队的火腿肠我全吃了。他们过的题是怎么过的我也不知道就不展开说了，最后榜单100多名。

赛后跟zyf,lhx一起去聊了会天。随后xwc想回去睡觉，我感觉没意思。我们就回学校了。

回到学校我就对zhl说，体会到去年他这个时候的状态了。感叹算法竞赛离我现在是越来越远了。我觉得现在我还能在赛场上也就是怀念之前的一起打acm的日子了吧。

明天跟队友玩一玩叙叙旧。两周后我们最后一场icpc省赛见，这回真的是最后一场了～

My mac

Mon, 02 Mar 2026 00:00:00 GMT

My mac

📦 开发者基石：Homebrew

Homebrew 是 macOS 必备的包管理器。安装后，你可以通过命令行一键安装各种软件：

Bash

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

yt-dlp：终端下载视频工具，支持国内外主流视频网站，搬运必备。
- 安装：brew install yt-dlp
g++：GNU C++ 编译器。虽然系统自带 Clang，但装这个可以获得原生 GNU 支持。
- 安装：brew install gcc
npm / pnpm：Node.js 包管理器。推荐 pnpm，通过硬链接节省磁盘空间，安装速度极快。
- 安装：brew install pnpm

🛠️ 系统增强与效率工具

Alfred 5：Mac 的“终极控制中心”。 它是 Spotlight 的进阶版，通过 Workflows（工作流） 可以实现搜翻译、查物流、查代码片段等骚操作。
AltTab：把 Windows 的切换体验带回 Mac。 弥补原生 Cmd+Tab 只能换应用不能换窗口的槽点，带实时预览图。
Maccy：最轻量的开源剪贴板管理器。 记录复制过的文字、图片和文件，Shift+Cmd+C 快速搜索并粘贴历史记录，UI 与系统原生统一。
iBar：菜单栏图标隐藏工具。 专门解决刘海屏遮挡图标的问题，将不常用的图标折叠，保持顶部整洁。
Loop：分屏软件，通过快捷键或炫酷的 radial 菜单快速排列窗口，体验极佳。
Mos：鼠标滚动平滑工具。 让外接鼠标滚动起来像触控板一样丝滑。
Stats：开源系统监视器。在菜单栏实时显示 CPU、内存、风扇、网速等数据。
超级右键：补齐 Mac 右键菜单，支持“新建文件”、“复制路径”等常用功能。
MessAuto：自动提取短信验证码并填写，彻底解放双手。
EasyFind：强力文件搜索工具。 不依赖索引，可以搜索软件包内部内容，找隐藏文件神器。

🎬 影音、办公与生产力

IINA：macOS 下最好的视频播放器，UI 完美契合系统，格式通杀。
Arc：颠覆传统的浏览器。Chromium 内核，极简 UI 配合垂直标签页和多工作空间切换，用了就回不去。
Obsidian：第二大脑。 强大的 Markdown 笔记软件，双链架构，插件生态极其丰富。
Anki：开源记忆卡片工具。基于间隔重复算法，支持 Win, macOS, Android 多端同步，英语学习神器。
Cherry Studio：高颜值 AI 聚合客户端。 一个界面集成 GPT-4, Claude 3, Gemini, DeepSeek 等主流大模型，支持长文本。
Office 学习版：懂的都懂，给生活拮据的学术青年的一点温存。
EVCapture：国产良心录屏。 简单好上手，支持分屏录制和桌面画板，资源占用极低。
剪映专业版：上手最快、素材最全的视频剪辑软件，智能识别字幕功能极其好用。
Local Send：开源跨平台局域网文件传输，AirDrop 的全平台平替。

💻 开发者专区

PyCharm：顶级 Python IDE。 提供智能补全、实时检查和强大调试器， Python 开发者工业级首选。
Docker：容器化平台。 搭建开发环境（数据库、Redis 等）最快最干净的方式，确保环境一致性。
ProxyPin：全平台开源抓包工具，支持手机扫码连接，拦截和重写流量非常方便。
BBDown：命令行 B 站下载神器，支持多分段、弹幕及 8K/HDR 下载（搬运可耻，仅供学习）。

🌐 社交、互联与网络

Discord：全球领先的社群平台。AI 绘画 (Midjourney)、编程社区、学术讨论的集散地，资源极香。
纸飞机 (Telegram)：好用的端对端加密聊天软件。微信是无奈，QQ 是生态，纸飞机是自由。
OPPO 互联：打破手机与电脑边界。 支持屏幕镜像、跨设备拖拽文件和共享剪贴板（适配 OPPO/一加/Realme）。
Clash：多协议代理客户端。 支持自定义规则分流，确保网络环境高速稳定。
AirBattery：全家桶电量管理。 菜单栏直接看 iPhone, iPad, AirPods 的实时电量。

My CLI

终端

终端优化待补充……

zsh

# =============================================================================
# 系统基础设置
# =============================================================================

# 自动对 path 变量进行去重，确保 PATH 中不会出现重复路径，提高 shell 效率
typeset -U path

# =============================================================================
# 代理管理工具 (nszkay 函数)
# =============================================================================
# 用法: 
#   nszkay on     - 开启代理
#   nszkay off    - 关闭代理
#   nszkay status - 查看状态
#   nszkay update [端口] - 修改默认代理端口
function nszkay() {
    local DEFAULT_PORT="7897"
    local PROXY_FILE="$HOME/.nszkay_proxy_port"

    # 从文件读取保存的端口，否则使用默认值
    if [ -f "$PROXY_FILE" ]; then
        local CURRENT_PORT=$(cat "$PROXY_FILE")
    else
        local CURRENT_PORT=$DEFAULT_PORT
    fi

    case "$1" in
        on)
            export http_proxy="http://127.0.0.1:$CURRENT_PORT"
            export https_proxy="http://127.0.0.1:$CURRENT_PORT"
            export all_proxy="socks5://127.0.0.1:$CURRENT_PORT"
            echo "✅ 终端代理已开启: $CURRENT_PORT"
            ;;
        off)
            unset http_proxy https_proxy all_proxy
            echo "❌ 终端代理已关闭"
            ;;
        update)
            if [ -n "$2" ]; then
                echo "$2" > "$PROXY_FILE"
                echo "⚙️ 端口已更新为: $2 (请执行 nszkay on 生效)"
            else
                echo "⚠️ 请输入端口号: nszkay update [端口号]"
            fi
            ;;
        status)
            if [ -n "$http_proxy" ]; then
                echo "🌐 当前代理状态: ON ($http_proxy)"
            else
                echo "⚪ 当前代理状态: OFF"
            fi
            ;;
        *)
            echo "用法: nszkay [on|off|update|status]"
            ;;
    esac
}

# =============================================================================
# 开发语言与环境工具管理 (NVM, SDKMAN, jEnv)
# =============================================================================

# --- SDKMAN (Java/Kotlin 等管理器) ---
export SDKMAN_DIR="$HOME/.sdkman"
[[ -s "$HOME/.sdkman/bin/sdkman-init.sh" ]] && source "$HOME/.sdkman/bin/sdkman-init.sh"

# --- NVM (Node.js 版本管理器) ---
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" 
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

# --- jEnv (Java 版本切换工具) ---
export PATH="$HOME/.jenv/bin:$PATH"
eval "$(jenv init -)"

# =============================================================================
# Android 开发环境变量
# =============================================================================
export ANDROID_HOME=~/Library/Android/sdk
# 优先加载 Android 工具命令
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:/opt/platform-tools:$PATH

# =============================================================================
# 别名设置 (Aliases) 与 Python 工具
# =============================================================================

# 指定特定 Python 路径
alias python3="/opt/homebrew/bin/python3.13"

# 视频下载工具别名
alias yt-dlp="/opt/homebrew/bin/python3.13 /usr/local/bin/yt-dlp"
alias ytdl="yt-dlp"

# =============================================================================
# 网络与 SSL 证书设置
# =============================================================================

# 解决一些 Python 程序在 HTTPS 连接时报错的问题
# 方案 A: 使用 Python certifi 包提供的证书
export SSL_CERT_FILE=$(/opt/homebrew/bin/python3.13 -m certifi)

# 方案 B: 使用 Homebrew 安装的系统证书 (最后一行生效)
export REQUESTS_CA_BUNDLE=$(brew --prefix)/etc/ca-certificates/cert.pem

2-1数论

Wed, 07 Jan 2026 00:00:00 GMT

格雷码 (相邻两个数字的二进制异或为二的次幂)

两个数的二进制只有一个位数相差1

i^(i>>1) 这个能求出i的格雷码

1 000011 2 000001 3 000111 4 000001 5 000011 6 000001 7 001111 8 000001 9 000011 10 000001 11 000111 12 000001 13 000011 14 000001 15 011111 16 000001

16以内的格雷码数，相邻的格雷码数^=1;

矩阵快速幂构造方法总结

在使用矩阵快速幂解决递推问题时，关键在于 构造初始矩阵和转移矩阵。下面以例题 a_i = a_{i-3} + a_{i-1} 为例总结方法。

1️⃣ 构造初始矩阵（Basic Matrix）

根据题意，已知前几个项：a_1 = a_2 = a_3 = 1。
初始矩阵存储这些已知值：

a₁	a₂	a₃
1	1	1

矩阵大小：
- 行：1（因为这是一个“行向量”）
- 列：保存多少个历史状态，就有多少列
  - 本例需要保存 a_i, a_{i-1}, a_{i-2} → 3 列
作用：基础矩阵保存初始状态，用于与转移矩阵相乘计算后续项。

2️⃣ 构造转移矩阵（Transfer Matrix）

原递推式：a_i = a_{i-3} + a_{i-1}
为了计算 a_{i+1}，需要把矩阵状态向右移动，并引入新关系。
转移矩阵规则：
1. 第一列对应递推公式中参与计算的元素：
  - 本例：a_i 和 a_{i-2} 参与 → 第一列是 [1, 0, 1]
2. 其余列用于原封不动地转移历史状态：
  - 第二列对应 a_i → a_i
  - 第三列对应 a_{i-1} → a_{i-1}
最终转移矩阵示意：

	i	i-1	i-2
i+1	1	1	0
i	0	0	1
i-1	1	0	0

作用：
对基础矩阵乘以转移矩阵，可以将状态从 [a_i, a_{i-1}, a_{i-2}] 转移到 [a_{i+1}, a_i, a_{i-1}]。

3️⃣ 计算第 n 项

我们要求 a_n，则只需：
1. 用初始矩阵（存储 a_1, a_2, a_3）乘上 转移矩阵的 n-1 次方
  [ \text{ans} = \text{basic matrix} \times (\text{transfer matrix})^{n-1} ]
2. 基础矩阵乘完后，第一格就是 a_n
优化：
- 转移矩阵幂用快速幂算法计算 → 时间复杂度 O(log n)
- 整个计算从暴力 O(n) 降为 O(log n)

4️⃣ 总结矩阵构造步骤

确定基础矩阵：
- 行：1（或列向量）
- 列：保存递推所需历史状态数量
- 填入已知初始值
确定转移矩阵：
- 第一列：对应递推公式参与的元素
- 其余列：原封不动地保存历史状态
- 行列数与基础矩阵列数一致（方阵方便快速幂）
计算递推：
- 将基础矩阵乘以转移矩阵的 n-1 次幂
- 输出基础矩阵的第一格，即为答案

4-2数据结构2

Wed, 07 Jan 2026 00:00:00 GMT

数据结构(三)

~目录 Part 7.13 树链剖分 Part 7.14 树套树 Part 7.15 动态树 Part 7.16 可持久化数据结构
Part 7.17 K-D Tree Part 7.18 珂朵莉树

Part 7.13 树链剖分

Part 7.14 树套树

Part 7.15 动态树

Part 7.16 可持久化数据结构

可持久化线段树(普通版本)

此版本，二分主席树，O(log^(2)n) 时间二分区间第一个大于等于x的位置

struct TRE 
{
    int ls, rs, sum;
} tre[N*40];
int root[N*40], cnt;

int build(int l, int r) 
{
    int k = ++cnt;
    tre[k] = {0};
    if (l < r) 
    {
        int mid = (l + r) >> 1;
        tre[k].l = build(l, mid);
        tre[k].r = build(mid + 1, r);
    }
    return k;
}

int change(int lst, int l, int r, int op) 
{
    int k = ++cnt;
    tre[k] = tre[lst];
    tre[k].sum++;
    if (l < r) 
    {
        int mid = (l + r) >> 1;
        if (mid >= op) tre[k].ls = change(tre[lst].ls, l, mid, op);
        else tre[k].rs = change(tre[lst].rs, mid + 1, r, op);
    }
    return k;
}

int query(int a1, int a2, int l, int r, int k) 
{
    if (l == r) return l;
    int xx = tre[tre[a2].ls].sum - tre[tre[a1].ls].sum;

    int mid = (l + r) >> 1;
    if (xx >= k) return query(tre[a1].ls, tre[a2].ls, l, mid, k);
    else return query(tre[a1].rs, tre[a2].rs, mid + 1, r, k - xx);
}



//打印      版本   范围
void nszka(int k,int l,int r)
{
    auto []=tre[k];
//输出
    if(l==r)
    {
        //操作
        return ;
    }
    int mid=(l+r)>>1;
    nszka(tre[k].ls,l,mid);
    nszka(tre[k].rs,mid+1,r);
}

可持久化并查集

可持久化字典树

Part 7.17 K-D Tree

Part 7.18 珂朵莉树

4-1数据结构

Wed, 07 Jan 2026 00:00:00 GMT

数据结构

~目录

Part 7.1 链表 Part 7.2 栈 Part 7.3 队列 Part 7.4 并查集 Part 7.5 二叉堆 Part 7.6 ST表 Part 7.7 树状数组

Part 7.1 链表

Part 7.2 栈

单调栈

Part 7.3 队列

单调队列

Part 7.4 并查集

普通板子封装(联通大小(点，边)，判断环)

struct DSU 
{
    ve<int>fa,p,e,f;
    DSU(int n) 
    {
        fa.resize(n + 1);
        iota(fa.begin(), fa.end(), 0);
        p.resize(n + 1, 1);
        e.resize(n + 1);
        f.resize(n + 1);
    }
    int find(int x)
    {
        if(f[x]!=x) f[x]=find(f[x]);
        return f[x];
    }
    bool merge(int x, int y) 
    {//y-->x
        if (x == y) f[find(x)] = 1; //之前已经在一个地方了
        x=find(x);y=find(y);
        e[x]++;//y-->x  边
        if (x == y) return false;
        if (x < y) swap(x, y); // 将编号小的合并到大的上 
        fa[y] = x;
        f[x] |= f[y];//判断自环
        p[x] += p[y];//点
        e[x] += e[y];//边
        return true;
    }
  
  
    bool same(int x, int y) //判断是否在一个联通中
    {
        return find(x)==find(y);
    }
    bool F(int x) //判断x所在联通是否存在自环
    {
        return f[find(x)];
    }
    int size(int x) //获取点x所在联通的大小
    {
        return p[find(x)];
    }
    int E(int x) //联通中边的数量
    {
        return e[find(x)];
    }
};

Part 7.5 二叉堆

Part 7.6 ST表

nlog预处理 O(1) 查询

template <class Ty, const int logn>
struct RMQ 
{
	vector<array<Ty, logn>> info1;
	vector<array<Ty, logn>> info2;
	RMQ(const vector<Ty>& A) { init(A); }
	void init(const vector<Ty>& A) 
	{
		int n = A.size() - 1;
		info1.assign(A.size(), array<Ty, logn>{});
		info2.assign(A.size(), array<Ty, logn>{});
		for (int i = 1; i <= n; ++i) 
		{
			info1[i][0] = A[i];
			info2[i][0] = A[i];
		}
		for (int j = 1; j <= logn; ++j)
		{
			for (int i = 1; i + (1 << j) - 1 <= n; ++i)
			{
				info1[i][j] = max(info1[i][j - 1], info1[i + (1 << (j - 1))][j - 1]);
				info2[i][j] = min(info2[i][j - 1], info2[i + (1 << (j - 1))][j - 1]);
			}
		}
	}
  
	Ty Query_Max(int l, int r)
	{
		int j = log2(r - l + 1);
		return max(info1[l][j], info1[r - (1 << j) + 1][j]);
	}
	Ty Query_Min(int l, int r)
	{
		int j = log2(r - l + 1);
		return min(info2[l][j], info2[r - (1 << j) + 1][j]);
	}
};

Part 7.7 树状数组

5-1串

Wed, 07 Jan 2026 00:00:00 GMT

字典树

字典树(普通版本)

以26个小写的英文字母为例子

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;
template<class T>
using ve=vector<T>;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

struct TIE
{
    ve<ve<int>>ti;
    ve<int>sum;
    int cnt;
    TIE(int n)
    {
        cnt=1;//
        ti=ve<vector<int>>(n+1,ve<int>(30,-1));
        sum=ve<int>(n+1,0);
    }

    int get_sum(char x)
    {
        if(x>='a'&&x<='z') return x-'a';//0-26
        if(x>='A'&&x<='Z') return x-'A'+26;
        return x-'0'+52;
    }

    void insert(const string& s)
    {//
        int ls=0;
        for(auto x:s)
        {
            if(ti[ls][get_sum(x)]==-1) ti[ls][get_sum(x)]=cnt++;
            ls=ti[ls][get_sum(x)];
            sum[ls]++;
        }
    }

    int query_sum(const string& s)
    {
        int ls=0;
        for(auto x:s)
        {
            if(ti[ls][get_sum(x)]==-1) return 0;
            ls=ti[ls][get_sum(x)];
        }
        return sum[ls];
    }
};

void solve()
{
    int n,q;cin>>n>>q;
    TIE tr(3e6);
    for(int i=1;i<=n;i++)
    {
        string s;cin>>s;
        tr.insert(s);
    }
    while(q--)
    {
        string s;cin>>s;
        cout<<tr.query_sum(s)<<'\n';
    }
}
signed main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1; cin>>_;
    while(_--) solve();
    return 0;
}

可持久化字典树

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;
template<class T>
using ve=vector<T>;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

int n,m;
int ti[N*25][2];
int sz[N*25],rt[N*25],siz[N*25];
int cnt=0,idx=0;

void insert(int x)
{//0--24
    rt[++idx]=++cnt;//开新的版本
    int ls=rt[idx-1];//上一个版本
    int rs=rt[idx];//当前版本
    for(int i=23;i>=0;i--)
    {
        int j=(x>>i)&1;         //
        ti[rs][j^1]=ti[ls][j^1];//继承

        ti[rs][j]=++cnt;        //开新的节点
        ls=ti[ls][j];
        rs=ti[rs][j];
        siz[rs]=siz[ls]+1;
    }
}

int query(int l,int r,int p)
{
    int ls=rt[l-1];
    int rs=rt[r];
    
    int sum=0;
    for(int i=23;i>=0;i--)
    {
        int j=p>>i&1;
        if(siz[ti[rs][j^1]]>siz[ti[ls][j^1]])
        {//可以
            ls=ti[ls][j^1];
            rs=ti[rs][j^1];
            sum+=(1<<i);
        }
        else 
        {
            ls=ti[ls][j];
            rs=ti[rs][j];
        }
    }
    return sum;
}

void solve()
{
    cin>>n>>m;
    int ans=0;
    insert(ans);
    for(int i=1;i<=n;i++)
    {
        int x;cin>>x;
        ans^=x;
        insert(ans);
    }
    while(m--)
    {
        char p;cin>>p;
        if(p=='A')
        {
            int x;cin>>x;
            ans^=x;
            insert(ans);
        }
        else
        {
            int l,r,x;cin>>l>>r>>x;
            cout<<query(l,r,ans^x)<<'\n';
        }
    }
}

signed main()
{
    IOS;
    int _ = 1; //cin >> _;
    while (_--) solve();
    return 0;
}

4-2数据结构

Wed, 07 Jan 2026 00:00:00 GMT

数据结构（二）

Part 7.8 线段树 Part 7.9 分块 Part 7.10 可并堆 Part 7.11 主席树 Part 7.12 平衡树

Part 7.8 线段树

线段树（区间修改，区间覆盖）

ps:

区间修改，区间查询。 dug功能输出树

  
struct my_tree
{
	#define kl (k<<1)
	#define kr (k<<1|1)
  
	struct node
	{
		int l, r, sum;
		int lz;
	};
	vector<node> tree;
  
  
	my_tree(int x,ve<int>&a)
	{
		tree = vector<node>(x*4+10);
		build(1,1,x,a);
	}
  
	void pushup(node& kk, const node& kkl, const node& kkr)
	{
		kk.sum = max(kkl.sum, kkr.sum);
	}
	void pushup(int k)
	{
		pushup(tree[k], tree[kl], tree[kr]);
	}
  
  
	void pushdown(int k)
	{
		if(tree[k].lz==0) return ;
		tree[kl].sum=tree[kr].sum=tree[k].lz;
		tree[kl].lz=tree[kr].lz=tree[k].lz;
		tree[k].lz=0;
	}
  
	void build(int k, int l, int r, ve<int>& a)
	{
		tree[k].l = l;
		tree[k].r = r;
		if (l == r)
		{
			tree[k].sum = a[l];
			return;
		}
		int mid = (l + r) >> 1;
		build(kl, l, mid, a);
		build(kr, mid + 1, r, a);
		pushup(k);
	}
  
	// 区间修改   区间修改 [l,r] 全复制成val
	void update(int k, int l, int r, int val)
	{
		if (tree[k].l >= l && tree[k].r <= r)
		{
			tree[k].sum = val;
			tree[k].lz=val;
			return;
		}
		pushdown(k);
		int mid = (tree[k].l + tree[k].r) >> 1;
		if (l <= mid) update(kl, l, r, val);
		if (r > mid) update(kr, l, r, val);
		pushup(k);
	}
  
	node query(int k, int l, int r)
	{
		if (l <= tree[k].l && tree[k].r <= r) return tree[k];
		pusgdown(k);
  
		int mid = (tree[k].l + tree[k].r) >> 1;
  
		node kkl = {tree[k].l, mid};
		node kkr = {mid + 1, tree[k].r};
		node kk = {tree[k].l, tree[k].r};
  
		int opl=0,opr=0;
		if (l <= mid) kkl = query(kl, l, r),opl=1;
		if (r > mid) kkr = query(kr, l, r),opr=1;
		if(opl&&opr) 
		{
			pushup(kk, kkl, kkr);
			return kk;
		}
		if(opl) return kkl;
		return kkr;
	}
  
  
	void dug(int k=1)
	{
		auto [l,r,sum,lz]=tree[k];
		cout<<"k: "<<k<<"\n";
		cout<<"[ "<<l<<" "<<r<<" "<<sum<<" "<<lz<<" ]"<<'\n';
		if(l<r)
		{
			dug(kl);
			dug(kr);
		}
	}
};

权值线段树

单点修改，区间查询个数权值线段树的每一个节点，存放的是[l,r]的值个数

#define kl (k<<1)
#define kr (k<<1|1)

struct node
{
    int l,r;
    int sum;
}tre[N*4+10];

void build(int k,int l,int r)
{
    tre[k]={l,r};
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(kl,l,mid);
    build(kr,mid+1,r);
}

void insert(int k,int val,int id)
{
    tre[k].sum+=id;
    if(tre[k].l==tre[k].r) return ;
    int mid=(tre[k].l+tre[k].r)>>1;
    if(val<=mid) insert(kl,val,id);
    else insert(kr,val,id);
}

int query(int k,int l,int r)
{
    if(l<=tre[k].l&&tre[k].r<=r) return tre[k].sum;
    int mid=(tre[k].l+tre[k].r)>>1;
    int ans=0;
    if(l<=mid) ans+=query(kl,l,r);
    if(r>mid) ans+=query(kr,l,r);
    return ans;
}

动态开点线段树

Part 7.9 分块

Part 7.10 可并堆

Part 7.11 主席树

Part 7.12 平衡树

7-1图论

Wed, 07 Jan 2026 00:00:00 GMT

7-1 图论

树的直径

我看网上的博客。一般树的直径可以跑一遍深度，然后从深度最大的开始跑一下最远的，这个方法还可以把树的直径上的点拿出来

ve<ve<int>>ed(n+1);
ve<int>dis(n+1);
int ls,rs,maxl,maxr;
void dfs1(int u,int la)
{
    dep[u]=dep[la]+1;
    if(maxl<dep[u])
    {
        maxl=dep[u];
        ls=u;
    }


    for(auto v:ed[u])
    {
        if(v==la) continue;
        dfs1(v,u);
    }
}

void dfs2(int u,int la)
{
    dis[u]=dis[la]+1;
    if(maxr<dis[u])
    {
        maxr=dis[u];
        rs=u;
    }

    for(auto v:ed[u])
    {
        if(v==la) continue;
        fa[v]=u;//处理前缀
        dfs2(v,u);
    }
}

//ls,rs 就是树的直径的两个端点
ls,rs


//拿出树的直径上的端点
ve<int>f;
while(rs!=ls)
{
    f.push_back(rs);
    rs=fa[rs];
}
f.push_back(ls);

树的中心

树的重心

单源最短路(djstka)

struct node
{
    int x,ds;
};
struct cmp
{
    bool operater()(node a,node b)
    {
        return a.ds>b.ds;//当a.ds>b.ds时交换，这个时小顶堆
    }
};

ve<ve<int>>ed[N];
ve<int>st[N];

void djs()
{
    priority_queue<node,ve<node>,cmp>pq;
    pq.push({});
    while(pq.size())
    {
        auto [u,ds]=pq.top();pq.pop();
        if(st[u]) continue;
        st[u]=1;
        for(auto [v,w]:ed[u])
        {
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                pq.push({v,dis[v]});
            }
        }
    }
}

分层最短路也是常用的，分层图最短路

多源最短路

floyd （O(n^3) 三层暴力跑最短路）

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;
using ll = long long;
template<class T>
using ve = vector<T>;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

int n,m,q;
int a[N][N];


void solve() 
{
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++) 
    {
        for(int j=1;j<=n;j++) 
        {
            if(i==j) a[i][j]=0;
            else a[i][j]=1e18;
        }
    }
    for(int i=1;i<=m;i++)
    {
        int u,v,w;cin>>u>>v>>w;
        a[u][v]=min(a[u][v],w);
    }

    for(int k=1;k<=n;k++)
    {//k是分割点
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                a[i][j]=min(a[i][j],a[i][k]+a[k][j]);
            }
        }
    }

    while(q--)
    {
        int x,y;cin>>x>>y;
        if(a[x][y]>=1e9/2 )cout<<"impossible"<<'\n';
        else cout<<a[x][y]<<'\n';
    }

}

signed main() 
{
    IOS;
    int _ = 1; //cin >> _;
    while (_--) solve();
    return 0;
}

最小生成树(并查集)

/*


克鲁斯卡尔算法  

是并查集维护的，把边存一下，然后每次拿最小的边权，
如果不会形成环加上，反之舍弃此边。


*/

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;
using ll = long long;
template<class T>
using ve = vector<T>;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

struct node
{
    int a,b,c;
};
bool cmp(node x,node y)
{
    return x.c<y.c;
}

int f[N];
int find(int x)
{
    if(f[x]!=x) f[x]=find(f[x]);
    return f[x];
}
void solve()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++) f[i]=i;
    ve<node>a;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;cin>>u>>v>>w;
        a.push_back({u,v,w});
    }
    sort(a.begin(),a.end(),cmp);
    int ans=0;
    int res=0;
    for(int i=0;i<a.size();i++)
    {
        auto [u,v,w]=a[i];
        u=find(u),v=find(v);
        if(u==v) continue;
        f[u]=v;
        ans+=w;
        res++;
    }
    if(res!=n-1) cout<<"orz\n";
    else cout<<ans<<'\n';
}

signed main()
{
    IOS;
    int _ = 1; //cin >> _;
    while (_--) solve();
    return 0;
}

基环树

基环树是n个节点，n条边的数据结构，基环树有一个环

有向边的基环树，指向环的是内向树，反之是外向树

dfs找环

set<int>se;
void dfs_c(int u,int la)
{
    //st标记是否遍历,ins表示是否在栈中//
    st[u]=ins[u]=true;
    for(auto v:ed[u])
    {
        if(st[v]) continue;


        fa[v]=u;
        dfs_c(v,u);
        if(ins[v]) //在栈中，这个感觉是找即环树的一种方式
        {//找到环


        //拿出环
            int id=u;
            se.insert(v);
            while(id!=v)
            {
                se.insert(id);
                id=fa[id];
            }
            break;
        //
        }
    }
    ins[u]=false;//
}

3-1数论

Wed, 07 Jan 2026 00:00:00 GMT

数论

欧拉筛(经典版本) 欧拉筛(最下质数筛) 质因子分解(O(n)筛法,O(logn)质因子分解 ) 矩阵的转置 (横向变纵向，纵向变横向)

欧拉筛(经典版本)

vector<int> pri;
void pri_init(int n)
{
    vector<bool> is_pri(n + 1, true);
    is_pri[0] = is_pri[1] = false;
    for (int i = 2; i <= n; i++) 
    {
        if (is_pri[i]) pri.push_back(i);
        for (int j = 0; j < pri.size() && pri[j] <= n / i; j++) 
        {
            is_pri[pri[j] * i] = false;
            if (i % pri[j] == 0) break;
        }
    }
}

欧拉筛(最小质数筛)

vector<int> pri;
int pmin[N];
void my_pmin(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (pmin[i]==0)
        {
            pmin[i] = i;
            pri.push_back(i);
        } 
        for (auto p : pri)
        {
            if (i * p > n) break;
            pmin[i * p] = p;
            if (i % p == 0) break;
        }
    }
}

质因子分解(O(n)筛法,O(logn)质因子分解 )

质因子分解解释

✅ 结论公式：

设一个正整数 ( n ) 的 质因子分解 为：

[ n = p_1^{a_1} \cdot p_2^{a_2} \cdot \cdots \cdot p_k^{a_k} ]

那么它的约数个数（包括 1 和 ( n ) 本身）为：

[ \text{约数个数} = (a_1 + 1)(a_2 + 1) \cdots (a_k + 1) ]

vector<int> pri;
int pmin[N];
void my_pmin(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (!pmin[i])
        {
            pmin[i] = i; // pmin[i]：i 的最小质因子
            pri.push_back(i);
        }    
        for (auto p : pri)
        {
            if (i * p > n) break; // 超范围了
            pmin[i * p] = p;
            if (i % p == 0) break;
        }
    }
}

ve<pii> nszka(int n)
{
    map<int, int> mp;
    while (n != 1)
    {
        int pm = pmin[n];
        mp[pm]++;
        n /= pm;
    }
    ve<pii> f;
    for (auto [x, y] : mp) f.push_back({x, y});
    return f;
}
// 示例：分解 60 -> [(2,2), (3,1), (5,1)]

矩阵的转置 (横向变纵向，纵向变横向)


ve<ve<int>>a(n+1,ve<int>(n+1));
ve<ve<int>>b(n+1,ve<int>(n+1));
for(int i=1;i<=n;i++)
{
    for(int j=1;j<=n;j++)
    {
        b[i][j]=a[j][n-i+1];
        // cout<<"("<<i<<", "<<j<<")  ("<<j<<", "<<n-i+1<<")  \n";
    }
}
a=b;

组合数( 快速幂+组合数+逆元预处理 O(n) )

✅ 问题形式：(能使用乘法逆元的前提)

要求的是：

[ \frac{a}{b} \mod m ]

若：

[ \gcd(b, m) = 1 ]

则 ( b ) 在模 ( m ) 意义下有乘法逆元 ( b^{-1} \mod m )，于是可以转化为：

[ \frac{a}{b} \mod m \equiv a \cdot b^{-1} \mod m ]


int ksm(int a, int n)
{
    int ans = 1;
    while (n)
    {
        if (n & 1) ans = ans * a % mod;
        a = a * a % mod; n >>= 1;
    }
    return ans;
}
struct ZHS
{
    int fac[N+2], ifac[N+2];
    ZHS() { init(); }
    void init()
    {
        fac[0] = ifac[0] = 1;
        for (int i = 1; i <= N; i++) fac[i] = fac[i - 1] * i % mod;
        ifac[N] = ksm(fac[N], mod - 2);
        for (int i = N - 1; i >= 1; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
    }
    int C(int n, int m)
    {
        if (n >= m && m >= 0 && N > n)
            return fac[n] * ifac[m] % mod * ifac[n - m] % mod;
        return 0;
    }
    int A(int n, int m)
    {
        if (n >= m && m >= 0 && N > n)
            return fac[n] * ifac[n - m] % mod;
        return 0;
    }
} zhs;

int inv(int a,int mod) { return ksm(a,mod-2,mod);}

扩展欧几里得exgcd

求解形如 ax+by==gcd(a,b) 的不定方程的任意一组解

int exgcd(int a,int b,int&x,int& y)
{
    if(b!=0)
    {
        x=1;y=0;
        return a;
    }
    int d=exgcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}

杨辉三角

杨辉三角模板题

杨辉三角具有如下的初始条件：

$$C_{i,0} = C_{i,i} = 1$$

杨辉三角有如下的递推公式：

$$C_{i,j} = C_{i-1,j} + C_{i-1,j-1}$$

杨辉三角本质是二项式系数，其第 $n$ 行各个数值即为 $(a+b)^n$ 展开后各项的系数。
展开后共有 $n+1$ 项，第 $i$ 项的系数记作 $C_{n,i}$，形如：

$$C_{n,0}a^n + C_{n,1}a^{n-1}b + C_{n,2}a^{n-2}b^2 + \dots + C_{n,n-1}ab^{n-1} + C_{n,n}b^n$$

由于 $a^n$ 只能由 $n$ 个 $(a+b)$ 中 $a$ 相乘得到，因此其系数为 $1$，$b^n$ 同理，由此得到了杨辉三角的边界条件式。

对于杨辉三角第 $n$ 行中第 $i$ 项 $C_{n,i}$，其为 $a^i b^{n-i}$ 的系数。
考虑第 $n$ 行的 $a^i b^{n-i}$ 可能来源：

$$(a+b)^n = (a+b)^{n-1}(a+b)$$

即：

$$(C_{n-1,0}a^{n-1} + C_{n-1,1}a^{n-2}b + \dots + C_{n-1,n-1}b^{n-1})(a+b)$$

于是 $a^i b^{n-i}$ 可以由上一行的 $a^{i-1}b^{n-i}$ 乘以 $a$，或者由 $a^i b^{n-i-1}$ 乘以 $b$ 得到。
由此可得：

$$C_{n,i} = C_{n-1,i-1} + C_{n-1,i}$$

即杨辉三角的递推式。

由于二项式系数的组合性质，杨辉三角的 $C_{i,j}$ 项即为组合数 $C(i,j)$，这使得杨辉三角成为时间复杂度允许情况下一种简洁好写的组合数求法。

#include <cstdio>
int N,C[30][30];
int main()
{
    scanf("%d",&N);
    int i,j;
    C[0][0]=1;printf("1\n");
    for(i=1;i<=N;i++)
    {
        for(j=1;j<=i;j++)
        {
            C[i][j]=C[i-1][j]+C[i-1][j-1];
            printf(j!=i?"%d ":"%d\n",C[i][j]);
        }
    }
}

0-0初始化

Wed, 07 Jan 2026 00:00:00 GMT

vscode 的设置操作

运行脚本文件

ubutun环境下

这个命令给run.js运行的权限

chmod +x run.sh

#!/bin/bash

# 检查是否传入了文件名参数
if [ -z "$1" ]; then
    echo "用法: run.sh 文件名.cpp"
    exit 1
fi

FILE=$1
# 去除 .cpp 后缀生成可执行文件名
EXE="${FILE%.cpp}"

echo "编译 $FILE..."

# 编译 C++ 文件
g++ "$FILE" -std=gnu++20 -O2 -o "$EXE"
if [ $? -ne 0 ]; then
    echo "编译失败！"
    exit 1
fi

echo "编译成功，正在运行..."

# 如果存在 in.txt 文件，则重定向输入
if [ -f "in.txt" ]; then
    ./"$EXE" < in.txt > out.txt
else
    ./"$EXE"
fi

# 比较输出文件 out.txt 和 com.txt
echo "正在比较输出文件..."
if cmp -s "out.txt" "com.txt"; then
    echo "Accept （输出一致）"
else
    echo "Wrong Answer （输出不一致）"
fi

文本缩放

ctrl+, 调出设置，搜索 zoom ,打对勾

ctrl+鼠标滚轮缩放代码

快捷键配置(待补充)

主函数板子


#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define endl '\n'
#define int long long
using namespace std;
using ll = long long;
template<class T>
using ve = vector<T>;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

void solve()
{



}


signed main()
{
    IOS;

    int _ = 1; //cin >> _;
    while (_--) solve();
    return 0;
}


//------------------------------------
// #define ONLINE_JUDGE
#ifndef ONLINE_JUDGE
    ifstream in("./in.txt");
    cin.rdbuf(in.rdbuf());
    ofstream out("./out.txt");
    cout.rdbuf(out.rdbuf());
#endif
//------------------------------------

在ubutun 系统

设置鼠标大小，灵敏度调整

对拍

windows系统下

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;
using ll = long long;
template<class T>
using ve = vector<T>;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

signed main() 
{

//编译
    system("g++ -O2 a1.cpp -o a1.exe");
    system("g++ -O2 a2.cpp -o a2.exe");
    system("g++ -O2 data.cpp -o data.exe");


    int n=500;
    for (int i = 1; i <= n; i++) 
    {
        system("data.exe > data.in");
        system("a1.exe < data.in > a1.out");
        system("a2.exe < data.in > a2.out");


        // 显示当前测试进度
        cout<<"test: "<<i<<'\n';
        if (system("fc a1.out a2.out > nul")) 
        {
            cout<<"Wrong Answer!\n";

            
            cout << "\n================== INPUT =================================\n";
            ifstream fin("data.in");
            cout << fin.rdbuf(); // 直接输出整个文件内容
            fin.close();

            cout << "\n================== YOUR OUTPUT (a1.out) ==================\n";
            ifstream fout1("a1.out");
            cout << fout1.rdbuf();
            fout1.close();

            cout << "\n================== CORRECT OUTPUT (a2.out) ===============\n";
            ifstream fout2("a2.out");
            cout << fout2.rdbuf();
            fout2.close();

            cout << "\n================= end  ===================================\n";
        }
        else cout<<"Accept!\n";
    }
    return 0;
}

linux系统下

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;

signed main() 
{
    // 编译，注意没有 .exe
    system("g++ -O2 a1.cpp -o a1");
    system("g++ -O2 a2.cpp -o a2");
    system("g++ -O2 data.cpp -o data");

    int n = 500;
    for (int i = 1; i <= n; i++) 
    {
        // 执行命令时前面要加 ./ 表示当前目录
        system("./data > data.in");
        system("./a1 < data.in > a1.out");
        system("./a2 < data.in > a2.out");

        cout << "test: " << i << '\n';
        
        // 使用 diff 进行对比，> /dev/null 表示隐藏输出
        if (system("diff a1.out a2.out > /dev/null")) 
        {
            cout << "Wrong Answer!\n";

            cout << "\n================== INPUT =================================\n";
            ifstream fin("data.in");
            cout << fin.rdbuf();
            fin.close();

            cout << "\n================== YOUR OUTPUT (a1.out) ==================\n";
            ifstream fout1("a1.out");
            cout << fout1.rdbuf();
            fout1.close();

            cout << "\n================== CORRECT OUTPUT (a2.out) ===============\n";
            ifstream fout2("a2.out");
            cout << fout2.rdbuf();
            fout2.close();

            cout << "\n================= end  ===================================\n";
            break; // 出错就退出循环
        }
        else cout << "Accept!\n";
    }

    return 0;
}

数据生成器

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fix(x) fixed<<setprecision(x)
#define int long long
using namespace std;
using ll = long long;
template<class T>
using ve = vector<T>;
using pii = pair<int, int>;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;

// 创建随机设备和随机数生成器
mt19937 rng(random_device{}());


// 生成 [l, r] 区间的随机整数
int randint(int l, int r) 
{
    return uniform_int_distribution<int>(l, r)(rng);
}

// 生成长度为len的字符串  [    ]
string randstring(int len) 
{ // 大写，数字，修改 randint('a','z');
    string res;
    for (int i = 0; i < len; ++i) res += char(randint('a', 'z'));
    return res;
}


//创建n个节点的树，无重边，无自环
void get_tree(int n)
{
    ve<int>a(n+1);
    iota(a.begin(),a.end(),0);
    shuffle(a.begin()+1,a.end(),rng);
    for(int i=1;i<=n;i++) cout<<a[i]<<" \n"[i==n];
    ve<pii>f;
    for(int i=2;i<=n;i++)
    {//连接，点u和前面的某一个点
        int u=a[i];
        int v=a[randint(1,i-1)];
        f.push_back({v,u});
    }
    cout<<n<<'\n';
    for(auto [u,v]:f) cout<<u<<" "<<v<<"\n";
}


void solve()
{
    int x=randint(0,20);
    cout<<x<<'\n';
}

signed main()
{
    IOS;
    int _ = 1; //_=randint(1,10);
    while (_--) solve();
    return 0;
}

动态规划——LIS

Wed, 07 Jan 2026 00:00:00 GMT

动态规划

<br><br> LIS 和LCS 问题

首先是这两个名词

<mark> LIS：Longest Increasing Subsequence，最长递增子序列

<br> LCS：Longest Common Subsequence，最长公共子序列

</mark>

然后先说一下LIS问题

lis O(n^2) 版本

放一个板子题 https://www.luogu.com.cn/problem/B3637

对于 6 5 1 4 2 7

这个的LIS 很明显就是 1 4 7 长度为三当然这个是不固定的

最简单的方法O(n^2)的算法，dp[i] 当前以i结尾能构造的LIS dp[i]=max(1, max(dp[1]~dp[i-1])+1) //[1,i-1] a[j]< a[i] 这样子的写就行了


void solve()
{
    int n;cin>>n;
    ve<int>a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];
    ve<int>dp(n+1);
    for(int i=1;i<=n;i++)
    {
        dp[i]=1;
        for(int j=1;j<=i-1;j++)
        {
            if(a[j]<a[i])
            {
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
    }
    cout<<dp[n]<<'\n';
}

lis O(nlogn)版本

二分优化

还有一种二分的方法，跟树状数组的方法实现这个代码

二分的方法 dp[i]:代表当前长度为i的最长上升，对于当前已经来到第j个元素 [1,j] 中最小的那个能满足的元素

二分 dp 更新找到第一个大于a[j]的dp[i] （dp[i]<=a[j]) 更新 dp[i+1]=a[j];


void solve()
{
    int n;cin>>n;
    ve<int>a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];
    ve<int>dp(n+1);
    int len=1;
    dp[1]=a[1];
    for(int i=2;i<=n;i++)
    {
        if(a[i]>dp[len]) dp[++len]=a[i];
        else
        {
            int id=lower_bound(&dp[1],&dp[len],a[i])-&dp[1];
            if(dp[id]!=a[i]) id++;
            dp[id]=a[i];
        }
       // for(int j=1;j<=n;j++) cout<<dp[j]<<" \n"[j==n];
    }

    cout<<len<<'\n';
}

树状数组优化

树状数组也能处理这个问题，思路是如果当前已经遍历到了第i个元素，树状数组维护了前[1,a[i]-1] 个元素的情况所能组成的最长公共子序列。因为在 [1,a[i]-1] 这个范围下肯定会小于a[i]。

这个方法需要注意下离散化行为，因为我们维护的是权值。

int f[N];
void add(int x,int val)
{
    while(x>0&&x<N)
    {
        f[x]=max(f[x],val);
        x+=(x&-x);
    }
}
int query(int x)
{
    int ans=0;
    while(x)
    {
        ans=max(ans,f[x]);
        x-=(x&-x);
    }
    return ans;
}
void solve()
{
    int n;cin>>n;
    ve<int>a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];

    int maxa=0;
    for(int i=1;i<=n;i++)
    {
        int x=query(a[i]-1)+1;//长度
        maxa=max(maxa,x);
        add(a[i],x);
    }
    cout<<maxa<<"\n";
}

lcs 问题

最长公共子序列问题：

给出a数组，b数组，找a,b下最长公共子序列

朴素版本O(n^2)

我们可以用dp[i][j]来表示第一个串的前i位，第二个串的前j位的LCS的长度，那么我们是很容易想到状态转移方程的：

如果当前的A1[i]和A2[j]相同（即是有新的公共元素）那么 dp[i][j]=max(dp[i][j],dp[i−1][j−1]+1);

如果不相同，即无法更新公共元素，考虑继承： dp[i][j]=max(dp[i−1][j],dp[i][j−1]

lcs O(nlogn)版本

我们可以先对a进行离散化操作。我们需要按照a的大小准则，对b操作。转换成b按照a准则下的，lis问题比如a中 [5 3] 得到5<3顺序则离散化后 5=>1 3=>2 即在b中5大小是1 3大小是2 。这个样子映射后得到的结果

这个方法需要注意重复的情况，在重复的情况需要倒序

数组无重复

int f[N];
void add(int x,int val)
{
    while(x<N)
    {
        f[x]=max(f[x],val);
        x+=(x&-x);
    }
}
int query(int x)
{
    int ans=0;
    while(x)
    {
        ans=max(ans,f[x]);
        x-=(x&-x);
    }
    return ans;
}
void solve()
{
    int n;cin>>n;
    ve<int>a(n+1),b(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) cin>>b[i];

    map<int,int>mp;
    for(int i=1;i<=n;i++) mp[a[i]]=i;
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        int x=query(mp[b[i]]-1)+1;
        ans=max(ans,x);
        add(mp[b[i]],x);
    }
    cout<<ans<<'\n';
}

数组有重复

int f[N];
void add(int x,int val)
{
    while(x<N)
    {
        f[x]=max(f[x],val);
        x+=(x&-x);
    }
}
int query(int x)
{
    int ans=0;
    while(x)
    {
        ans=max(ans,f[x]);
        x-=(x&-x);
    }
    return ans;
}
void solve()
{
    int n;cin>>n;
    int m;cin>>m;
    ve<int>a(n+1),b(m+1);
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=m;i++) cin>>b[i];
    
    ve<ve<int>>mp(N);
    for(int i=1;i<=n;i++) mp[a[i]].push_back(i);



    ve<int>g;
    for(int i=1;i<=m;i++)
    {
        for(int j=mp[b[i]].size()-1;j>=0;j--) g.push_back(mp[b[i]][j]);
    }

    for(auto x:g) cout<<x<<" ";
    cout<<"\n-------------\n";


    int ans=0;
    for(int i=0;i<g.size();i++)
    {
        int x=query(g[i]-1)+1;
        ans=max(ans,x);
        add(g[i],x);
    }
    cout<<ans<<'\n';
}

二分的方法

如果对于有重复的，新数组的构造很可能会超时间复杂度那么还是二分的方法比较稳定一点

my big school (上)

Wed, 07 Jan 2026 00:00:00 GMT

my big school (上)

</div>

1.出生时期

既然是自传，就先从出生开始吧。 (待施工)

2.大一上

</div>

伴随23高考，我成功的降临到郑州经贸学院。在这之前我并没有去接触太多的互联网。所以我也没有什么眼观。相对我来说我在23暑假期间的最常刷到的就是一些传销大学的频道。可能在我现在看来那时候自己非常的呆滞。完们c语言老师是中工外聘的，当时还在上一些c语言的课程，那个时间我时长会在什么“源程序”平台，现在已经找不到那个网站了，应该是中工oj吧，用c语言写一些做加减法的题目。或者在PTA写一些老师们拉的题单。偶然间我就联系中工的c语言老师，在后来偶然机会我也认识到中原工学院的ACM成员，日后虽然也没什么联系。进入到一个提升班选拔的qq群，知道了学院还做了些新生周赛。然后我就打了一回新生周赛，那时候什么都不懂，因为在榜的前面，随后被xj同志拉过去打南阳理工学院的校赛。这是我第一次接触到算法竞赛，这段时间我认识到的ACM，随即在抖音去看一些频道的ACM讲解，各种薄纱之类的让我有对ACM有了一些想法。

这时间我在b站找了一些c语言的课程，我认为鹏哥C语言讲的确实还可以，但不是竞赛向的。我并不了解C语言的内存，堆栈，在南阳理工新生赛在main函数定义大内存，爆栈洪文，喜提1题下机。这时间开始做提升班选拔赛，我参考了之前的选拔赛，发现学校有acm集训队这个组织。在周赛我偶然遇到了同届的mjl同学。然后两场选拔赛后，没有起到选拔的作用，大家都进了提升班，三十多个人。

总之说大一上一直都在忙进集训队的事情，混学校的日子。班里的课还是经常去上，甚至还私下去写写老师布置的作业。甚至于我大一上的绩点还能高达3.7，虽然这个数据甚至还没有过4，但跟后来的我对比，这个数字已经非常惊艳了。

3.大一下

</div>

大一的寒假，在vjudge上做题。wy属鼠在vj上拉了一个题单，我们就跟着做，让在寒假刷到150题。但实际并没打多数人应该都没有做够150个。

回来后有一个郑州轻工业大学的校赛，学校要选几个人，打了两场选拔赛，也是拿到门票了。这个时期我开始去集训室做题，一开始在三楼做了两天.

后来得知了一点事情。学校此时间有两个集训队。人工智能学院跟计算机学院。隔壁室在三楼，我们是在二楼。这个时间的二楼算是一个空教室，我们就租用了。大一的要去上晚自习，我还时有自豪，自己可以去二楼训练不用去上晚自习。就一种类似帮派之争的样子，有两个队伍，大家都会想着相互对比，去争着排名。我感觉这样互相诋毁，互相竞争的模式在某种意义上算是一种好事情。

我们去了郑州轻工业大学，参与他们学校举办的新生赛。这是我第一次出学校打比赛。在机房比的，A出题还会发气球。最后我打了7题，排名二十多。隔壁zyf打了8题，打到前十还拿了奖。算是第一次比较正式的比赛了，acm的气球氛围还是不错了

3.1 转折

我把这段时间称之为“ 危机纪元 ” 时期。

（蓝桥杯省赛的时间线差不多也是这个时期，在中原工学院打的，比赛体验差劲，省流：省一。)

伴随着我对acm的认知，我感觉到这个比赛非常的nb，跟创业大赛非同寻常，我也开始逛知乎，偶然间在b站刷到了jiangly，加进了“江丽二群”这个群可谓是信息学竞赛的枢纽了。对acm的认知越来越熟悉。以至于我对创业大赛有一种极致的鄙视性，这应该算是acm的独特优越感，收集了很多圈子的数据，盯着 https://board.xcpcio.com/ 看学校的数据。看到曾经的前辈打铜，打银。幻想自己有天能打到金。xwc出走了，xj拉了lsy跟我,mjl组队。我们也一起组了队内训练，学了背包dp。我记忆忧心的是在牛客我拉了一个单调队列题，盯一天的题解无法理解为什么。知道后来许久我才知道这种做法。

但是转折来了。24年上半年，CCPC省赛在24年进化成了全国邀请赛。一个学校只有了6支队伍，跟3楼的对半分。名额只有3支队伍。我当时还在磨拳擦掌准备跟22级打一打，最后的结果是，实际连打学长队的资格都没了，但肯定还是有点不服气。其实名额这个问题一直围绕着我整个算竞。

没有完整的训练体系，慢慢得23级的训练随时间也消散了，大家也都去摆烂了。

在ICPC省赛前夕，我们去打了蓝桥杯国赛，省流：国三。 ICPC省赛，隔壁三楼打到学校第一张金牌。这个金牌应该是河南省赛第一张三本金牌，我听zhl说的，虽然是奖励名额。zhl他们打了银，然后22级的主力队员强势打铜，圆梦退役。

在潜水一些算法群，我得知了，下半年有XCPC区域赛。在18年学校成立队伍来学校只有两只队伍打进去过去区域赛。20年疫情时期的远古时期的队伍，跟三楼在22年打的CCPC哈尔滨站。但全都遗憾打铁了。

总之这个时间我的状态很差劲，自己的训练没有发挥的结果。我甚至当时已经萌发出了跑路的想法，这个团队没有我想象的那样，后面晚上也不再去二楼训练，开始留在宿舍玩了。

五月份我接触到了codeforces，这是俄罗斯的信息学奥赛的网站。由于时差，比赛几乎都在晚上到凌晨。我开始打codeforces，我对acm圈内的一些东西慢慢都开始熟悉，在暑假前夕打上了1300分，我觉得大一下是我的转折点。如果没有22级搞的那些事情我估计对acm也不会有太大的执念。或许后面的故事也不会如此发展了。

acm集训队选拔赛。也看不到什么选拔效果了，已经没有之前提升班，郑轻新生赛选拔赛时期新鲜感了。时间也差不多来到了百度之星省赛。百度之星是第一次参与，百度之星省赛的题对当时的我们太难乐，很多爆零的，mjl也爆零了，我下机看只a了两题，感觉已经无了，随后问了一圈，只有我跟xwc，2题，打了铜，其余的全爆零或者签到，全体坠机。

百度之星省赛结束后。24上半年的所有的比赛都结束了。简单说对于acmer来说，大家的主要战场都在下半年的区域赛，但是这个时期，郑州经贸学院集训队对于区域赛来说，能不能打到参赛名额都是一个严峻的问题，照看之前的经验就是说zueb的acm选手不打acm。

XCPC省赛结束后，wy属鼠退役去考研了。22级的也都不在做acm，对于这些前辈，我当时也仅仅与wy属鼠跟xj同志认识而已了。xwc,zhl缺了一个人，我被拉过去打网络赛。所以只能抛弃mjl同学了。主要我担心不跟主流队伍，明年能不能上场都是一个问题，事实确实如此，在弱校，没有一个完整的名额分配体系，甚至在有太多又菜又爱打，名义上的最强队就是有保送比赛名额的优势。

3.2.暑期集训

ACMer是没有假期的，但是我有。

7月份我在家玩，我发现在家根本就没法去静心训练，其根本还是个人问题。这个时间我靠手速的cf打到了1400分。被xwc忽悠说蓝名足以河南省金。但现在河南省赛难度感觉有种逐年递增的感觉，应该越来越普及了。

8月份回到学校集训，每天做着早8去，二楼摸鱼。这个时期我们集训队内还在分组做一些专题，其实开始的势头都还好，越往后面还在做的人就比较少了，训练的内容也忘的差不多，我是在二楼的，当时mjl，zb他们还搞了一群一样的键盘，点名狼蛛F87，这个时期是在学校最舒服的一个时期。22级的老登在一楼考研，xwc他在一楼训练。

此时我才终于知道，省赛只是玩一玩，区域赛才是算法竞赛。这个时候感觉区域赛搞个牌子这辈子也就有了。

$贴几张24暑假集训照片$

暑期集训，二楼的水瓶

大二上

</div>

随后9月份开始3周的网络赛，先是CCPC，随后ICPC两场。在网络赛之前我们队打过几次训练赛，我一直都是0作用，都是他俩在A题。

CCPC网络赛，zhl承当主力，先签到，在跟xwc一起开，然后zhl又开一题，随后我爆冷开了三维“区间dp”，这也是我的唯一作用。随后3人开香槟感觉有了。赛后我们一起去吃了串串。赛后校排211，直接炸了，后来因为pta原因把4题队名额都发了1个，然后我发现前面有2个学校貌似是被判舞弊了(难道是连坐吗)随后的ICPC网络赛就是打着玩了，因为已经有一个名额了。所以ICPC的事情记的已经不太清楚了。我记得一场被一个中位数的中位数卡到崩溃，一场zhl假翻译卡到崩溃。

CCPC网络赛现场

之后的时间，学校的两个学院合并，二楼。虽然学院合并了，但是二楼三楼并没有做合并，后面的名额就更少了。这个消息出来后，我想很多23级的在这个时期已经结束了。

这段时期我跟zhl慢慢熟悉了,我俩经常在二楼冲浪。

网络赛结束，薛老师请客吃饭，讨论了后续二楼的安排，当时考虑了lsy，mjl，tyl，然后我跟xwc推荐了dzy 来当队长，主要他在一些QQ群的唐人发言，感觉很可爱。在现在看这个选择是正确的，为二楼带来了一位省金选手。

2024ccpc区域赛郑州站

随后我们开始准备郑州站，一直在幻想着郑州站拿牌，给学校打个历史。郑州站。这是第一次打区域赛，虽然此时我还没有打过省赛，但还是被区域赛的队伍配置震撼到，路边随便拉一队都比我们强。这就不得不讲三本自尊这件事情了，这场比赛意外是Windows系统，还有cph。热身赛被一道建图卡到结束。郑轻的衣服感觉不太好看，志愿者的袋鼠衣服挺好看。次日正式赛，体育场容纳接近300支队伍，这体育馆的体验就非常好，钱包也很爆炸，开局就卡签到题L，xwc打表发现规律，我上机敲了一下二进制。1个小时过签到。随后陷入卡题，这场题面真难懂，我跟zhl在F理解样例花了很久,XWC单开了B题。然后我上机去敲F题，最后面向样例，改了一下就过了F。这个时候3题。还要给M题开了。我曾想过很多种输的情况。唯独没有想到最后连M题的题面都看不懂，还是中文题面，3人对着一个中文题面硬控了1个多小时。最后破防打铁。我的第一站献给了郑州铁牌。

本想着打铜了找jiangly签个名的 wangy与jiangly(算竞圈知名人物)

对于我们这种学校，下半年几乎是无比赛打。这个时候开始了助力新生赛，这个烂摊子扔给了Dzy去做，主要我的教育形态跟他有所违背，我比较倾向于压力政策，对一些没有必要的事情，认为没有做的必要，dzy,xwc,就有点稳扎稳打的样子。我也就跟新生没什么交谈了。一直持续到寒假。这段时间大致就是做一些算法跟日常跟zhl诋毁，偶尔浅谈未来，聊聊二楼八卦。这个时期算是我们队数据上的巅峰状态了。

这个阶段就一直持续到寒假，此时还是一年无牌选手。

大二下

</div>

到寒假，今年寒假集体参与了牛客寒假训练营。

回到学校后，就是激动人心的一群比赛事情要处理。先是选拔了24届的新生。我统筹最后一场新生赛的题目工作，这套题目难度很高，搬运了一群绿题，给新生造成了不小的压力，但是两个签到实际是很简单的，不应该两个签到题做到结束，我尽可能的避免比赛出线题目问题，最后2题签到rk1，这里只能对当时参与这场的新生说声抱歉，没考虑到中位数水平，最后的滚榜还是很有激情的，我本还想着等25年我也去做一下滚榜，但已经没有机会了额。

学校之前没有打过邀请赛，今年wy属鼠跟我们研究了邀请赛的情况。我们拿到了武汉邀请赛的三个名额，西安邀请赛的一个名额。其实名额问题一直以来都是一个很大的问题，我想要找到一种方式，也看了杭电等一些学校在名额以及集训队的管理，这并不太适合我们这种草台班子，xj是22届队长，但之前许多原因以及24年省赛。我对他一直有偏见，我对他的实力一直很怀疑，主要他网络赛的一些代码存在 ai 嫌疑，而且他两年时间只打到省赛铜，还在考研。我的观念还是厉害的去上，不论辈分，不论身份，但是实在难找到一种相对公平的方式，那些有管理的集训队，对我们来说实在困难，所以名额这种东西只能无奈如同之前的情况，我们仍然做了一些挣扎，给了新生跟不练的老生比拼一点机会，虽然并不能做到公平。

回到学校一段时间我的cf分数就到了1600分。

4.6郑轻校赛。

这是上半年的第一场，河南有些学校打星，有些就没打。我们是正式参赛队伍，这场是200队伍的规模。我们前期非常稳定开签到，后2个小时卡到结束。最后总榜第10，校外第8名,算是打个开门红。这场我发挥还算稳定。稳定度过前期题跟简单数论。后期就没任何贡献。主要简单的题目相对来说比较多一点，并没有体现这支队伍的问题。

当时的榜单

4.12蓝桥杯省赛。 省流：省一，仍然在中原工学院，机房的电脑比zueb都拉，鼠标滚轮坏的还不给我换，体验感拉爆了。

4.19天梯赛，被一个栈模拟卡了一个多小时。这也决定了我之后对模拟的态度。国三结束。

因为武汉邀请赛抢到了三个名额，然后我撮合了踢出xj，让gjz跟dzy,mjl去打武汉。

最后一支队伍在群里随便一问。然后就组了三队。

学校历年来没有打邀请赛的先例，所以报销的问题当然是没有了，zhl给我们干了9张火车的站票，一群人就这样一起去了武汉。

ICPC武汉邀请赛

武汉邀请赛的整体强度跟区域赛的难度已经没差多少了，很多区域赛的金牌队伍都在，在国家网安基地的华中科技大学，这对于我来说就是，农村人进城，可见这个时期的三本自尊还是非常强烈了。第一次出去这么远的比赛，赛前我们三个认为最差也不会打铁，这个队伍的问题也是从这里出现了，正式赛，我们找不到之前的文件夹开局20分钟才签上到，然后我们zhl去做构造，a掉之后，我跟xwc去一起看忘了是什么题，他的做法没给我讲清楚，我抢了他的机子，我的做法也没给他讲清楚，最后我卡根号分治，打铁出局。在此之前24下半年数据，以为邀请赛至少也会是个铜，但是我们太菜了。武汉邀请赛跟郑州邀请赛的强度差距太大了。其实这里我们这支队伍就已经出问题了。

5.3 icpc西安邀请赛。

西安正好这几天放假，没想到那个校区这么偏僻，但是学校是真的大我们都没逛完。这是场400队的大场，而且非常容易拿到牌子。赛前我们还说如果拿牌子了好好玩一下。

这场榜还是歪的。如果当时，我们分开看题，让xwc去看那个思维，这场是肯定能拿牌的。这场直接hack了三人开一题的策略。是完全的决策错误。而且最后封榜我a掉的那个题，也成为了本赛季我们队唯一的封榜a题。

所以两场邀请赛。相当于去俩985被一群✌打，然后回去。两场铁后，我们队伍就停止了vp因为我这个时候心态已经崩了。我需要去调整心态了。

西安邀请赛开幕式

5.11 icpc河南省赛。

面对前两场的失败。这一个星期我一直在调整自己的心态。我认为之前的一些原因心态炸裂很大方面是，我已经打了一年了，除了没资格打省赛，就是区域赛铁牌。这个拿牌执念太深了。今年的河南省赛在，商丘师范学院，发的衣服挺不错了，但是这场比赛的问题还是比较大，测评机太卡了。题目问题还很多。我们赛时开始签到还是很顺利的，然后就是我的战犯操作了，我先时给凸包题看错了，然后上机，zhl还造错误样例，我就上机两个小时另外wa五发。然后zhl指出结构时凸包，这个时候已经两个多小时了，我心态已经无了。换题去了，xwc上机给大模拟开了。然后我就发现f题，有一种lca的感觉。想到之前我学过启发式合并的一种处理方法，就立马想到这个做法绝对是可以的。然后开了f题，算是赎罪了。之后三个人梭哈凸包卡到结束。如果当时我们拉上xwc一起看凸包，可能我们就g了。这或许就是西安的作用吧。赛后有惊无险的金牌尾巴。但是也并没有想象中的那么兴奋。可能这张金牌在好久好久之前，我们就已经当做自己的了。也完成之前给zhl说的“上机两小时，wa5发”。

总之icpc河南来讲，就是又有报销，结果还好，虽然过程痛苦了一点。

从武汉回来后我就学了一点怎么在linux去用脚本文件去编译cpp文件，还搞了一下 win批量运行脚本。感觉以后比赛vscode还是用脚本文件比较方便。其实脚本文件真的也挺好用的。主要之前省赛都是在win系统下的。

CCPC郑州邀请赛，河南省赛

郑州邀请赛是在体育馆举办，体育馆的氛围比较好，这里有一个插曲，郑轻当时的场地小一些，李老师还来郑州经贸学院考察了场地。6.1儿童节当天，我们10点就去黄河科技学院，前面打的很多场都没有好好体验，我们去到黄科发现，三本之间亦有差距。我们在校内骑着共享电车游遍黄科，可惜没有西工大的有山有水。队服不知道为什么小了一个号码，蓝色的衣服我是感觉不是很好看，还有一个帽子，xwc戴上也是很有感觉，然后发现教练的衣服是白色的也就是说，今年ccpc的选手服是去年的教练服。xue老师还发了一张去年教练衣服，主教练正在热身。

16：00热身赛。热身赛电脑非常的卡，测评机也是非常的卡，一直在ping。CPH卡到爆炸，我们都没编译直接扔上去跑了。

热身结束后，吃完一卡通的所有钱，然后我们就回去了，说来ccpc结束第二天就是2门考试，那是一点没有复习。晚上回去后，我日常跟wwz打劫，然后看会知乎。这天晚上我还看了看我之前的代码。想着上回没拿线性基这回万一出了怎么办。但想着前些天我打印的500页的繁凡的板子，这回板子应该是全的，虚惊一场。

第二天我们早7点起来，xwc这回没有睡过头。我们到黄科，xwc没吃早饭想买瓶能量饮料，发现黄科没卖的。xue老师跟wangy跑去给我们买了3瓶饮料。这里xwc进赛场尽然不带身份证，还好没有什么影响。体育场真是好评，这种大赛场才是邀请赛应有的样子。

然后比赛我的战犯行为开始了，一开始我手上有着我的main函数模板，我不知道我在干什么我不照着板子上去敲，盲目的敲完main函数。之后我就去看a题了，发现a题意是很好理解了，但是没有一点想法。Xwc,zhl去写了签到，我在看m,然后我上去写m。想着m过的很多应该不会卡map，我用了两此的mp[x] == 1的判断我知道这个样子的判断时间不是很友好。然后t了一发。zhl说给map的判断换了，我换成mp.find(）！=mp.end()。我这个时候不知道在干什么开了个临时变量没初始化，然后又t了。然后发现我的main函数没有引用IOS 对的IOS我已经在全局宏定义了但是我没有引用这个宏。加上后就a掉了。这个时候我还对zhl说不会就因为我这三发罚时把(照应后文)。

xwc去写了迷宫跑路。我跟zhl去看构造树。我按照zhl的构造结构，推理了一个二元一次方程组，解x+y+1=n,x+(y+1)/2=y+1 ==>x=n/3 。然后得到了3 * k，3 * k - 1的做法。之后菊花树在加一个节点得到了3*k-2的做法。然后上去对前4个特判之后按照我的数学推论a掉了这个题。我只记得xwc在旁边也叫了他的战犯行为，他有一发没初始化然后wa了。随后不知道他改了什么a掉了。

看了下榜单N+2同校的了。这个时候我想到了e的一种字典树的做法，然后上去乱搞了一下我跟xwc在争论字典树数组大小的问题，我之前在做字典树被卡过内存，所以我字典树开了N40的大小。我想着给long long 关了这个内存肯定是不会超的。然后xwc力争内存，我改成了N10，又发现又n*(n+1)/2这个数据给long long 开了。(实际上，这个26个字母的字典树开的内存跟串的长度有关)交上一发没想到尽然a掉了。

然后发了马斯卡彭，这回吃爽了，我们吃着马斯卡彭看了下榜单。看河南榜第7.总榜49.发现再a一题。双金了。也就是说如果开局，我板子在main函数引用IOS，省赛就有金牌了。

这个时候我看了b题发现是期望dp，n^2的时间复杂度，但是我已经晕了组合数学，看到c题，我想到了一种珂朵莉树+权值线段树的做法，大概就是在珂朵莉树上操作区间修改，然后在权值线段树上处理珂朵莉树的信息更替。修改的时间是2*logn。权值线段树的查询是O（1)的常数。我看了一下我好久之前自己的板子我发现尽然没有带珂朵莉的板子。又翻了一下繁凡的板子也没有。感觉有哭有😀。

上回icpc省赛没带线性基(虽然线段树上+线性基的时间会超)，这回没带珂朵莉树。然后没办法了只能用一颗线段树+权值树状数组处理这个过程了。看到是多组样例，对这种选手肯定是class包装一下。搞完了150行代码。然后发现权值树状数组好像不能处理区间max。xwc在旁边看我一愣一愣了，可以给权值树状数组改成线段树再修修bug但是还有30分钟，其实是可以拼一下的，虽然大概率我的第一棵线段树替换珂朵莉树的效果感觉有问题。

然后看榜单省赛已经刚好掉出金牌区了，看了眼同校的都在卡构造跟迷宫跑路。计算了一下，大概就是省赛银首+邀请赛银了。然后预期的跟结果是一样的。这个时间对应我的3发签到罚时，发现如果少一发罚时我们就有省赛金牌了，哈哈正中开始的时候我对zhl说的三发罚时。

这里反映了我们队的一个严重的缺陷，坐不住，明明还有两个多小时的时间，完全可以在去梭哈一题。

或许放到武汉前我可能会因为我的战犯三发罚时感到苦恼，但现在尽然也没什么大波动了。赛后我拿到珂朵莉树的板子做了一下，发现我珂朵莉树+权值线段树，的想法跟题解一毛一样。赛后回去我就过c题的痛苦感🤣，如果带珂朵莉树，可能就双金了。

至少这场比赛打的还挺欢乐的。我们在赛场拍了最后的合照，或许这就是阿比盖尔之花的最后一场省赛…………

好吧现在考试结束了。原本以为郑州打完就结束了，但是ccpc福建邀请赛名额也拿到了，后面还有百度之星，蓝桥杯国赛。那只能准备福建了😄

CCPC福建邀请赛

省赛结束后。是一场线上的福建邀请赛。确实省了不少开销。开局他俩梦游了。前期3个小时，我单开5个前期题。然后我就睡着了。他俩开两个题。来到银牌区前列。最后我有点BUG没调出E题。遗憾打银。

然后我开始入海教培了。主要wy考完研没事干下海教培了。我也想挣点快钱。dzy紧跟着也下海做教培了。这里我几乎开始摆烂吃老本了。只学了个强联通分量，割边，缩点，一些数论。7月份在家。这段时间非常的折磨，这个阶段正在接受意识形态的摧残，反正就做点教培，训练也少了。主要为对区域赛已经没心气了，zhl精力放到考研去了，我下海教培了，xwc不知道在干嘛。整个7月份就是浑浊状态，总体上一种颓废。

8月份回学校，我开始全职教培了，但训练量比7月份多不少。xwc开始猛攻训练。这里我还挺对不起xwc的，这个时候我的状态太差劲了，如果当时我没做教培，精力放到训练上，后面我们也许就不会这么狼狈。

8月份我跟gjz交流的多了，他接触网络的时间很早，有很多经验，但都不深刻。我俩经常聊一些不能讲的东西。每天就是早8去2楼，中午来个小汉堡。以前我是感觉小汉堡没什么吃的，但8月份吃了一个月的小汉堡。这段时间总结来说就是做教培圈钱了。

所有比赛结束，薛老师奖励。

2025CCPC郑州邀请赛（河南省赛）

wangy打LOL

大三上

</div>

开学之后，在网络赛前夕，我跟gjz晚上会经常开黑打cf，虽然效果不如我自己打。但至少是难得晚上还能找到打cf的了。几乎就是做几个签到题就下班了。一场比赛都打不到结束，完全没有训练效果。实际从大一下开始，学校的事情我就没怎么搞了，慢慢开始逃课，直到现在我也是偶尔去上上课了，这里点名感谢wwz同学，帮我答到，如果没有wwz帮我做学校的一些事情，感觉我可以被劝退了。

这个时候我还时长在二楼摸鱼，还想着做一场 “集训队劝退赛“，给一些名存实亡的大二，大三的踢出集训队。虽然我也不训了，正好之前"金鸡毛杯"还有些费案的题目，可以利用一下。当时还跟gjz，cjr一起玩了《失落城堡》。

网络赛前夕，dzy，cjr，他们去打了南昌，感觉出省打的二楼的状态都太差劲了。他们也是坠机了。

然后ICPC网络赛第一场。被一个分层图卡常了，题目的数据我的时间复杂度可以通过的。但是被卡了。结束在qoj提交发现过了。这场比赛题目被骂的很惨。卡常数，实际预期解的时间就是n方的，但是给的数据，我的做法时间复杂度是可以过的。赛后有队伍应该做优化卡过去了。

结束end

一个消息，二楼散了，现在我只有晚上的位置去了。所有的事情并没有按照之前的假设去进行，在一些复杂的事情下,全部滚回到了一楼。我已经能想到之后的样子了。所以我26年选拔赛滚榜的愿望也碎了。我的劝退场还没有开始，我被劝退了。

随后来的就是第二场网络赛。第二场网络赛纯纯数学场，XWC大手去写了二分+容斥，我推公式用组合数过了第二个。然后猜了个结论。最后三题结束。整体综合下来就是g了。

CCPC网络赛，算起来似乎正是二楼的结束时间了。我全程在梦游，让xwc一个人在单挑，没打过隔壁gjz，外卡的事情扔给他们队了。

然后就是ICPC整外卡的了，由于学校从来没有打过区域赛所以我们算是吃上红利了，搞到了西安站跟沈阳站的外卡。

这里分享一下我们外卡的作文：

尊敬的ICPC组委会、承办方老师们：

您们好！

我校长期重视大学生程序设计竞赛的开展，积极组织学生参加 ICPC 省赛，邀请赛。现特向组委会申请外卡名额。
	我校自成立 ACM 集训队，持续开展算法竞赛训练，积极参与各类赛事。近年来，学校逐步完善了竞赛支持体系，设立
专项训练计划，提供必要经费，并鼓励更多学生广泛参与算法竞赛。但是至今我校尚未进入过 ICPC 区域赛，在 2025 年 ICPC、
网络赛中，第一场校排名为 252 名，第二场为 193 名，合并排名 240 名，创造了我校迄今为止的最佳成绩，但仍然距离获取名
额有些差距。我校至今未能进入 ICPC 区域赛，参赛同学对此深感遗憾。
	当前学校主力队员多为大三、大四学生，也都有三年的比赛经历，受升学与毕业压力影响，未来将难以继续坚持至 2026 年网络赛。
若能获得本赛季外卡名额，将是他们最后一次在 ICPC 赛场上展示实力的宝贵机会，同时也有助于激励更多低年级同学投身竞赛。
	学校将继续全力支持 ICPC 中国赛区的各项工作，积极组织参赛队伍，严格遵守竞赛相关规定，认真备赛，文明参赛。若能获得外卡
机会，我校必将倍加珍惜，力争在赛场上展现风采。恳请组委会考虑我校申请，给予外卡参赛资格。我们真诚期盼能在 ICPC 区域赛中展示
风采，并通过参赛进一步推动学校算法竞赛的发展。
	再次衷心感谢各位老师在百忙之中审阅我们的申请！祝2025年ICPC亚洲区域赛（xx站）圆满成功！
此致
	敬礼！
     
申请学校：郑州经贸学院
联系方式：xxx
日期: xxxxxxxxx

拿到西安外卡，从暑假结束，基本就没做题了，做的题也都没什么训练价值，我已经是摆烂状态了，平常没事跟gjz去一楼学学项目，学学英语了。平时可以见到的人慢慢的都看不到了，大家都各忙各的事情去了。西安前我也并没有训多少，只是写了几个水题而已，然后做做教培。这个时候觉得虚拟币未来很有看头。

ICPC区域赛西安

时间来到第50届国际大学生程序设计竞赛亚洲区域赛。西安我们拿牌子的概率是非常的大的，跟上半年的邀请赛是一样的。还是西北工业大学的长安校区。前瞻我们还在铜尾徘徊。

赛前，我跟zhl为了省点钱，我俩通宵去做火车，次天早少6点到西安火车站，就打车去秦龙酒店，到11点去西北工业大学，然后去听华为讲座，听了俊杰Charles的分享。下午的热身赛，这个时期我已经研究好比赛的环境了，随手一搞，然后回酒店。5月份来过西北工业大学，所以没太多好逛的。

次日开赛，zhl去翻译题目，xwc很快的去签到，然后第二题我先是没有思考特殊情况，莽了一把，wa了一发很快发现hack情况，然后构思了一些想到了一个二分的做法，ac掉之后。 zhl给我讲了第三个题，我模拟一下样例，很快发现一个做法，将点权转换成边权，这个过程需要先维护每一个节点所有儿子的最小点权，次小点权，然后此点跟父亲的连边的权值就是其一，做一遍LCA的处理，单次查询就是一个log级别的倍增做法，我给zhl讲了一下，很认可我的做法，然后xwc似乎有点不理解，我感觉我的做法很正确，然后上机乱搞一下，写了150行左右，然后漏掉了一个树向上递推的情况，改成树上跑dp做边权，然后一发A了，之后还有两个题目，我看了xwc在做的构造，乱搞了一下没有思路，去看了有向基环树森林的题，想到了一个做法，跑拓扑排序，维护每一个点的。总的时间复杂度是一个线性了，跟zhl讲了一下，他也没听明白的推的式子，我上机搞了一下，样例都过了，交后wa了。xwc去做了他那个题，但也被卡了。结束后又是同样的剧情。

西安区域赛现场

队伍问题。

这个时间都冷静了一下回顾西安的情况，西安的强度是所有赛站最低的,但依旧打铁了，zhl这个时候也不想打了，如果又沈阳让换人，实际我很早之前在网络赛就发现zhl的问题了，从去年郑州开始，zhl的精力都放在考研了，牛客寒假还能打打，从寒假回来后，我看他的账号就没有在做题了，在上半年还能有些作用。网络赛。西安站，4场比赛他甚至连键盘都没有去摸。实际也时我俩强行拉他打的，确实也没有人了。这个问题时三本无法解决的，我已经想沈阳站给zhl踢了。换人如果在中文的情况下，肯定比现在的三个人打压力好多了，主要他把题面一翻译全程都在梦游，样例也不造一个。

其实主要还是我太菜了，根本没有铜牌实力，情绪发泄到队伍问题。

zhl作为22届主力队员。就算不练也不至于热身赛键盘都不去碰一下。当时感觉放他去考研更好。现在看他，他还挺勇敢的，愿意在我俩身上下金币赌注去赌区域赛拿牌。

wy，Mr.xue应该也发现我心态炸裂了，Mr.xue还给我开个专场开导了一下。

省流没有踢zhl。

沈阳外卡最后的机会，新队名“最后的阿比盖尔之花”

沈阳拿到外卡了，这是我们最后的机会，静下心去想，现在能做翻译题目且曾经有水平的只有zhl能打了。我们不敢去赌沈阳站有中文。最后队伍敲定，nszkay,xwc,zhl组成最后的阿比盖尔之花，结束我的ACMer生涯。

ICPC区域赛沈阳

已经熟悉了去外面打比赛的流程。沈阳火车要一天。我们准备飞机过去。我跟xwc 在周五到。然后在酒店玩了一天。周六去东北大学报道，领了衣服，是个浅色的马甲，只做了华为套圈的活动，后面华为宣传大会也没去，签到有点晚了，没有领到隔壁非凸科技的fufu玩偶。沈阳站有400支队伍，强度跟西安做一桌，这样看来，今年的区域赛就西安跟沈阳的强度是最低的。

晚上热身赛给我干蒙了，热身赛有计算几何，交互题，通信题。一般热身赛出计算几何是不是意味着计算几何是可作的题。最难不过银牌题吧。我对交互题的逻辑是很不理解，通信题知道最后才知道他这个流程的情况。如果这三题都是铜牌题，那这场就完了。

国内第一次通信题出现在了沈阳站，虽然这场的通信题是一个非常hard的题。

晚上吃过饭zhl也来了。热身赛已经确定有中文题面了。实际早在沈阳群发队伍信息的时候我就在别的群知道有中文题面但不敢确定。

正式赛开始。我去调环境。zhl跟xwc去找了签到在10min a掉后签到后，我跟zhl去看B题，我们推出一个公式。可以前缀和处理好，常数时间得到，然后我提出这个公式可能有抛线性质。去做一个三分。时间上也允许(实际上线性求就行了)。xwc在看M题,然后xwc下机，我上去写B题，让zhl给每一种层数推出来。我调试了一会A掉后，xwc上去写M题，很快A掉。在90分钟左右，3题罚时191，随后看K题，发现一点做不了，完全没有思路，然后开始摆烂，在封榜前170名左右，还有70名的下降空间，感觉K题是脑电波题目，封榜后我让xwc去看F题，感觉可以做，对了一下思路：

如果ab点没有边，可让与ab点相邻的边指向他们其余边随便。反知，如果AB点在环上，让环顺时针或者逆时针指向，其余边指向环，这个可以用拓扑排序如果A在环，B不在，让B指向A，让让环顺时针或者逆时针指向，然后跟A,B有关的边都指向A,B，做拓扑排序。如果都不在，判断A,B谁的一次可以出现环，加入B侧有环，然A->B，反之A测有环B->A ,反之无解。

代码比较难实现，只有30分钟不到。码了200行，吃的很难受，最后，AB环方向问题是在太难写放弃。结束看到下面都在交F题，认为F题是榜单歪了。有点担心。赛后看群发现，，k 题太脑电波了。大家都是F有点思路，去写了F题，但F是一种刺史大模拟，代码很不好写，最后过的不多，终榜199名，铜了。在赛场进行的滚榜，我们没有看到最后的滚榜，赶飞机，就提前走了。

补：回学校一段时间后，我们的报销下来了，一直以来，只有icpc河南省赛有过报销，其余的ccpc省赛，邀请赛，区域赛，icpc邀请赛都没有报销。前前后后打比赛也花了几千块钱了，xue教练最后给我们争取到了大三上的两场icpc区域赛报销，让我吃惊的是，学校对省赛的支持的比赛一直有一个一天90元的比赛补助。也是很吃惊了。看来我大经贸对icpc还是比较认可的，还能跟蓝桥杯做一桌。

遥看我两年的算法竞赛生涯，到如今这个现状，最后结果没当时想的如此，没有天赋注定了在这个赛场走不远,我现在的状态以及环境已经不支持我继续坚持下去了。我已经够幸运了，还能有几个队友。在这里能遇到二楼这个团队，在我这个级别的学校，大部分人或许连集训队都没有，甚至组不到一个队伍，没有一个训练场所。也m了很久zueb,现在回想起来，感慨万千。两年来去过很多学校打过很多场比赛，至少我的大学生涯献给算法竞赛，很感谢zueb对我们支持。从新生赛一起到，省赛，区域赛。遇到很多不同班级，不同专业的同学。我的故事开始一场新生赛，在沈阳站结束。我仍然希望未来，在zueb当某几个新人，还能讨论到二楼打出的成绩，就像好久前的我们那样。

感谢我的队友xwc，zhl。感谢xue教练，wy,xj,dzy,mjl,gjz,等等二楼的各位。感谢wwz。感谢zueb对二楼一直以来的支持。

有缘了ACM，Nszkay退役了····

Codeforces_Global_30

Fri, 19 Dec 2025 00:00:00 GMT

Codeforces Global Round 30 (Div. 1 + Div. 2)

链接 https://codeforces.com/contest/2164

4题，Ranking 1.5k

A题

只需要判断数组是否存在k,或者存在<k,也存在>k,做一下判断

void solve()
{
    int n;cin>>n;
    ve<int>a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];
    int x;cin>>x;
    int op=0,id1=0,id2=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]==x) op=1;
        if(a[i]>x) id1=1;
        if(a[i]<x) id2=1;
    }
    if(op||(id1&&id2))
    {
        cout<<"Yes\n";
    }
    else cout<<"No\n";
}

B题

猜结论，猜测，出现的概率很大，对第i个位置，暴力向后跑100次

void solve()
{
    int n;cin>>n;
    ve<int>a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];
    ve<int>f;
    for(int i=1;i<=n;i++)
    {
        if(a[i]%2==0) f.push_back(a[i]);
    }
    if(f.size()>=2) 
    {
        cout<<f[0]<<" "<<f[1]<<'\n';
        return ;
    }
    else 
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=min(n,i+100);j++)
            {
                if((a[j]%a[i])%2==0)
                {
                    cout<<a[i]<<" "<<a[j]<<'\n';
                    return ;
                }
            }
        }
    }
    cout<<"-1\n";
}

C题

做法比较麻烦。肯定有更简单的做法

对数组a扔到小顶堆。然后数组，b,c做按照b升序的排序。然后线段树维护数组c的区间最大值，以及最大值的下标，优先用数组a最小的，然后在数组b二分出a所能击败的位置id，查询区间[1,id]的最大值，更新小顶堆。随后修改击败位置的下标。

struct my_tree
{
    // 区间和
    #define kl (k<<1)
    #define kr (k<<1|1)

    struct node
    {
        int l, r, sum,id;
    };

    vector<node> tree;
    my_tree(int x)
    {
        tree = vector<node>(x*4+10);
    }

    void pushup(node& kk, const node& kkl, const node& kkr)
    {
        if(kkl.sum>kkr.sum) kk.sum=kkl.sum,kk.id=kkl.id;
        else kk.sum=kkr.sum,kk.id=kkr.id;
    }
    void pushup(int k)
    {
        pushup(tree[k], tree[kl], tree[kr]);
    }

    void build(int k, int l, int r, ve<int>& a)
    {
        tree[k]={l,r};
        if (l == r)
        {
            tree[k].sum = a[l];
            tree[k].id=l;
            return;
        }
        int mid = (l + r) >> 1;
        build(kl, l, mid, a);
        build(kr, mid + 1, r, a);
        pushup(k);
    }

    // 区间修改 // 区间替换 
    void update(int k, int l, int r, int val)
    {
        if (tree[k].l >= l && tree[k].r <= r)
        {
            tree[k].sum = val;
            return;
        }
        int mid = (tree[k].l + tree[k].r) >> 1;
        if (l <= mid) update(kl, l, r, val);
        if (r > mid) update(kr, l, r, val);
        pushup(k);
    }

    node query(int k, int l, int r)
    {
        if (l <= tree[k].l && tree[k].r <= r) return tree[k];
        int mid = (tree[k].l + tree[k].r) >> 1;

        node kkl = {tree[k].l, mid,-1,-1};
        node kkr = {mid + 1, tree[k].r,-1,-1};
        node kk = {tree[k].l, tree[k].r,-1,-1};

        if (l <= mid) kkl = query(kl, l, r);
        if (r > mid) kkr = query(kr, l, r);
        pushup(kk, kkl, kkr);
        return kk;
    }
};
void solve()
{
    int n,m;cin>>n>>m;
    priority_queue<int,ve<int>,greater<>>pq;
    for(int i=1;i<=n;i++) 
    {
        int x;cin>>x;
        pq.push(x);
    }
    ve<pii>a(m+1);
    for(int i=1;i<=m;i++) cin>>a[i].first;
    for(int i=1;i<=m;i++) cin>>a[i].second;
    function<bool(pii,pii)>cmp=[&](pii x,pii y)
    {
        if(x.first!=y.first) return x.first<y.first;
        return x.second>y.second;
    };
    sort(a.begin()+1,a.end(),cmp);
    ve<int>b(m+1),c(m+1);
    for(int i=1;i<=m;i++) b[i]=a[i].first,c[i]=a[i].second;
    my_tree te(m+1);
    te.build(1,1,m,c);//
    int ans=0;
    // for(int i=1;i<=m;i++) cout<<b[i]<<" \n"[i==m];
    // for(int i=1;i<=m;i++) cout<<c[i]<<" \n"[i==m];
    while(pq.size())
    {
        int x=pq.top();pq.pop();
        int id=upper_bound(b.begin()+1,b.end(),x)-b.begin();
        id--;
        if(id<=0) continue;
        auto [l,r,sum,ip]=te.query(1,1,id);
        // cout<<1<<" "<<id<<' '<<sum<<" "<<ip<<'\n';
        if(sum>0) 
        {
            pq.push(max(x,sum));
        }
        if(sum>=0) 
        {
            te.update(1,ip,ip,-1);
            ans++;//
        }
    }
    cout<<ans<<'\n';

}

一个更简单的做法，可以对c == 0的放到一个集合中，然后先去操作>0的，优先选择b小的，在现有的可重集合二分查找第一个可以击败b的，去更新最后在对c==0的数组做操作。这样可以简化一下线段树的码量

void solve()
{
    int n,m;cin>>n>>m;
    ve<int>a(n+1),b(m+1),c(m+1);
    int cnt0=0,cnt1=0;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=m;i++) cin>>b[i];
    for(int i=1;i<=m;i++) cin>>c[i];
    ve<int>id0,id1;
    for(int i=1;i<=m;i++)
    {
        if(c[i]==0) id0.push_back(i);
        else id1.push_back(i);
    }
    auto cmp=[&](int l,int r)->bool
    {
        if(b[l]!=b[r]) return b[l]<b[r];
        return l<r;
    };
    sort(id0.begin(),id0.end(),cmp);
    sort(id1.begin(),id1.end(),cmp);
    multiset<int>se;
    for(int i=1;i<=n;i++) se.insert(a[i]);
    int ans=0;
    for(int k=0;k<id1.size();k++)
    {
        int i=id1[k];//优先拿出较小的b。
        auto it=se.lower_bound(b[i]);//找第一个大于等于他的a
        if(it==se.end()) break;
        int x=*it;//
        se.erase(it);
        x=max(x,c[i]);
        se.insert(x);
        ans++;
    }
    // for(auto x:se) cout<<x<<" ";
    // cout<<'\n';
    // cout<<ans<<'\n';
    for(auto i:id0)
    {
        auto it=se.lower_bound(b[i]);
        if(it==se.end()) break;
        se.erase(it);
        ans++;
    }
    cout<<ans<<'\n';

}

D题

s<sup>'</sup>[i]=s[i-1] || s<sup>'</sup>[i]=s[i] 得到i位置一定由<i前面的位置更新，所以优先从后向前去考虑满足第i个位置前提下，如何满足<i的位置，如果第下标l<=i位置满足s[l]=t[i],这样i位置可以由l位置更新得到，此时记录[l,i]区间，对于i-1,的更新一定由<l的位置得到。

处理好每一个s[i]满足等于t[i]由l位置更新。这个操作可以nlogn的做法得到。整个s => s<sup>'</sup> => t的操作次数就是$max_{i=1}^{n}$(i-l)

void solve()
{
    int n,k;cin>>n>>k;
    ve<ve<int>>MP(27);
    string s,t;cin>>s>>t;
    for(int i=0;i<n;i++) MP[s[i]-'a'].push_back(i);
    ve<pii>f;
    int ls=n-1;
    for(int i=n-1;i>=0;i--)
    {
        if(MP[t[i]-'a'].size()==0)
        {
            cout<<-1<<'\n';
            return ;
        }
        int id=upper_bound(MP[t[i]-'a'].begin(),MP[t[i]-'a'].end(),min(i,ls))-MP[t[i]-'a'].begin();
        id--;
        if(id<0) 
        {
            cout<<-1<<'\n';
            return ;
        }

        id=MP[t[i]-'a'][id];//值
        ls=min(ls,id);
        if(id<i) f.push_back({id,i});//id--->i;
    }
    int cha=0;
    for(int i=0;i<f.size();i++)
    {
        auto [l2,r2]=f[i];
        // cout<<l2<<" "<<r2<<'\n';
        cha=max(r2-l2,cha);
    }
    if(cha>k)
    {
        cout<<-1<<'\n';
        return ;
    }
    cout<<cha<<'\n';
    while(f.size())
    {
        ve<pii>h;
        for(auto [l,r]:f)  
        {
            // cout<<l<<" "<<l+1<<"\n";
            // swap(s[l],s[l+1]);
            s[l+1]=s[l];
            l++;
            if(l<r) h.push_back({l,r});
        }
        cout<<s<<'\n';
        f=h;
        // ends;
    }
    // ends;
}

E题

没看，并查集，重构树，最近公共祖先

待施工

冒泡排序

Thu, 18 Dec 2025 00:00:00 GMT

冒泡排序

为什么有这个呢，面经

oi wiki链接 https://oi-wiki.org/basic/bubble-sort/

冒泡排序原理

原理：

比较两个相邻的元素，符合要求（看自己的需求是从小到大，还是从大到小）即交换两个元素的位置。

算法步骤

比较相邻元素：从列表的第一个元素开始，比较相邻的两个元素。

交换位置：如果前一个元素比后一个元素大，则交换它们的位置。

重复遍历：对列表中的每一对相邻元素重复上述步骤，直到列表的末尾。这样，最大的元素会被"冒泡"到列表的最后。

缩小范围：忽略已经排序好的最后一个元素，重复上述步骤，直到整个列表排序完成。

模拟过程

假设有一个待排序的列表 [5, 3, 8, 4, 6]，冒泡排序的过程如下：

第一轮遍历：

比较 5 和 3，交换位置，列表变为 [3, 5, 8, 4, 6]。

比较 5 和 8，不交换。

比较 8 和 4，交换位置，列表变为 [3, 5, 4, 8, 6]。

比较 8 和 6，交换位置，列表变为 [3, 5, 4, 6, 8]。

第一轮结束后，最大的元素 8 已经"冒泡"到列表的最后。

第二轮遍历：

比较 3 和 5，不交换。

比较 5 和 4，交换位置，列表变为 [3, 4, 5, 6, 8]。

比较 5 和 6，不交换。

第二轮结束后，第二大的元素 6 已经"冒泡"到列表的倒数第二位置。

第三轮遍历：

比较 3 和 4，不交换。

比较 4 和 5，不交换。

第三轮结束后，列表已经有序。

第四轮遍历：

比较 3 和 4，不交换。

列表已经完全有序。

图解

![[冒泡排序示意图.gif]]

coding

对一个数组，排升序的冒泡排序代码

int a[N];
void solve()
{
    int n;cin>>n;
    for(int i=1;i<=n;i++) 
    {
        cin>>a[i];
    }

    for(int i=1;i<=n;i++)//进行n轮
    {
        for(int j=1;j<=n-i;j++)//每一轮进行 n-i次
        {
            if(a[j]>a[j+1]) swap(a[j],a[j+1]);//判断语句
        }
    }
    for(int i=1;i<=n;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<'\n';
}

例题

链接 https://www.luogu.com.cn/problem/P1271

![[Pasted image 20251108174527.png]]

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

nszkay

2026icpc河南省赛

2026ccpc河南省赛

My mac

My mac

📦 开发者基石：Homebrew

🛠️ 系统增强与效率工具

🎬 影音、办公与生产力

💻 开发者专区

🌐 社交、互联与网络

终端

zsh

2-1数论

格雷码 (相邻两个数字的二进制异或为二的次幂)

矩阵快速幂构造方法总结

1️⃣ 构造初始矩阵（Basic Matrix）

2️⃣ 构造转移矩阵（Transfer Matrix）

3️⃣ 计算第 n 项

4️⃣ 总结矩阵构造步骤

4-2数据结构2

数据结构(三)

Part 7.13 树链剖分

Part 7.14 树套树

Part 7.15 动态树

Part 7.16 可持久化数据结构

可持久化线段树(普通版本)

可持久化并查集

可持久化字典树

Part 7.17 K-D Tree

Part 7.18 珂朵莉树

4-1数据结构

数据结构

Part 7.1 链表

Part 7.2 栈

单调栈

Part 7.3 队列

单调队列

Part 7.4 并查集

普通板子封装(联通大小(点，边)，判断环)

Part 7.5 二叉堆

Part 7.6 ST表

Part 7.7 树状数组

5-1串

字典树

字典树(普通版本)

可持久化字典树

4-2数据结构

数据结构（二）

Part 7.8 线段树

线段树 （区间修改，区间覆盖）

权值线段树

动态开点线段树

Part 7.9 分块

Part 7.10 可并堆

Part 7.11 主席树

Part 7.12 平衡树

7-1图论

7-1 图论

树的直径

树的中心

树的重心

单源最短路(djstka)

多源最短路

最小生成树(并查集)

基环树

3-1数论

数论

欧拉筛(经典版本)

欧拉筛(最小质数筛)

质因子分解(O(n)筛法,O(logn)质因子分解 )

质因子分解解释

矩阵的转置 (横向变纵向，纵向变横向)

组合数( 快速幂+组合数+逆元预处理 O(n) )

✅ 问题形式：(能使用乘法逆元的前提)

扩展欧几里得exgcd

杨辉三角

杨辉三角模板题

0-0初始化

vscode 的设置操作

运行脚本文件

线段树（区间修改，区间覆盖）

2024ccpc区域赛郑州站