Qingw の Blog

ACM笔记

Qingw — Mon, 27 Apr 2026 20:32:00 GMT

开头

刷题的作用

知识点
思维
代码调试和实现
前期：知识点 > 思维, 代码实现 > 代码调试

训练方案

提高难度，借助题解刷题

知识

有体系（自底向上）
无体系（归纳法）

数学

异或

CF2225D 前缀异或和 $P(3mod4) = 0, P(1mod4) = 1$

异或线性基

给出一个数列 a1,a2,...,an，若一个序列 d1,d2,...,dk 满足以下性质：

所有原数列中的元素能够异或出来的值 d 中的数也能异或出来

d[i]中非零的个数就是这个线性空间的秩(线性无关的向量的个数)

P3812 最大值问题从高位到低位贪心异或
最小值问题
hdu3949第k小问题: 净化后的p数组, 二进制拆分
P3857异或和问题 $2^k\k为d[i]非零的个数$
P4570 贪心插入元素,动态查看能否被消掉 (极大线性无关组的个数是常数(秩))

鸠巢原理

有N + 1个可能，但是只有N个抽屉，那么必然至少有一个会有重复的

200_D

质数筛

任何一个合数都是可以整除比他小的一个质数

P5440 要判断一个数是否是质数，就要看$\sqrt{N}$的范围里的质数能不能整除
412_E 区间筛法，用小筛子去筛大数, 对于每个小质数，乘以倍数后把[L,R]里的合数筛掉,剩下的就一定是质数

矩阵加速

斐波那契 POJ-3070 $$ \begin{pmatrix} F_n F_{n-1} \end{pmatrix} \begin{bmatrix} 1&1\ 1 &0\ \end{bmatrix} $$
POJ-3233

$$ \begin{pmatrix} A_k&S_k \end{pmatrix} \begin{bmatrix} A&A\ 0&1\ \end{bmatrix}

\begin{pmatrix} A_{k+1}&S_{k+1} \end{pmatrix} $$

P1306 $gcd(f_i, f_j) = f_{gcd(i, j)}$ 斐波那契数列最大公因数性质

斐蜀定理

两个互质的数a和b

凑不出的最大整数为$S = a * b - a - b$, 在S之后的数都可以用a 和 b凑出来（用于路径压缩），所以大于S的路径直接变成S长度

路径压缩 P1052

概率论

逆元的计算（费马小定理（$n ^ {p-2}$ 前提是p是质数），扩展欧拉函数）：适用于求单点的逆元
逆元的预处理（阶乘预处理，再处理逆元）：适用于大范围的逆元
模类Z
组合数$C_n^m = \frac{n!}{m!(n-m)!}$

计算几何

扫描线

动态规划

定义dp数组 -> 初始化dp数组 -> 转移方程

DP数组的初始化

求方案数（初始化为-1）来看看是否算过
求最小值（初始化为1E9）
求最大值（初始化为-1E9）

线性DP

dp数组的思考 : 有足够的信息, 不会破坏无后效性

二维dp P2758
带状态的dp P1541乌龟棋
abc_418D

最长递增子序列

tails数组 --> tails[1] = 7 代表长度为2的LIS的最小结尾数字为7

P1020 找<= 序列用 upper_bound(>)，找<序列用 lower_bound(>=)

树上DP

套路：父节点的全集信息需要靠子节点的全集信息递归来返回

例题
- 树上背包
  - P12136 dp[u][val]定义为u能否凑出val的重量
  - P1273
  - **P201
- 树上DP
  - P1352
  - P1122
  - P2607 基环树"森林" --> 多个连通块，但每个连通块都只有一个基环树(一个环，环上的节点可以形成树)
  - P3177 树上染色 -- 边的贡献

数位DP

利用条件判断加递归

技巧
- 利用转字符串来的到数字的某一位
例题
- P2602

状压DP

dp[status][i] status == (1 << MAXN)，用位来表示每一个东西已经选了或者还没选(状态的子集状态)

例题
- 旅行商问题 P1433 P1171 列举mask从小到大
- 棋盘问题 P1896 P2704
- 老鼠吃奶酪 P1433

区间DP

小区间合并成大区间

一般允许$$O(n^3)$$的复杂度

[数字游戏]:(http://10.160.111.129/p/2873
P1775 石子合并

0-1背包

两个变量: 容量和价值，依次遍历每个物品，更新dp[容量] = std::max(价值1，价值2)， dp[i]数组定义是在容量为x的时候最大价值是多少，可以买或者不买来更新

410_E
P1776 0-n背包(需要打包操作, 要从小到大的打包)

数据结构

链表

P1996
P1160

带版本控制的链表(可持久化)

411_D

前缀和差分

二维前缀和公式 : a[i][j] = a[i][j] + a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1]

二维差分公式: d[x1][y1]++, d[x1][y2 + 1]--, d[x2 + 1][y1]--, d[x2 + 1][y2 + 1]++

410E 二维前缀和
abc_419D 差分数组

BIT

a[0011] 代表以3结尾，长度为1的区间和, a[0100]代表以4结尾，长度为4的区间和

维护可差分（可减性）信息（由两个大区间得到一个小区间）

单点修改 + 区间查询（维护原数组） P3374
1. 求逆序对 P1774
2. 树上逆序对 P3605
3. 离线查询 + 维护区间出现了几次 P1972 P4113
单点查询 + 区间修改（维护差分数组）P3368
区间查询 + 区间修改（维护D和Di）P3372
二维数组 + 单点修改 + 区间查询（维护二维数组）
二维数组 + 区间修改 + 区间查询（维护二维差分数组）P4514

DSU

408_E :求两点之间最小OR路径，维护连通性
Bailian-1182 **P1525 **拓展域并查集
hdu3038 hdu3635带权并查集, 相对位置...
P4185 并查集加离线海量查询
P2294 带权并查集

RMQ

对数组的范围静态查询，（最大值，最小值，最大公约数）

$$rmq[i][k]$$ 可以理解成管辖[i, i + (1 << k))的一个值

倍增思想：就是很大的区间分成一个较大的区间，然后剩下的区间再递归... P4155

线段树

区间查询 + 区间修改 + 一维数组 + （有组合律）

P3372 区间和
P13825 动态开点线段树

单调栈

找到阶段性的强者

例题
- 动态后缀最大值 P1198
- 求全0矩形的方案 P1950
- 求最大全0矩形 P4147

单调队列/滑动窗口

与普通的队列不同的是，这是一个双端队列

P1886 求一个窗口内的的最大值, 最小值
P1714 求不定长子段最大和（前缀和 + 滑动窗口）
P3957 二分答案 + [L, R]的单调队列 + 坐标离散
P1419 二分答案 + [L, R]的单调队列 + 前缀和

堆/优先队列

自动维护最小值，最大值，反悔贪心的关键数据结构

LCA（最近公共父节点）

作用：

求树上两点的距离

树上差分（点差分[diff[u]++,diff[v]++,diff[lca]--, diff[fa[lca]]]--，边差分 diff[u]++,diff[v]++,diff[lca]-2)

P3379 模板
P2680 , P9246边差分

算法

搜索

每个节点都是状态(位置，颜色......), 我们需要找到一条从起点到终点的有效边

暴力搜索 -> 剪枝叶(处理无效状态)
- P5294
- P1118 一维上的，从左到右选数问题
暴力搜索 -> 开dp数组(处理重复问题)
折半搜索(用空间换时间), 先把前半部分的结果存起来(DFS)
- 适用于一维上的选和不选求子集和, 然后$2^N会TLE但是2^{N/2}不会的数据范围$
- 时间: $2^N\to2^{N/2}+2^{N/2}\times log(2^{N/2})$
- 空间: $0 \to 2^{N/2}$
- P3067 折半搜索 + 掩码（表示集合状态）+ vector排序去重替代set
- P4799
- P5195 两段BFS
IDA*（带有深度限制的，带有估价函数剪枝的DFS)
- 适用范围是: 状态的分支太多会爆队列, 却要求最小步数
- POJ3134

分治法

把大问题分成两半，再递归合并

P1908 分治求逆序对
P3806 点分治

CDQ分治

倍增

P3509 滑动窗口 + 倍增跳跃

图论

DFS

父节点给子节点初始化信息，先操作，后递归

子节点给父节点更新消息，先递归，后操作

417E 派出一个哨兵来给我信息这条路可能通终点吗

BFS

多源BFS ABC_405_D

洪水填充

P1162
P1506

二分图

二分图最大匹配（匈牙利算法）: 二分图中每条边都是一对一的（没有公共节点）P3386

哈夫曼树

高频短码，低频长码，从底至上

P1090
P2168 K分支哈夫曼树，要挂空节点保证最后剩一个

dji算法

优先队列维护的是全局的最近的点

算法复杂度 $O(N + M)log(N)$ N+M是遍历了图中的所有点和边, logN是优先队列比较每个点

P3956 带颜色状态的Dij算法
P1126 机器人搬货物，要判断合法状态
[L2-001](https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=994805073643683840&page=1)dji模板加路上的状态维护
P2865 求次短路径(维护dist1和dist2, 一个最短一个次短)--> 拓展K短路（暂时不学）
P1266 分层图dij, 带一个速度状态的dij
P5304 多源dij + 染色法, 用于求某个点距离该集合最近的距离和点

floyd

求全局任意两点的最短路, $O(n^3)$

剪枝很重要，很有可能不剪枝过不了hdu_1704

// abc_416_E 动态增加新路 O(n^2)
dist[i][j] = std::min({dist[i][j],
                       dist[i][x] + dist[x][y] + dist[y][j],
                       dist[i][y] + dist[y][x] + dist[x][j]});

hdu_1385 floyd维护最短路径(1->2->3...)，利用nxt[i][j]数组, 拓展: nxt[i]可以用于dijiskra算法的单源最短路径
P1119 按照时间顺序来写中转点来更新dist
P1913 floyd前要先倍增建图
hdu_1704 把dist[i][j]想成i和j的关系, 他们之间可以通过中转点K来确定另一个关系,统计答案的时候不要重复统计
P1730 初始化floyd的时候多加一个维度f[i][j][k]表示i到j经过了k条边的最大路径和

spfa

用来判断图中是否有负环,初始的时候要把所有点入队(防止图不连通), 所有dist都为0

如果没有负环, 起始节点到目标节点的走过的边数应该是<= V - 1(整个图的总点数)

如果是从0号点出发,则其他的dist应该为INF(这种是求最短路顺便判断负环)

算法复杂度: 最坏是$O(NM)$ 菊花图

P5960 差分约束，判断负环存在
P2868 二分计算边的权重，spfa判负环
P3385 单点可到达的负环
P2294 差分约束

johnson

求全源最短路 $O(NMlog(M))$

先用spfa求势能,再跑n个dij算法

P5905

tarjan

SCC: 强连通分量, 一个有向子图(不是树)中任意两个点连通

$dfn_n$: dfs顺序遍历的编号

$low_n$ : u为根的子树的所有节点能够到达的最小dfn序

割边: 如果删掉这条边, 图中的连通块(分量)变多

割点: 如果删掉这个点, 图中的连通块(分量)变多

割边 P1656
割点 P3388

字符串

马拉车

解决回文问题

KMP

找到S1中的S2的位置 , $S_2 \in S_1$

$nxt$数组是在[0, i)的前缀中的最长公共前后缀

$n-nxt[n] == x$ 则$s[i] == s[i+x]$ 则x为最小循环字串的大小

字符串哈希

判断字符串是否相等

字典树（前缀树）

记录多个字符串的前缀

维护字符串的字典树
0-1 Trie 求路径最大异或和 P4551

杂项

CF思考角度

从局部思考推到整体

CF2225B 把l和r影响的是局部和其他, 内部不影响, 外部最后影响两个冲突

旋转操作

顺时针90° $(i, j) \to (j, N-1-i)$
逆时针90°$(i, j) \to (N-1-j,i)$

// 顺时针
vector<string> ns(n);
for (int i = N - 1; i >= 0; --i) {
    for (int j = 0; j < N; ++j) {
        ns[j] += s[i][j]; 
    }
}
// 从最后一行向上从左到右发牌
// 1 2 3       7 4 1
// 4 5 6 ====> 8 5 2
// 7 8 9       9 6 3

// 逆时针
vector<string> ns(n);
for (int i = 0; i < N; ++i) {
    for (int j = 0; j < N; ++j) {
        ns[N - 1 - j] += s[i][j];  
    }
}

// 
// 1 2 3      3 6 9
// 4 5 6 ===> 2 5 8
// 7 8 9      1 4 7

位运算

// 取一位数n的最高位1的位置
int high_bit = 63 - __builtin_clzll(n);
// 制作一个数前i位都是1 (11111100000)
-(1 << i) + 1;
// 取一个数的最小的一位1
x & -x
// 取x的第i位
(x >> i) & 1
// 取反x的第i位
x ^= (1 << i)
// 将x的第i位取0
x &= ~(1 << i)

408E 通过贪心求最小或和

贪心

反悔贪心

在一维数组上进行要或者不要（这个值），带有前缀条件，用优先队列

先无脑入队列

例题
- 407_e
- **P30

最大子段和

Kadane 算法：通过维护历史最值来判断是继续加，还是清零

普通的Kadane算法P1719
环形Kadane算法**P1121*

破环成链

P2629
P4155 断环成链后，寻找覆盖区间超过环的连续区间就OK了

如何调代码

#include <bits/stdc++.h>
#define _CLR_CYAN   "\033[1;36m"
#define _CLR_GREEN  "\033[1;32m"
#define _CLR_RESET  "\033[0m"
using i64 = long long;
using i128 = __int128;
inline std::ostream& operator<<(std::ostream& os, __int128 n) {
    if (n == 0) return os << "0";
    if (n < 0) { os << "-"; n = -n; }
    std::string s;
    while (n > 0) { s += (char)('0' + (n % 10)); n /= 10; }
    std::reverse(s.begin(), s.end());
    return os << s;
}

template <typename T>
void dbg_out(const T& val) { std::cerr << val; }

template <typename A, typename B>
void dbg_out(const std::pair<A, B>& p) { std::cerr << '(' << p.first << ", " << p.second << ')'; }

template <typename T>
requires requires(T t) { t.begin(); t.end(); }
void dbg_out(const T& v) {
    std::cerr << '[';
    bool first = true;
    for (const auto& x : v) {
        if (!first) std::cerr << ",";
        first = false;
        dbg_out(x);
    }
    std::cerr << ']';
    std::cerr << "Total:" << v.size() << '\n';
}
template <typename T, std::size_t N>
void dbg_out(const T (&a)[N]) {
    std::cerr << '[';
    for (std::size_t i = 0; i < N; ++i) {
        if (i > 0) std::cerr << ",";
        dbg_out(a[i]);
    }
    std::cerr << "]";
    std::cerr << "Total:" << N << '\n';
}
template <typename T>
requires requires(T t) { t.begin(); t.end(); }
void dbg_out_range(const T& v, int L, int R) {
    std::cerr << '[';
    bool first = true;
    auto it = std::next(v.begin(), L);
    for (int i = L; i < R && it != v.end(); ++i, ++it) {
        if (!first) std::cerr << ",";
        first = false;
        dbg_out(*it);
    }
    std::cerr << "]";
    std::cerr << "Range: [" << L << ", " << R << "), Total: " << v.size() << '\n';
}
template <typename T, std::size_t N>
void dbg_out_range(const T (&a)[N], int L, int R) {
    std::cerr << '[';
    for (int i = L; i < R && i < (int)N; ++i) {
        if (i > L) std::cerr << ",";
        dbg_out(a[i]);
    }
    std::cerr << "]";
    std::cerr << "Range: [" << L << ", " << R << "), Total: " << N << "\n";
}
#define debug(x) \
    std::cerr << _CLR_CYAN << "[" << #x << "]" << _CLR_RESET << '\n'; \
    std::cerr << _CLR_GREEN; dbg_out(x); std::cerr << _CLR_RESET << '\n';

#define debug_range(x, L, R) \
    std::cerr << _CLR_CYAN << "[" << #x << "]" << _CLR_RESET << '\n'; \
    std::cerr << _CLR_GREEN; dbg_out_range(x, L, R); std::cerr << _CLR_RESET << '\n';

int 与 int 相乘会溢出，应该转为i64

字符串的stl操作

string text;
text.find(word, pos) // ==> string::npos;
text.replace(pos, len, str)

    // 输入
    std::cin // 会留下一个换行符, 忽略空格换行符
    std::cin.ignore(); // 吃掉一个字符
    std::cin.get(c)
    std::getline(std::cin, s); // 读取,直到换行符,会吃掉换行符

	// 标准流程(读取多行字符串)是
	int n;
	std::cin >> n;

	// 坚决清空第一行数字后面的所有残留物
	std::string dummy;
    std::getline(std::cin, dummy); 

    for (int i = 0; i < n; ++i) {
        std::string s;
        std::getline(std::cin, s); // 干净清爽地读取每一行
        // 处理字符串 s ...
    }

天梯赛的阴函数

// 补全前导零
os << std::setfill('0') // 全局有效i
os << std::setw(5) // 只对后面一个数有效

sort的元素满足传递性

P2123 中我们可以通过sgn(x) 来比较 $min(a_1,b_2) 与 min(a_2, b_1)$,

较难知识点

ABC_454G --> DSU on tree

不想更新了

Qingw — Sat, 17 Jan 2026 19:07:00 GMT

OK呀，本人感觉更新太费时间了，准备停止更新

Hello2026

Qingw — Thu, 08 Jan 2026 14:08:00 GMT

import ProblemCard from '../../components/ProblemCard.astro';

新年第一赛ABC做了, 记录一下

A Binary Array Game

题目概述

给你一个数组$a$, 这个数组$a$里只有0和1

Alice和Bob可以执行两个操作之一, Alice先走

选择$a_l$到$a_r$删除并替换为一个数字$1 - min(a_l...a_r)$

求谁会赢?（只剩下一个数字，如果是0 Alice赢，如果是1 Bob赢

题目分析

只要$a_l-a_r$有0, 替换后就为1

Alice想赢就得把数组变为全1

起始数组为11111111，那么Alice赢

起始数组为1xxxxxxxx, 因为x中有0，所有我们选择$a_2, a_n$，就变成了11 Alice赢

起始数组为xxxxxxxx1，选择$a_1, a_{n-1}$, 就变成了11 Alice赢

起始数组为0xxxxxxx0, Alice操作后肯定是0xxxxxxx, Bob直接选择$a_2, a_n$ 就变成了1 Bob赢

const int MAXN = 101;
int a[MAXN];
void solve() {
    int n; cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    if (a[1] || a[n]) cout << "Alice\n";
    else cout << "Bob\n";
}

B

题目概述

给你一个数组$a$，长度$n$，一个窗口长度为$k$， $f(l,r) = mex(a_l, a_r)$^1

你每次选择$mex$最大的窗口并且在这个窗口里删除一个数

求最后$a$只剩$k-1$长度时，最大的$mex(a)$

题目分析

我们需要尽可能保护$a$中的$0,1,2...k-2$

答案为$max(mex(a), k-1)$

const int MAXN = 2e5 + 1;
int a[MAXN];
void solve() {
    int n, k; cin >> n >> k;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    sort(a + 1, a + 1 + n);
    int e = unique(a + 1, a + 1 + n) - a - 1;
    int ans = e;
    for (int i = 1; i <= e; ++i) {
        if (i - 1 != a[i]) {
            ans = i - 1;
            break;
        }
    }
    ans = min(k - 1, ans);
    cout << ans << endl;

C War Strategy

题目概述

给n,m,k

n代表数组长度， m代表限制天数， k代表起始大本营

每天可以执行操作

a_i的士兵部分或全部的移动一个单位

a_k的士兵加1

问在m天内，怎么让数组上士兵不为空的格子最多?

题目分析

我们先分析拓展一边

$3, \underbrace{2,1}{d_2 = 2}0 \underbrace{1,2,3}{d1=3}$

其中0代表大本营, 我们怎么让给定d1，使得运输的时间最短?-- 当然是先屯兵，再一起走

$t_{d_1} = t_{屯兵} + t_{行军}= d_1 + d_1 - 1 =2d_1-1$

我们发现了一件事情, 在行军的过程中大本营也在屯兵

$t_{d_2} = t_{屯兵} + t_{行军} = max(0, d_2 - d_1) + 1 + d_2 - 1 == max(0, d_2-d_1)+d_2$

可得:

$t_d = t_{d_1} + t_{d_2} = 2d_1 + d_2 - 1 + max(0, d_2-d_1)$

我们定$d_2 < d_1$ 则$t_d = 2d_1 + d_2 - 1$

为了让$t_d\leq m & d_1 + d_2最大$

我们要让$d_2$尽可能大，看循环部分的代码

int n, m, k;
void solve() {
    cin >> n >> m >> k;
    int mx = max(k - 1, n - k);
    int mn = min(k - 1, n - k);
    int ans = 0;
    for (int d2 = 0; d2 <= mn; ++d2) {
        for (int d1 = mx; d1 >= d2; --d1) {
            if (d2 + 2 * d1 - 1 <= m) {ans = max(ans, d1 + d2 + 1); break;}
        }
    }
    cout << ans << endl;
}

rt1500

Qingw — Sun, 04 Jan 2026 20:55:00 GMT

import ProblemCard from '../../components/ProblemCard.astro';

个签

Qingw — Sat, 03 Jan 2026 23:04:00 GMT

随风潜入夜
可乐

nvim快捷键

Qingw — Sat, 03 Jan 2026 18:13:00 GMT

回退时间撤销

:earlier 10s
:earlier 10m
:later 10m
:later 10s

rt1400

Qingw — Fri, 02 Jan 2026 22:49:00 GMT

import ProblemCard from '../../components/ProblemCard.astro';

D Epic Transformation

题目描述

给一个数组a, $a_1,a_2...a_n$

每次选择两个不同的$a_i,a_j$删除，求最后的数个数最小多少

思路分析

找到最多的数(有x个), 如果$x > \frac{n+1}{2}$ ,答案就是$x - (n - x) == 2x-n$

否则n是奇数答案为1， n是偶数答案为0

void solve() {
    int n; cin >> n;
    int z = 0;
    map<int,int> m;
    for (int i = 1; i <= n; ++i) {
        int x; cin >> x;
        m[x]++;
        z = max(z, m[x]);
    }
    if (2 * z > n) cout << (2 * z - n) << "\n";
    else cout << (n % 2) << "\n";
}

E Arranging The Sheep

题目描述

给一个字符串**.**..**之类的，每次可以让*向右边或者左边移动一格(如果左边或者右边是.)，求移动次数最少可以让*全部挨在一起

思路分析

先假设第i个*是标准，那么1 ~ i-1的*j要向右走x - (i - j)

如果我们枚举每头🐏然后再计算每头🐏的举例就是$O(n^2)$直接TLE

根据数学中位数，可以知道数列中到中间的数的距离和是最短的

举个例子: 1 4 5 7 10

1 : 3 + 4 + 6 + 9 = 22

4 : 3 + 1 + 3 + 6 = 13

5 : 4 + 1 + 2 + 5 = 12

7 : 6 + 3 + 2 + 3 = 14

10: 9 + 6 + 5 + 3 = 23

怎么证明? 当x小于中间数时, 他向右移动, 右边的数$t* (n - x)$少走加入t步, 左边的数就多走$t*(x-1)$步, 总和就会变小, 同理当x大于中间数

向左走的时候总和变小

void solve() {
    int n; cin >> n;
    int cnt = 0;
    for (int i = 1; i <= n; ++i) {
        char c;
        cin >> c; 
        if (c == '*') {
            a[++cnt] = i;
        }
    }
    if (cnt == 0) {cout << "0\n"; return;}
    ll ans = 0;
    int mid = (cnt + 1) / 2;
    for (int i = 1; i <= cnt; ++i) {
        ans += abs(a[i] - a[mid] - (i - mid));
    }
    cout << ans << "\n";
}

C Dominant Charcter

题目描述

有一个字符串s, 仅仅由abc三个字符（都是可有可无的）组成, 求s的字串中满足$cnt_a > cnt_b & cnt_a > cnt_c$ 的个数

思路分析

找到一个最小元字串满足题意, 其他任意字串可以由元字串来拼凑

1 ： a 1+0+0

2 : aa 2+0+0

3 : aaa aba aca 2+1+0

4: abca acba 2+1+1

5: ababa acaca 3+2+0

6: abbaca accaba 3+2+1

7: abbacca 3+2+2

void solve() {
    int n; cin >> n;
    string s; cin >> s;
    int ans = 1e9;
    for (uint i = 0; i < s.size(); ++i) {
        int cnt[3] = {0};
        for (int k = 0; k < 7; ++k){
            if (i + k >= s.size()) break;
            cnt[s[i+k]-'a']++;
            if (k >= 1 && cnt[0] > cnt[1] && cnt[0] > cnt[2]) {
                ans = min(ans, k+1);
                break;
            }
        }
    }
    cout << (ans == 1e9 ? -1 : ans) << "\n";
}

B I hate 1111

题目分析

一个整数n能否被11, 111, 1111, 11111....相加得到?

思路分析

发现1111 = 11 + 111 * 10

11111 = 1111 * 10 + 11

所以元整数是11和111

$n=11x+111y$

因为11个111可以换成111个11，所以我们只需要列举0~10个111看看是否有解

void solve() {
    int n; cin >> n;
    for (int i = 0; i <= 10; ++i) {
        if (n - i * 111 >= 0 && (n - i * 111) % 11 == 0){
            cout << "YES\n";
            return;
        }
    }
    cout << "NO\n";
}

B2 Wonderful Coloring - 2

题目分析

有一个数组$a_1,a_2,a_3....a_n$, 有$k$种颜色

要求:

一个颜色涂的格子不能有相同值

让所有涂色的格子的总值尽可能高

思路分析

解法一: 一个链式前向星存储每种值+ 他们的位置, 然后我们从最大值开始涂色，限制同一个值不能涂色超过k次, 桶排序

解法二: 用vector存储每种值加位置，然后也是从最大值涂色.....

const int MAXN = 2e5 + 1;
int head[MAXN], pos[MAXN], nxt[MAXN], tot;
int c[MAXN];
int n, k;
void init() {
    for (int i = 1; i <= n; ++i) {head[i] = -1; c[i] = 0;}
    tot = 0;
}
void insert(int val, int p) {
    ++tot;
    pos[tot] = p;
    nxt[tot] = head[val];
    head[val] = tot;
}
void solve() {
    cin >> n >> k;
    init();
    int mx_val = 0;
    for (int i = 1; i <= n; ++i) {
        int v; cin >> v;
        insert(v, i);
        mx_val = max(v, mx_val);
    }
    vector<int> paint;
    for (int i = mx_val; i >= 1; --i) {
        if (head[i] == -1) continue;
        int count = 0;
        for (int j = head[i]; j != -1; j = nxt[j]) {
            if (count < k) {
                paint.push_back(pos[j]);
                count++;
            }
        }
    }
    int painted = paint.size() / k * k;
    for (int i = 0; i < painted; ++i) c[paint[i]] = i % k + 1;
    for (int i = 1; i <= n; ++i) cout << c[i] << " ";
    cout << "\n";
}

Goodbye2025

Qingw — Fri, 02 Jan 2026 18:14:00 GMT

import ProblemCard from '../../components/ProblemCard.astro';

Goodbye2025

C. First or Second

题目描述

给一个数组a, 每次从a的第一个或者第二个选择一个数$a_i$, 如果是第一个数则$X + a_i$否则$X - a_i$

求X的最大值(当a只剩下一个数的时候停止)

思路分析

反向思考：来列举剩下的$a_i$

我们可以发现 : $a_i$的右边一定是被$-a_i$的(可以用suf后缀和优化)，左边可能是$+a_i$也可能是$-a_i$(除了第一个肯定是+)

我们需要列举每个剩下的$a_i$然后求最大值

void solve() {
	int n; cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    suf[n + 1] = 0;
    for (int i = n; i >= 1; --i) {
		suf[i] = suf[i+1] - a[i];
    }
    ll ans = -1e9, pre = 0;
    for (int i = 1; i <= n; ++i) {
		ans = max(ans, pre + suf[i + 1]);
       	if (i == 1) pre += a[i];
        else pre += abs(a[i]);
    }
    cout << ans << "\n";
}

D. Xmas or Hysteria

题目描述

有n个精灵，他们有$a_i$的生命和攻击力, 我们需要在X个回合后仍然需要m个精灵存活, 是否存在一个迭代序列满足条件? (迭代: 当所有存活的精灵都主动攻击后才会停止，一个迭代指的是A攻击B， $h_a\to{h_a-a_b} h_b\to{h_b-a_a}$)，每个精灵的$a_i$都不同(distinct)

思路分析

因为一次攻击至少死一个精灵，所以迭代最多是$\lfloor{\frac{n}{2}}\rfloor$, 存活的精灵最多是$\lfloor{\frac{n}{2}}\rfloor$

把精灵按照攻击力从低到高排序

分类讨论m :

m > $\lfloor{\frac{n}{2}}\rfloor$ 不合法

m = 0 : 所有人攻击最大的看看有没有可能干死他，如果可以，我们看看是第i个干死他，然后剩下的精灵就按照链式送死个第i个，然后i再取干最大的

m > 0 : 我们让 1 ~ n - 2(m-1)的精灵只剩下一个, n - 2(m-1)+1 ~ n的精灵剩下m-1, 这样就有m个了

array<int, 2> a[MAXN];
void solve() {
	int n, m; cin >> n >> m;
    if (m > n / 2) {
        cout << "-1\n";
        return;
    }
    for (int i = 1; i <= n; ++i) cin >> a[i][0], a[i][1] = i;
    sort(a + 1, a + 1 + n);
    vector<array<int, 2>> ans;
    if (m == 0) {
        ll total = 0;
        for (int i = 1; i <= n - 1; ++i) total += a[i][0];
        if (total < a[n][0]) {
            cout << "-1\n";
            return;
        }
        for (int i = n-1; i >= 1; --i) {
			a[n][0] -= a[i][0];
            if (a[n][0] <= 0) {
                for (int j = 1; j < i; ++j) {
                    ans.push_back({a[j][1], a[j+1][1]});
                }
                ans.push_back({a[i][1], a[n][1]});
                break;
            }
            ans.push_back({a[i][1], a[n][1]});
        }
        
    }else {
        for (int i = 1; i <= n - 2*(m - 1)-1; ++i) { // 贡献一个精灵
            ans.push_back({a[i+1][1], a[i][1]});
        }
        for (int i = n - 2*(m-1) + 1; i <= n-1; i += 2) { // 贡献m-1个精灵
			ans.push_back({a[i+1][1], a[i][1]});
        }
    }
    cout << ans.size() << "\n";
    for (auto [x, y] : ans) cout << x << " " << y << "\n";
}

Qingw の Blog

ACM笔记

开头

刷题的作用

训练方案

知识

数学

异或

异或线性基

鸠巢原理

质数筛

矩阵加速

$$ \begin{pmatrix} A_k&S_k \end{pmatrix} \begin{bmatrix} A&A\ 0&1\ \end{bmatrix}

斐蜀定理

概率论

计算几何

扫描线

动态规划

DP数组的初始化

线性DP

最长递增子序列

树上DP

数位DP

状压DP

区间DP

0-1背包

数据结构

链表

带版本控制的链表(可持久化)

前缀和 差分

BIT

DSU

RMQ

线段树

单调栈

单调队列/滑动窗口

堆/优先队列

LCA（最近公共父节点）

算法

搜索

分治法

CDQ分治

倍增

图论

DFS

BFS

洪水填充

二分图

哈夫曼树

dji算法

floyd

spfa

johnson

tarjan

字符串

马拉车

KMP

字符串哈希

字典树（前缀树）

杂项

CF思考角度

从局部思考推到整体

旋转操作

位运算

贪心

反悔贪心

最大子段和

破环成链

如何调代码

字符串的stl操作

天梯赛的阴函数

sort的元素满足传递性

较难知识点

不想更新了

Hello2026

A Binary Array Game

B

C War Strategy

rt1500

个签

前缀和差分