算法 on 蛋蛋忧桑

ST稀疏表 (Sparse Table)

Wed, 20 Aug 2025 15:23:59 +0800

稀疏表常用于解决RMQ问题（区间最大/小值查询问题），稀疏表仅支持高效的查询操作，并不支持动态修改操作。其实现主要基于倍增思想和动态规划。

稀疏表最主要的思想就是将区间分为两个子区间，例如[l,r]分成[l,l+2^k-1]和[r-2^k+1,r]，其中k=log2(r-l+1)向下取整。

其本质上就是用两个长度为 2^k 的重叠区间覆盖 [l,r]，那我们查询区间最值就可以分解为两个子区间最值中的较大/小值，即max[l,r]=max(max[l,l+2^k-1],max[r-2^k+1,r])。

我们用二维数组构造稀疏表，大小为f[N][log2(N)+1]，其中f[i][j]=max[i,i+2^j-1]，状态转移方程为f[i][j]=max(f[i][j-1],f[i+2^(j-1)][j-1]);

vector dt(N);
vector> f(N,vector(log2(N)+1));

void init(int n){
 for(int i=0;i<n;i++) f[i][0]=dt[i];
 for(int j=1;(1<<j)<=n;j++){
 for(int i=0;i+(1<<j)-1<n;i++){
 f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
 }
 }
}

int query(int l,int r){
 int k=log2(r-l+1);
 return max(f[l][k],f[r-(1<<k)+1][k]);
}

算法设计与分析：要点总结-3

Mon, 28 Apr 2025 10:11:52 +0800

贪婪算法（Greedy Algorithm）

1. 基本思想

每一步都做当前看来最优的选择（即局部最优），希望通过一系列局部最优，达到整体最优。
特点是只顾眼前（每次选择最优），不回溯。

2. 贪婪问题分类

绝对贪婪问题：

每一步的局部最优选择，最终一定得到全局最优解。

例子：活动安排问题、最小生成树问题。
相对贪婪问题：

贪婪算法得到的解不是全局最优，但通常是一个近似最优（有时足够好了）。

例子：一些NP问题的贪婪近似，比如旅行商问题的贪婪解。

贪婪算法与问题复杂性

P问题：可以在多项式时间内求解的问题（即存在有效算法）。
NP问题：能在多项式时间内验证一个解是否正确，但不一定能快速求解。
贪婪算法通常用于P问题或NP问题的近似解。
有效算法：

运行时间是问题规模的多项式函数，比如 O(n^2), O(nlog⁡n)。

相对的，指数时间 O(2^n)算法就不是有效算法。

经典例题

1. 工资分发问题（类似找零问题）

题意：用最少数量的钱币发工资。
解法：每次选面额最大且不超过剩余金额的钱币。
注意：有些面额组合下贪心策略不一定最优（比如奇怪的硬币系统）。

2. 活动安排问题

题意：给定若干活动，每个活动有开始、结束时间，要求安排最多不重叠活动。
贪心策略：优先选结束时间最早的活动。

3. 多机调度问题

题意：n个任务分配到k台机器，使得最晚完成时间最早。
贪心策略：每次将任务分配到当前负载最轻的机器上。

重要贪婪算法

1. Huffman树构造（最优编码问题）

题意：给定字符及其出现频率，设计编码使总编码长度最短。
方法：

每次选取出现频率最小的两个节点合并。

最后生成哈夫曼树。

2. 单源最短路径：Dijkstra算法

适用于边权非负的图。
思路：

维护一张最短距离表。

每次选取当前未访问、距离源点最短的点，更新它的邻居。

3. 最小生成树

Prim算法：

从任意点开始，逐步将最近的点连入生成树。

Kruskal算法：

把边按权值从小到大排序，逐条选边，如果不会成环就加入生成树。

用并查集快速判断成环。

算法设计与分析：要点总结-2

Mon, 21 Apr 2025 00:36:48 +0800

分治算法

分治思想：分治算法是一种将一个复杂问题分解成多个较小的子问题，通过递归解决子问题，再将子问题的解合并起来，得到原问题的解。分治思想的核心是通过将问题规模减小、分解和组合来简化问题的解决。

分治算法的基本步骤：

分解：将问题划分为多个规模较小、结构与原问题类似的子问题。
解决：递归地解决这些子问题，当子问题的规模足够小或问题简单时，可以直接求解。
合并：将子问题的解合并成原问题的解。

减治算法：减治算法是分治算法的一种特殊形式，它也将问题分解成多个子问题，但在减治算法中，通常没有合并步骤。每次递归都是通过缩小问题规模来直接逼近解决方案，典型的例子是 归纳法 和 动态规划。

二分法

什么是二分法：二分法是一种通过将问题的解空间不断对半分割，逐步缩小搜索范围的算法。通常用来解决有序数据的查找问题。二分法的典型例子是 二分查找，其基本思想是通过比较目标值和中间元素来决定查找区间，逐步缩小查找范围。

二分法变异：二分法变异是对传统二分法的扩展或修改，常见的变异包括：

变异1：处理不完全有序的情况（例如，寻找最左或最右的目标元素）。
变异2：用于解决更复杂的决策问题，比如 最小最大值问题 或 区间问题。

为什么需要变异二分法：传统二分法只适用于简单的查找问题，但在实际应用中，经常遇到更复杂的情况，如：

查找某个值的最左或最右位置。
求解某个条件成立的最小/最大值。
寻找某个阈值条件下的解空间。

这些问题需要对标准二分法进行适当变异，以适应更复杂的需求。

重要例题

金块问题：

问题：给定一个二维矩阵，其中每个位置都有金块，如何找到从左上角到右下角的最大金块数？你可以在矩阵中上下左右移动。

引出结论：通过分治，将问题分解成子问题，利用动态规划的思想来求解最大值。
残缺棋盘问题：

问题：给定一个 2^n x 2^n 的棋盘，其中一个小方块被去除，如何将其余部分覆盖上 L 型小块？

引出结论：这是一道典型的分治问题，通过递归分割棋盘并覆盖，可以有效地解决。
循环赛日程表：

问题：有 n 个队伍，如何安排一个循环赛程，使得每个队伍与其他队伍比赛一次？

引出结论：通过分治，将问题划分为较小的子问题，求解比赛安排。
最大子段和问题：

问题：给定一个整数数组，求出其中和最大的连续子数组。

引出结论：这道题目可以通过分治的方式进行求解，分解成较小的子问题，最终合并求得最大子段和。

重要算法

冒泡排序

时间复杂度：O(n^2)
空间复杂度：O(1)
特点：通过多次遍历，将最大（或最小）元素“冒泡”到数组的一端。适合小规模数据。

def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 for j in range(0, n-i-1):
 if arr[j] > arr[j+1]:
 arr[j], arr[j+1] = arr[j+1], arr[j]
 return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("冒泡排序结果:", bubble_sort(arr))

插入排序

时间复杂度：O(n^2)
空间复杂度：O(1)
特点：通过从未排序的部分插入元素到已排序部分，逐步扩大已排序部分。

def insertion_sort(arr):
 for i in range(1, len(arr)):
 key = arr[i]
 j = i - 1
 while j >= 0 and arr[j] > key:
 arr[j + 1] = arr[j]
 j -= 1
 arr[j + 1] = key
 return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("插入排序结果:", insertion_sort(arr))

快速排序

时间复杂度：O(n log n)（平均），O(n^2)（最坏）
空间复杂度：O(log n)（平均）
特点：通过选择一个基准元素，将数组分为两个部分，递归地对每个部分进行排序。效率较高。

def quick_sort(arr):
 if len(arr) pivot]
 return quick_sort(left) + middle + quick_sort(right)

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("快速排序结果:", quick_sort(arr))

归并排序

时间复杂度：O(n log n)
空间复杂度：O(n)
特点：通过递归地将数组分成两个子数组，然后合并排序。稳定且适用于大规模数据。

def merge_sort(arr):
 if len(arr) > 1:
 mid = len(arr) // 2
 left_half = arr[:mid]
 right_half = arr[mid:]

 merge_sort(left_half)
 merge_sort(right_half)

 i = j = k = 0
 while i < len(left_half) and j < len(right_half):
 if left_half[i] < right_half[j]:
 arr[k] = left_half[i]
 i += 1
 else:
 arr[k] = right_half[j]
 j += 1
 k += 1

 while i < len(left_half):
 arr[k] = left_half[i]
 i += 1
 k += 1

 while j < len(right_half):
 arr[k] = right_half[j]
 j += 1
 k += 1
 return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("归并排序结果:", merge_sort(arr))

算法竞赛读入数据相关操作

Sat, 05 Apr 2025 02:08:01 +0800

读入带空格的字符串

char str[1024];
scanf("%[^\n]",&str); // 读取到'\n'为止，不读入'\n'
getchar(); // 清除'\n'

int num;
string str;
cin >> num; // 读取数字
cin.ignore(); // 跳过数字后的'\n'
getline(cin, line); // 读取整行输入,包括换行符'\n'，但'\n'不会存储在 line 中。

循环读入

// 快速读取整数（C风格）
int num;
while (scanf("%d", &num) != EOF) { ... }

// 逐字符读取
char ch;
while ((ch = getchar()) != EOF) { ... }

int num;
string line;

// 读取数字
while (cin >> num) { ... }

// 读取行
while (getline(cin, line)) { ... }

快读

int read() {
 int x = 0, f = 1;
 char ch = getchar();
 while (ch '9') { if (ch == '-') f = -1; ch = getchar(); }
 while (ch >= '0' && ch 
- **`%[abc]`**：只读取 `a`、`b` 或 `c`，遇到其他字符停止。

- **`%[^abc]`**：读取直到遇到 `a`、`b` 或 `c` 为止。

- **`%[^\n]`**：读取整行（直到 `\n`，但不包括 `\n`）。c复制char str[100]; scanf("%[^\n]", str); // 读取一行（不含换行符） getchar(); // 吃掉残留的 \n**注意**：`%[^\n]` 不会自动限制长度，容易缓冲区溢出，建议用 `%99[^\n]` 限制。

```cpp
char str[100];
scanf("%[^\n]", str); // 读取一行（不含换行符）
getchar(); // 吃掉残留的 \n

**(2) 跳过输入 `%*`**

%*d：读取但不存储整数（跳过该输入）。

int a, b;
scanf("%d %*d %d", &a, &b); // 输入 "1 2 3"，a=1, b=3（跳过 2）

(3) 宽度限制 `%Ns`

%5s：最多读取 5 个字符（防止缓冲区溢出）。

char name[10];
scanf("%9s", name); // 最多读 9 个字符（留 1 位给 '\0'）

(4) 混合输入数字和字符串

scanf 不会自动跳过空白字符（如 \n、），需要手动处理：

int a;
char c;
scanf("%d", &a); // 读取整数
scanf(" %c", &c); // 注意前面的空格，跳过空白符

(5) 检测输入结束（EOF）

scanf 返回成功读取的变量个数，EOF 表示输入结束：

int num;
while (scanf("%d", &num) != EOF) {
 // 处理 num
}

`printf` 的高级用法

(1) 格式化输出

格式	作用	示例	输出
%5d	固定宽度 5 位（右对齐）	printf("%5d", 123);	123
%-5d	固定宽度 5 位（左对齐）	printf("%-5d", 123);	123
%05d	不足 5 位补 0	printf("%05d", 123);	00123
%.2f	保留 2 位小数	printf("%.2f", 3.14159);	3.14
%x / %X	十六进制（小写/大写）	printf("%x", 255);	ff
%o	八进制	printf("%o", 8);	10
%p	指针地址	printf("%p", &a);	0x7ffd…

(2) 动态指定宽度/精度

用 * 动态传入宽度或精度：

int width = 5, precision = 2;
printf("%*.*f", width, precision, 3.14159); // 输出 " 3.14"

(3) 输出 `%` 符号

用 %% 输出 %：

printf("Success rate: 100%%"); // 输出 "Success rate: 100%"

(4) 打印字符串（限制长度）

%.5s：只打印前 5 个字符：

printf("%.5s", "Hello World"); // 输出 "Hello"

(5) 对齐 + 填充

左对齐 + 填充 -：

printf("%-10s", "Hello"); // 输出 "Hello "

右对齐 + 填充 0：

printf("%05d", 42); // 输出 "00042"

【转载】赛前小记 | 往期视频总结

Mon, 31 Mar 2025 22:53:22 +0800

原文链接：https://rentry.org/5p2wa89m/edit

首先是蓝桥杯的注意事项：

比赛前试好鼠标、键盘等设备，有问题要举手告诉监考老师

先想清楚思路怎么做再写代码，防止题目读假了。
请将题目通读完以后，再开始深入思考开始写你认为最容易的一道题。
为了方便，可以使用万能头文件 **#include **
一维 int 型数组记最大可以开到 1e7 。
C++ 一秒最多 5e8 次，建议记成 1e8 — 1e9，java py？

如果不会做了想暴力枚举的话，每题1s的限时，所以暴力枚举两个for嵌套，每个for最多可以运行10000次，三个for嵌套，每个for最多可以运行464次，大家做题的时候根据题目给的数据范围，可以估算一下暴力的话会不会超时。

int 型变量最大记为 2e9 , long long 最大记为 1e18 （其实是9e18，主要记数量级），OI 赛制 不开long long见祖宗！
输入输出建议直接使用 scanf 和 printf ，或者ios加速后的 cin 和 cout ，但切记使用加速命令后cin cout 不要同时和 scanf 和 printf 一起使用。

直接放入 main() 函数开头即可。

输出的时候如果两个数字间有空格的话记得输出需要 printf("%d %d\n", a, b); （往期很多同学都会犯）
大家如果平时不常用 debug 功能的话，可以去在关键处使用 printf 大法 去打印出关键变量（或者数组中的元素），思考一下写的代码和思路的结果是否相同。
题目的样例给的很少，可以自己去造几组数据进行测试（最好造边界、极端情况 ），考虑有没有负值、有没有特殊样例、有没有可能爆变量的最大值。
代码全都写进主函数有点难以调试，可以去 分块写 函数，哪里错了看哪里
最好熟悉使用一下 stl 的数据结构 string , map, set,queue, stack, priority_queue, vector等；同时最好也熟悉 stl 里的函数

尽管可以直接现查赛时提供的 帮助手册 ，但还是建议去用一用熟悉一下。

upper_bound() \ lower_bound()
find()
count()
substr()
sort()
reverse() 
unique()
stoi(s)
atoi(s)
to_string()
等等...

推荐个STL的网站：https://wyqz.top/p/870124582.html 比较好看~

基于 OI 赛制，可以先想暴力，再去想算法去优化时间/空间。
暴力即枚举所有可能的答案，选最优的，也就是题目问什么就去枚举什么。
如果可以的话，直接模拟题目陈述的步骤即可。
对于暴力的方法，基本有以下几种：

for循环直接枚举数组\或者答案，（如果是答案的话立即想一下是否可以二分答案）

枚举排列组合的方案：dfs 飞机降落
想要找规律，可以直接写程序去找，而不是脑子硬想。
打表：可以在本地一直跑，跑出答案直接写到数组里，交程序时候直接读出数组中计算好的答案即可。
图论中暴力即 DFS、BFS 遍历所有点，最好去背背板子。
根据数据范围反推算法时间复杂度

由数据范围反推算法复杂度以及算法内容 - AcWing

二分

首先，二分查找的模板在此

#include
#include
#include

using namespace std;

const int N = 100010; //根据题目中n的范围来确定数组应该开多大, 开的范围必须比n要大一点

int n, q; //n个数, q次询问
int arr[N]; //array

//第一个二分查找找的是: 被询问数的第一次出现的位置(下标)
int binary_search1(int arr[], int len, int x) {
 int l = -1, r = len;
 while(l + 1 
- **数组大小要开的大一点**，比如题干给 $n \le 10000$ ，咱们最好开 $10010$ 大的数组，防止越界。

- **注意二分 $l, r$ 的取值**，如果数组从下标为 $1$ 处开始存，则 $l = 0, r = n + 1$ ；如果从下标为 $0$ 处开始存，则 $l = -1, r = n$ 即可。

- 要清楚**边界线**，以及怎么去划定自己需要的范围。

![](https://dn-simplecloud.shiyanlou.com/questions/uid1736686-20240410-1712735591404) 当取的值**大过一个分界线之后**，无论取哪个值都不可以满足条件。

![](/images/2025/03/uid1736686-20240410-1712735609631.png)

当取的值**小过一个分界线之后**，无论取哪个值都不可以满足条件。

![](/images/2025/03/uid1736686-20240410-1712735629991.png)

**相关视频**（简介里有视频讲义和题目）

[二分查找 | 妈妈再也不怕我写错二分啦 | 五点七边二分视频补充_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1fA411z7ru/?spm_id_from=333.999.0.0)

[二分习题课 | 手把手教你二分答案! | 超级细不听血亏_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1RT41197Ln/?spm_id_from=333.999.0.0)

[二分习题课补充 | P2853路标设置_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1hG4y1N7jZ/?spm_id_from=333.999.0.0) （第二种二分）

[精讲浮点数二分 | 另一种二分应用场景_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1HD4y1K7iD/?spm_id_from=333.999.0.0)

### 前缀和 和 差分

前缀和是指某序列的前 $n$ 项和，可以把它理解为数学上的数列的前 $n$ 项和，而差分可以看成前缀和的逆运算。合理的使用前缀和与差分，可以将某些复杂的问题简单化。

![](/images/2025/03/uid1736686-20240410-1712735645419.png)

![](/images/2025/03/uid1736686-20240410-1712735662592.png)

### 双指针

核心思想：**优化暴力** （一般都是把暴力的 $O(n ^2)$ 优化到 $O(n)$ ），维护一些具有**单调性**、可快速删减的区间信息。

![](/images/2025/03/uid1736686-20240410-1712735677102.png)

**注意：**

- 要保证两个指针的**单调性**，即**不能回头走** （如果向前走就一直向前走）。

- 如果无序的话，可能需要先**排个序**。

- 用到的基本是 **快慢指针** 和 **对撞指针**。

**相关视频**（简介里有视频讲义和题目）

[双指针 + 前缀和知识点课 | 一节课让你搞懂双指针思想!_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1rv4y1s7dJ/?spm_id_from=333.999.0.0)

[双指针习题课 | 不听血亏 | 全新的思维方式_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1BD4y1P7YF/?spm_id_from=333.999.0.0)

### DFS - 不撞南墙不回头

```cpp
void dfs()//参数用来表示状态 
{ 
 if(到达终点状态) 
 { 
 ...//根据题意添加 
 return; 
 } 
 if(越界或者是不合法状态) 
 ...//根据题意添加 
 return; 
 if(特殊状态)//剪枝
 ...//根据题意添加 
 return ;
 for(扩展方式) 
 { 
 if(扩展方式所达到状态合法) 
 { 
 修改操作;//根据题意来添加 
 标记； 
 dfs（）； 
 (还原标记)； 
 //是否还原标记根据题意 
 //如果加上（还原标记）就是 回溯法 
 } 

 } 
}

注意：

注意枚举的顺序，要做到对每个点都依次枚举到。
注意输出方案时 $return$ 的位置。
要从数据存入的第一个点开始依次搜（比如数组从 $1$ 开始存，那么 $dfs(1)$ ）。
迷宫问题的方向数组别写错
$dfs$ 前可以预处理

相关视频（简介里有视频讲义和题目）

递推与递归 + DFS | 手把手带你画出递归搜索树_哔哩哔哩_bilibili

DFS正确入门方式 | DFS + 递归与递推习题课(上) | 一节课教你爆搜!_哔哩哔哩_bilibili

DFS正确入门方式 | DFS + 递归与递推习题课(下) | 一节课教你爆搜!_哔哩哔哩_bilibili

BFS - 一石惊起千层浪，泛起层层涟漪~

#define pair PII
void bfs()
{
 queue q; //一般用stl库中的queue来实现队列比较方便
 q.push(起点S); //将初始状态入队
 标记初始状态已入队。
 while(!q.empty())//队列不为空就执行入队出队操作
 {
 top = q.front();//取出队头
 q.pop();//队首出队
 for (枚举所有可扩展的状态)
 {
 if (check())//状态合法
 {
 q.push(temp);//状态入队
 标记成已入队。
 }

 }
 }

BFS可用于解决两类问题：

1.从A出发是否存在到达B的路径；DFS也可求

2.从A出发到达B的最短路径；数据小20以内的话, DFS也不是不可以题眼

整体思路

其思路为从图上一个节点出发，访问先访问其直接相连的子节点，若子节点不符合，再问其子节点的子节点，按级别顺序(一层一层)依次访问，直到访问到目标节点。

步骤

起始：将起点（源点，树的根节点）放入队列中
扩散：从队列中取出队头的结点，将它的相邻结点放入队列，不断重复这一步
终止：当队列为空时，说明我们遍历了所有的能到的结点，整个图能到的点都被搜索了一遍

相关视频（简介里有视频讲义和题目）

BFS知识点课 | 一节课带你搞懂BFS | 凭什么为什么你怎么知道要用队列?_哔哩哔哩_bilibili

BFS习题课(上) | 从此搞懂搜索题的套路! | 入门必看_哔哩哔哩_bilibili

BFS 习题课(下) | 带你深入浅出 BFS 专题! | 下一站, DP!_哔哩哔哩_bilibili

DP

动态规划思路: dfs暴力 –> 记忆化搜索 –> 递推

1dfs > 2记忆化搜索 > 3逆序递推 > 4顺序递推 > 5优化空间 !

写出递推公式的方法:

递推的公式 = $dfs$ 向下递归的公式

递推数组的初始值 = 递归的边界

动态规划做题步骤

重述问题
找到最后一步
去掉最后一步，是否能划分出子问题
考虑边界

dp不会写可以直接写dfs 跑路（最好加个记忆化mem，能剪枝也可以剪枝）

相关视频（简介里有视频讲义和题目）

动态规划(dp)入门 | 这tm才是入门动态规划的正确方式! | dfs记忆化搜索 | 全体起立!!_哔哩哔哩_bilibili

DP之背包问题 | 01背包 + 完全背包 | 逐步推进，深入解析！_哔哩哔哩_bilibili

动态规划入门刷题课（上）| 新手必看必学 | dp四部曲_哔哩哔哩_bilibili

动态规划入门刷题课（下）| 新手入门动态规划必看！！ | dp四步曲_哔哩哔哩_bilibili

图论板子

堆优化版dijkstra —— 模板题 AcWing 850. Dijkstra求最短路 II

时间复杂度 $O(mlogn)$ ，$n$ 表示点数， $m$ 表示边数。

typedef pair PII;

int n; // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
 memset(dist, 0x3f, sizeof dist);
 dist[1] = 0;
 priority_queue, greater> heap;
 heap.push({0, 1}); // first存储距离，second存储节点编号

 while (heap.size())
 {
 auto t = heap.top();
 heap.pop();

 int ver = t.second, distance = t.first;

 if (st[ver]) continue;
 st[ver] = true;

 for (int i = h[ver]; i != -1; i = ne[i])
 {
 int j = e[i];
 if (dist[j] > distance + w[i])
 {
 dist[j] = distance + w[i];
 heap.push({dist[j], j});
 }
 }
 }

 if (dist[n] == 0x3f3f3f3f) return -1;
 return dist[n];
}

floyd算法 —— 模板题 AcWing 854. Floyd求最短路

时间复杂度 $(O^3)$ , $n$ 表示点数。

初始化：
 for (int i = 1; i ![](/images/2025/03/uid1736686-20240410-1712735700770.png)

双指针&前缀和

Mon, 31 Mar 2025 22:24:08 +0800

acwing799最长连续不重复子序列

#include
using namespace std;

const int N=1e5+10;
int n;
int q[N];
int cnt[N];

int main()
{
 std::ios::sync_with_stdio(0);
 std::cin.tie(0);

 cin>>n;
 for(int i=1;i>q[i];
 int res=0;
 for(int i=1,j=1;i1)
 {
 cnt[q[j]]--;
 j++;
 }
 res=max(res,i-j+1);
 }
 cout
using namespace std;

const int N=1e5+10;
int n,m;
int a[N],s[N];

int main()
{
 cin>>n>>m;
 for(int i=1;i>a[i];
 s[i]=s[i-1]+a[i];
 }
 while(m--)
 {
 int l,r;
 cin>>l>>r;
 cout
using namespace std;

const int N=1010;
int n,m,k;
int q[N][N],s[N][N];

int main()
{
 cin>>n>>m>>k;
 for(int i=1;i>q[i][j];
 s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+q[i][j];
 }
 }
 while(k--)
 {
 int x1,y1,x2,y2;
 cin>>x1>>y1>>x2>>y2;
 cout
using namespace std;

const int N=1e5+10;
int n,m,x;
int a[N],b[N];

int main()
{
 cin>>n>>m>>x;
 for(int i=1;i>a[i];
 for(int i=1;i>b[i];
 for(int i=1,j=m;i=1&&a[i]+b[j]>x) j--;
 if(a[i]+b[j]==x)
 {
 cout
using namespace std;

const int N=2e5+10;
int n,C;
int q[N];

int main()
{
 std::ios::sync_with_stdio(0);
 std::cin.tie(0);

 cin>>n>>C;
 for(int i=1;i>q[i];
 }
 sort(q+1,q+n+1);
 long long cnt=0;
 for(int a=1,b1=1,b2=1;a=C)
 {
 b1++;
 }
 while(b2C)
 {
 b2++;
 }
 cnt+=b1-b2;
 }
 cout
using namespace std;

const int N=1e5+10;
int n;
int a[N],b[N],c[N];

int main()
{
 cin>>n;
 for(int i=1;i>a[i];
 for(int i=1;i>b[i];
 for(int i=1;i>c[i];

 sort(a+1,a+1+n);
 sort(b+1,b+1+n);
 sort(c+1,c+1+n);

 long long res=0;
 for(int i=1,IndexA=1,IndexC=1;i
using namespace std;

const int N=5e4+10;
int n,K;
int a[N];
int cnt_lr[N],cnt_rl[N];

int main()
{
 cin>>n>>K;
 for(int i=1;i>a[i];
 sort(a+1,a+1+n);
 for(int i=1,j=1;iK)j++;
 cnt_lr[i]=max(cnt_lr[i-1],i-j+1);
 }
 for(int i=n,j=n;i>=1;i--)
 {
 while(j>=i&&a[j]-a[i]>K)j--;
 cnt_rl[i]=max(cnt_rl[i+1],j-i+1);
 }
 int res=0;
 for(int i=1;i<=n-1;i++)
 {
 res=max(res,cnt_lr[i]+cnt_rl[i+1]);
 }
 cout<<res<<endl;
 return 0;
}

算法设计与分析：要点总结-1

Mon, 31 Mar 2025 01:48:48 +0800

算法概述

算法的5大特性

确定性:算法的每一步骤必须有明确的定义，无二义性。即在相同输入下，每次执行都应得到相同的结果。
能行性:算法的每一步都必须是可实现的，即在有限时间内能用有限资源完成。
输入：算法可以有零个或多个输入，输入是算法处理的初始数据。
输出：算法必须有一个或多个输出，输出是算法处理的结果。
有穷性/有限性：算法必须在执行有限步骤后终止，不能无限循环。

算法与计算过程的区别

计算过程可能无限执行（如操作系统），而算法必须是有穷的。

算法描述的主要语言

自然语言：直观但容易歧义。
伪代码：介于自然语言和编程语言之间，结构清晰，无语法限制。
流程图：图形化表示，直观展示控制流。
编程语言：直接实现，但需关注语法细节。

渐进表示

定义

O（大O符号，上界）： f(n)=O(g(n)) 表示存在常数 c>0 和 n0，使得对所有 n≥n0，有 f(n)≤c⋅g(n)。

表示算法的最坏情况时间复杂度。

Ω（Omega，下界）： f(n)=Ω(g(n)) 表示存在常数 c>0 和 n0，使得对所有 n≥n0，有 f(n)≥c⋅g(n)。

表示算法的最好情况时间复杂度。

Θ（Theta，紧确界）： f(n)=Θ(g(n)) 当且仅当 f(n)=O(g(n)) 且 f(n)=Ω(g(n))。

表示算法的平均情况时间复杂度。

多项式定理

若 f(n) 是 d 次多项式，则 f(n)=Θ(n**d)。

常见的多项式/指数限界函数

O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

渐进符号O运算性质

传递性：若 f(n)=O(g(n)) 且 g(n)=O(h(n))，则 f(n)=O(h(n))。
加法规则：O(f(n))+O(g(n))=O(max⁡(f(n),g(n)))。
乘法规则：O(f(n))⋅O(g(n))=O(f(n)⋅g(n))。

重要例题

冒泡排序

def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 for j in range(0, n-i-1):
 if arr[j] > arr[j+1]:
 arr[j], arr[j+1] = arr[j+1], arr[j]
 return arr

# 示例
print(bubble_sort([64, 34, 25, 12, 22, 11, 90])) # 输出: [11, 12, 22, 25, 34, 64, 90]

警察抓小偷

信息数字化。

竞赛预测

信息数字化。将逻辑问题转化为代码，遍历求解。

楼梯台阶问题

def climb_stairs(n):
 if n 
- **基准情形**：明确递归终止条件（如 n=0 或 n=1）。

- **递归调用**：将问题分解为更小的同类子问题。

- **正确性证明**：通常用数学归纳法验证。

### 循环与递归的比较

| 比较维度 | 循环（迭代） | 递归 |
| --- | --- | --- |
| 程序可读性 | 通常更直观，适合线性逻辑（如遍历数组）。 | 更符合数学思维，适合分治、树/图遍历等问题，但嵌套过深时难理解。 |
| 代码量 | 通常较短，尤其是简单循环（如 for、while）。 | 可能更简洁（如阶乘、斐波那契数列），但需要额外递归终止条件。 |
| 时间效率 | 无函数调用开销，执行更快（适合大规模数据）。 | 每次递归调用需保存栈帧，函数调用开销大，可能更慢。 |
| 占用空间 | 仅需固定内存（如几个变量），空间复杂度通常为 O(1)。 | 需保存每一层调用的栈帧，空间复杂度取决于递归深度（如 O(n) 或 O(log⁡n)），可能栈溢出。 |
| 适用范围 | 所有可迭代问题（如数组遍历、数值计算）。 | 适合分治（如归并排序）、回溯（如八皇后）、树/图遍历（如DFS）等递归定义的问题。 |
| 设计难度 | 较直观，适合顺序逻辑。 | 需找到子问题分解方式，设计递归终止条件，对思维抽象能力要求更高。 |

 一般的，理论上，循环（迭代）都可以改写成递归，反之不然。 

### 常用数据结构的比较

- **数组**：随机访问快，插入/删除慢。

- **链表**：插入/删除快，访问需遍历。

- **栈/队列**：特定顺序操作（LIFO/FIFO）。

- **哈希表**：快速查找，但需处理冲突。

### 重要例题

#### 欧几里得算法

```python
def gcd(a, b):
 while b:
 a, b = b, a % b
 return a

# 示例
print(gcd(48, 18)) # 输出: 6

Hanoi塔

def hanoi(n, source, target, auxiliary):
 """
 汉诺塔递归解法
 :param n: 盘子数量
 :param source: 起始柱子（如 'A'）
 :param target: 目标柱子（如 'C'）
 :param auxiliary: 辅助柱子（如 'B'）
 """
 if n == 1:
 # 基准情形：只有一个盘子时，直接移动到目标柱子
 print(f"Move disk 1 from {source} to {target}")
 else:
 # 递归步骤：
 # 1. 将前 n-1 个盘子从 source 移到 auxiliary（借助 target）
 hanoi(n-1, source, auxiliary, target)
 
 # 2. 将第 n 个盘子（最大的）从 source 移到 target
 print(f"Move disk {n} from {source} to {target}")
 
 # 3. 将前 n-1 个盘子从 auxiliary 移到 target（借助 source）
 hanoi(n-1, auxiliary, target, source)

# 示例：移动 3 个盘子从 A 到 C，借助 B
hanoi(3, 'A', 'C', 'B')

整数的划分

def integer_partition(n, m):
 """
 计算将整数 n 划分为最大部分不超过 m 的划分数。
 :param n: 待划分的整数。
 :param m: 划分中允许的最大部分。
 """
 if n == 0:
 return 1 # 空划分算一种
 if m == 1:
 return 1 # 只能划分为 1+1+...+1
 if n 
- **初始化**：设定初始状态（如变量初值）。

- **迭代过程**：通过循环逐步更新状态。

- **终止条件**：达到目标时退出循环。

### 递推法vs倒推法

- **递推法**：从已知条件逐步推导到目标（如斐波那契数列）。

- **倒推法**：从目标反向推导初始条件（如猴子吃桃问题）。

### 重要例题

#### 兔子繁衍问题

```python
def fibonacci(n):
 a, b = 0, 1
 for _ in range(n):
 a, b = b, a + b
 return a

# 示例
print(fibonacci(6)) # 输出: 8（第6个月有8对兔子）

猴子吃桃问题

def peach_count(days):
 peaches = 1 # 最后一天剩1个
 for _ in range(days-1):
 peaches = (peaches + 1) * 2
 return peaches

# 示例
print(peach_count(5)) # 输出: 46（第1天有46个桃子）

杨辉三角形

递推关系：C(n,k)=C(n−1,k−1)+C(n−1,k)。

穿越沙漠问题（重点在于如何理解其思想）

核心思想：分段设立补给站，逆向计算资源消耗。

牛顿迭代法

求方程根：xn+1=xn−f(xn)/f′(xn)。

蛮力法

重要例题

百钱百鸡问题

def hundred_chickens():
 for x in range(0, 21): # 公鸡最多20只
 for y in range(0, 34): # 母鸡最多33只
 z = 100 - x - y
 if 5*x + 3*y + z/3 == 100:
 print(f"公鸡: {x}, 母鸡: {y}, 小鸡: {z}")

# 示例
hundred_chickens() # 输出所有解

解数字迷（ABCAB X A = DDDDDD）

def solve_abcab():
 for a in range(1, 10):
 for b in range(10):
 for c in range(10):
 abcab = 10000*a + 1000*b + 100*c + 10*a + b
 d = abcab * a
 if len(str(d)) == 6 and len(set(str(d))) == 1:
 print(f"ABCAB = {abcab}, A = {a}, D = {d}")

# 示例
solve_abcab() # 输出: ABCAB = 37037, A = 3, D = 111111

狱吏问题（蛮力->数学技巧->深入挖掘数学规律）

def prison_doors(n):
 doors = [False] * n # False表示门关闭
 for i in range(1, n+1):
 for j in range(i-1, n, i):
 doors[j] = not doors[j]
 return [i+1 for i, door in enumerate(doors) if door]

# 示例
print(prison_doors(10)) # 输出: [1, 4, 9]（完全平方数编号的门开着）

二分查找与二分答案

Fri, 28 Mar 2025 16:39:26 +0800

原题单链接：https://www.luogu.com.cn/training/111#problems

AcWing789. 数的范围

#include 
using namespace std;

const int N = 1e5 + 10;
int n, q, a[N];

int bs1(int x)
{
 int l = -1, r = n;
 while (l + 1 != r)
 {
 int mid = l + r >> 1;
 if (a[mid] > 1;
 if (a[mid] > n >> q;
 for (int i = 0; i > a[i];
 }
 while (q--)
 {
 int x;
 cin >> x;
 int res1 = bs1(x);
 if (res1 == -1)
 {
 cout 
using namespace std;

double n;

int main()
{
 cin>>n;
 double l=-100,r=100;
 // while(r-l>1e-8)
 for(int i=0;i
using namespace std;

const int N=1e6+10;
int n,m;
int a[N];

int main()
{
 cin>>n>>m;
 for(int i=1;i>a[i];
 }
 while (m--)
 {
 int x;
 cin>>x;
 int l=0,r=n+1;
 while (l+1!=r) // l+1>1;
 if(a[mid]
using namespace std;

const int N=2e5+10;
int n,C;
int q[N];

int bs1(int x)
{
 int l=0,r=n+1;
 while(l+1>n>>C;
 for(int i=1;i>q[i];
 }
 sort(q+1,q+n+1);
 long long cnt=0;
 for(int B=1;B
using namespace std;

const int N=1e6+10;
int n,m;
int q[N];

bool check(int x)
{
 long long sum=0;
 for(int i=1;i=m)return true;
 }
 if(sum>=m)return true;
 else return false;
}

int main()
{
 cin>>n>>m;
 for(int i=1;i>q[i];
 }
 int l=0,r=4e5;
 while(l+1
using namespace std;

const int N = 1e5 + 10;
int n, k;
int q[N];

bool check(int x)
{
 int sum = 0;
 for (int i = 1; i = k)
 return true;
 else
 return false;
}

int main()
{
 cin >> n >> k;
 for (int i = 1; i > q[i];
 }
 int res = 0, sum = 0;
 int l = 0, r = 1e8;
 while (l + 1 
using namespace std;

const int N=5e4+10;
int L,n,m;
int q[N];

bool check(int x)
{
 int cnt=0;
 int i=0,now=0;
 while(i>L>>n>>m;
 for(int i=1;i>q[i];
 }
 q[n+1]=L;

 int l=0,r=L+1;
 while(l+1
using namespace std;

const int N=1e5+10;
int L,n,k;
int q[N],s[N];

bool check(int x)
{
 int cnt=0;
 for(int i=1;ix)
 {
 cnt++;
 int num=s[i]-x;
 while (num>x)
 {
 cnt++;
 num-=x;
 }
 // cnt+=num/x-1;
 // if(num%x)cnt++;
 }
 }
 if(cnt>L>>n>>k;
 for(int i=1;i>q[i];
 s[i]=q[i]-q[i-1];
 }
 q[n+1]=L;
 s[n+1]=L-q[n];
 int l=0,r=1e7+1;
 while(l+1<r)
 {
 int mid=(l+r)/2;
 if(check(mid))r=mid;
 else l=mid;
 }
 if(check(l))cout<<l<<'\n';
 else cout<<r<<'\n';
 return 0;
}

动态规划做题步骤

Mon, 24 Mar 2025 11:26:18 +0800

原题单链接：https://rentry.org/ozd34yrn

例题

重述问题
找到最后一步
去掉最后一步，是否能划分出子问题
考虑边界

746. 使用最小花费爬楼梯

const int N=1010;

class Solution {
public:
 int mem[N];
 int dfs(vector& cost, int x)
 {
 if(mem[x])return mem[x];

 int sum=0;
 if(x==1||x==0)sum=0;
 else sum=min(dfs(cost,x-1)+cost[x-1],dfs(cost,x-2)+cost[x-2]);
 mem[x]=sum;
 return sum;
 }

 int minCostClimbingStairs(vector& cost) {
 int n=cost.size();
 // int ans=dfs(cost,n);
 int f[N];
 f[0]=f[1]=0;
 for(int i=2;i& nums, int x) {
 if (mem[x])
 return mem[x];

 int res = 0;
 for (int i = 0; i & nums) {
 int n = nums.size();
 int res=-1e9;
 // for(int i=0;i& coins, int amount) {
 if (mem[amount])
 return mem[amount];
 int n = coins.size();
 if (amount == 0)
 return 0;
 int res = 1e9;
 for (int i = 0; i = coins[i])
 res = min(res, dfs(coins, amount - coins[i]) + 1);
 }
 mem[amount] = res;
 return res;
 }

 int coinChange(vector& coins, int amount) {
 int n = coins.size();
 // int ans = dfs(coins, amount);
 // ans=ans==1e9?-1:ans;
 int f[N];
 memset(f, 0x3f, sizeof f);
 f[0] = 0;
 for (int i = 1; i =coins[j])
 f[i]=min(f[i], f[i-coins[j]] + 1);
 }
 }
 return f[amount]>1e9?-1:f[amount];
 }
};

剑指 Offer 42. 连续子数组的最大和

const int N=100010;

class Solution {
public:
 int mem[N];
 int dfs(vector& sales,int x)
 {
 if(x& sales) {
 int n=sales.size();
 int f[N];
 int ans=-101;
 // for(int i=0;i<n;i++)
 // {
 // ans=max(ans,dfs(sales,i));
 // }
 f[0]=sales[0];
 for(int i=1;i<n;i++)
 {
 f[i]=max(sales[i],f[i-1]+sales[i]);
 }
 for(int i=0;i<n;i++)
 {
 ans=max(ans,f[i]);
 }
 return ans;
 }
};

343. 整数拆分

const int N=110;

class Solution {
public:
 int mem[N]={0};
 int dfs(int x)
 {
 if(mem[x])return mem[x];
 if(x==0)return 1;

 int res=0;
 for(int i=1;i<x;i++)
 {
 res=max(res,max(i*(x-i),dfs(x-i)*i));
 }
 return mem[x]=res;
 }

 int integerBreak(int n) {
 int ans;
 // ans=dfs(n);
 int dp[N];
 dp[0] = dp[1] = 1;
 for (int i = 2; i <= n; ++i) {
 for (int j = 1; j < i; ++j) {
 dp[i] = max(dp[i], max(j * (i - j), dp[i - j] * j));
 }
 }
 ans=dp[n];
 return ans;
 }
};

下期待更新的dp题单（2024.2.25编）

413. 等差数列划分如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

279. 完全平方数简单预处理，最后一步：选择某个数作为最后一个

646. 最长数对链最长上升子序列模板 + 排序

918. 环形子数组的最大和找找最大和、最小和和总和的关系

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性，01转移实现dfs不需要传vector的参数

213. 打家劫舍 II 考虑选不选第一个物品，可以把问题分为两个子问题

368. 最大整除子集 pre数组记录路径，更新时实现记录，而不是以前的max不知道更新没更新

1105. 填充书架枚举选哪个，转移方程有教学意义

1416. 恢复数组枚举选哪个，集合转移

2400. 恰好移动 k 步到达某一位置的方法数目要对mem数组做偏移，`mem[now + N][cnt]` ，选其中一个的思路

1335. 工作计划的最低难度枚举选哪个思路，集合转移

7006. 销售利润最大化集合转移，预处理endi，选或不选

1235. 规划兼职工作选或不选 1751. 最多可以参加的会议数目 II 类似 2054. 两个最好的不重叠活动

01转移

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性

1186. 删除一次得到子数组最大和子数组最大和 + 记录删没删

2369. 检查数组是否存在有效划分划分型dp 好像用不了记忆化搜索？

并查集

Sat, 22 Mar 2025 12:08:20 +0800

#include 
using namespace std;

const int N = 10010;
int fa[N];

inline void init(int n)
{
 for (int i = 1; i > n >> m;
 init(n);
 for (int i = 1; i > child >> parent;
 merge(child, parent);
 }
 for (int i = 1; i <= n; i++)
 {
 cout << find(i) << " ";
 }
 return 0;
}

前缀和

Sat, 22 Mar 2025 11:58:17 +0800

#include
using namespace std;

const int N = 10010;
int a[N], s[N];
int n;

int main(){
 cin >> n;
 for (int i = 1; i > a[i];
 s[i] = s[i - 1] + a[i];
 }
 for(int i = 1; i <= n; i ++ ){
 cout << s[i] << " ";
 }
 return 0;
}

背包问题

Sat, 22 Mar 2025 10:31:12 +0800

01背包问题

#include 
#include 
#include 

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N];
int g[N];

int main()
{
 scanf("%d %d", &n, &m);
 for (int i = 1; i = 1; i--)
 // {
 // for (int j = 0; j = v[i])
 // {
 // g[j] = max(f[j], f[j - v[i]] + w[i]);
 // }
 // }
 // memcpy(f, g, sizeof g);
 // }
 // cout= v[i])
 // {
 // g[j] = max(f[j], f[j - v[i]] + w[i]);
 // }
 // }
 // memcpy(f, g, sizeof g);
 // }
 // cout = 0; j--)
 // {
 // if (j >= v[i])
 // {
 // f[j] = max(f[j], f[j - v[i]] + w[i]);
 // }
 // }
 // }
 // cout = 1; i--)
 {
 for (int j = m; j >= 0; j--)
 {
 if (j >= v[i])
 {
 f[j] = max(f[j], f[j - v[i]] + w[i]);
 }
 }
 }
 cout 
using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int mem[N][N];
int f[N][N];
int g[N];

int dfs(int x, int spV)
{
 if (mem[x][spV])
 return mem[x][spV];

 int sum = 0;
 if (x > n)
 sum = 0;
 else if (spV > n >> m;
 for (int i = 1; i > v[i] >> w[i];

 // int res=dfs(1,m);
 // cout 
using namespace std;

const int N = 1010;

int n, V, M;
int v[N], m[N], w[N];
int mem[N][110][110];
int f[N][110][110];
int g[110][110];

int dfs(int x, int spV, int spM)
{
 if (mem[x][spV][spM])
 return mem[x][spV][spM];

 int sum = 0;
 if (x > n)
 sum = 0;
 else if (spV > n >> V >> M;
 for (int i = 1; i > v[i] >> m[i] >> w[i];

 // int res=dfs(1,V,M);
 // cout= 1; i--)
 // for (int j = 0; j = v[i]; j--)
 // for (int k = M; k >= m[i]; k--)
 // {
 // g[j][k] = max(g[j][k], g[j - v[i]][k - m[i]] + w[i]);
 // }
 // cout = 1; i--)
 for (int j = V; j >= v[i]; j--)
 for (int k = M; k >= m[i]; k--)
 {
 g[j][k] = max(g[j][k], g[j - v[i]][k - m[i]] + w[i]);
 }
 cout << g[V][M] << endl;

 return 0;
}

动态规划入门

Sat, 22 Mar 2025 01:52:48 +0800

原题单链接：https://rentry.org/2f76axt4

见到很有意思的问题 : 以往见过许多教材，对动态规划（DP）的引入属于“奉天承运，皇帝诏曰”式：不给出一点引入，见面即拿出一大堆公式吓人；学生则死啃书本，然后突然顿悟。针对入门者的教材不应该是这样的。(看到一位知乎的大佬说的, 深有感悟~)

动态规划 就是 : 给定一个问题，我们把它拆成一个个子问题，直到子问题可以直接解决。然后把子问题的答案保存起来，以减少重复计算。再根据子问题答案反推，得出原问题解的一种方法.

那么我们今天就来带给大家 新手入门动态规划的正确方法!

记忆化搜索 = 暴力dfs + 记录答案

动态规划入门思路: dfs暴力 — 记忆化搜索 — 递推

1dfs > 2记忆化搜索 > 3逆序递推 > 4顺序递推 > 5优化空间 !

递归的过程:

“递” 的过程是: 分解子问题的过程;

“归” 的过程才是: 产生答案的过程;

“递” – 自顶向下, “归” – 自底向上 ，其中 “底” 是 递归搜索树 的底

写出递推公式的方法:

递推的公式 = dfs 向下递归的公式

递推数组的初始值 = 递归的边界

例题

acwing821.跳台阶 \或者\ P1255. 数楼梯

#include 

using namespace std;

const int N = 100;
int n;
int f[N];

int main()
{
 f[1] = 1, f[2] = 2;
 cin >> n;
 int newf = 0, tmp1 = 1, tmp2 = 2;
 for(int i = 3; i 

using namespace std;

const int N = 100010;
int n, T;
int home[N];
int men[N];
int f[N];

int dfs(int x)
{
 if (men[x])
 return men[x];

 int sum = 0;
 if (x > n)
 sum = 0;
 else
 sum = max(dfs(x + 1), dfs(x + 2) + home[x]);

 men[x] = sum;
 return sum;
}

int main()
{
 cin >> T;
 while (T--)
 {
 memset(men, 0, sizeof men);
 cin >> n;
 for (int i = 1; i > home[i];
 }
 // int res = dfs(1);
 // cout = 1; i--)
 // {
 // f[i] = max(f[i+1],f[i+2]+home[i]);
 // }
 // cout 

using namespace std;

const int N = 1010;
int n;
int g[N][N];
int mem[N][N];
int f[N][N];
int h[N];

int dfs(int x, int y)
{
 if (mem[x][y])
 return mem[x][y];

 // if (x>n||y>n) return 0;
 // // 求 最优子问题 dfs(x)=max(dfs(x+1),dfs(x+2))
 // // 求 子问题的和 dfs(x)=dfs(x+1)+dfs(x+2)
 // else return max(dfs(x+1,y),dfs(x+1,y+1))+g[x][y];
 int sum = 0;
 if (x > n || y > n)
 sum = 0;
 else
 sum = max(dfs(x + 1, y), dfs(x + 1, y + 1)) + g[x][y];
 mem[x][y] = sum;
 return sum;
}

int main()
{
 cin >> n;
 for (int i = 1; i > g[i][j];
 // int res = dfs(1, 1);
 // cout = 1; i -- )
 // for (int j = 1; j = 1; i--)
 // for (int j = 1; j = 1; i--)
 for (int j = 1; j 
#include 
#include 

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int res = 0;

void dfs(int x, int sumV, int sumW)
{
 if (x > n)
 {
 if (sumV = res)
 {
 res = sumW;
 }
 return;
 }

 // 不选
 dfs(x + 1, sumV, sumW);

 // 选
 if (sumV + v[x] 
#include 
#include 

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int res = 0;
int mem[N][N];
int f[N][N];
int g[N];

int dfs(int x, int spV)
{
 if (mem[x][spV])
 {
 return mem[x][spV];
 }

 int sum = 0;
 if (x > n)
 {
 sum = 0;
 }
 else if (spV = v[x])
 {
 sum = max(dfs(x + 1, spV), dfs(x + 1, spV - v[x]) + w[x]);
 }
 mem[x][spV] = sum;
 return sum;
}

int main()
{
 scanf("%d %d", &n, &m);
 for (int i = 1; i = 1; i--)
 // {
 // for (int j = 0; j = v[i])
 // {
 // f[i][j] = max(f[i + 1][j], f[i + 1][j - v[i]] + w[i]);
 // }
 // }
 // }
 // cout= v[i])
 {
 f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
 }
 }
 }
 cout 

## 下期待更新的dp题单（2024.2.25编）

### [LCR 091. 粉刷房子](https://leetcode.cn/problems/JEj789/) 简单dp

### [413. 等差数列划分](https://leetcode.cn/problems/arithmetic-slices/) 如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

### [279. 完全平方数](https://leetcode.cn/problems/perfect-squares/) 简单预处理，最后一步：选择某个数作为最后一个

### [91. 解码方法](https://leetcode.cn/problems/decode-ways/) 正序dfs好写

### [646. 最长数对链](https://leetcode.cn/problems/maximum-length-of-pair-chain/) 最长上升子序列模板 + 排序

### [918. 环形子数组的最大和](https://leetcode.cn/problems/maximum-sum-circular-subarray/) 找找最大和 、 最小和 和 总和的关系

### [376. 摆动序列](https://leetcode.cn/problems/wiggle-subsequence/) 考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接**01转移**

### [2786. 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score/) 枚举每个数选或不选，记录上的数的奇偶性，**01转移** 实现dfs不需要传vector的参数

### [213. 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii/) 考虑选不选第一个物品，可以把问题分为两个子问题

### [122. 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/) 状态机模型

### [368. 最大整除子集](https://leetcode.cn/problems/largest-divisible-subset/) pre数组**记录路径**，更新时实现记录，而不是以前的max不知道更新没更新

### [1105. 填充书架](https://leetcode.cn/problems/filling-bookcase-shelves/) 枚举选哪个，**转移方程**有教学意义

### [1416. 恢复数组](https://leetcode.cn/problems/restore-the-array/) 枚举选哪个，**集合转移**

### [2466. 统计构造好字符串的方案数](https://leetcode.cn/problems/count-ways-to-build-good-strings/) 爬楼梯

### [1043. 分隔数组以得到最大和](https://leetcode.cn/problems/partition-array-for-maximum-sum/) 枚举选哪个，**集合转移**

### [2400. 恰好移动 k 步到达某一位置的方法数目](https://leetcode.cn/problems/number-of-ways-to-reach-a-position-after-exactly-k-steps/) 要对mem数组做偏移，`mem[now + N][cnt]` ，选其中一个的思路

### [1335. 工作计划的最低难度](https://leetcode.cn/problems/minimum-difficulty-of-a-job-schedule/) 枚举选哪个思路，**集合转移**

### [7006. 销售利润最大化](https://leetcode.cn/problems/maximize-the-profit-as-the-salesman/) **集合转移**， 预处理endi，选或不选

### [2008. 出租车的最大盈利](https://leetcode.cn/problems/maximum-earnings-from-taxi/) 选或不选

### [1235. 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling/) 选或不选 [1751. 最多可以参加的会议数目 II](https://leetcode.cn/problems/maximum-number-of-events-that-can-be-attended-ii/) 类似 [2054. 两个最好的不重叠活动](https://leetcode.cn/problems/two-best-non-overlapping-events/)

## 01转移

### [376. 摆动序列](https://leetcode.cn/problems/wiggle-subsequence/) 考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

### [2786. 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score/) 枚举每个数选或不选，记录上的数的奇偶性

### [122. 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/) 状态机模型

### [1186. 删除一次得到子数组最大和](https://leetcode.cn/problems/maximum-subarray-sum-with-one-deletion/) 子数组最大和 + 记录删没删

### [2369. 检查数组是否存在有效划分](https://leetcode.cn/problems/check-if-there-is-a-valid-partition-for-the-array/) **划分型dp** 好像用不了记忆化搜索？

### [2466. 统计构造好字符串的方案数](https://leetcode.cn/problems/count-ways-to-build-good-strings/) 爬楼梯

C++的cin和cout取消同步

Mon, 10 Mar 2025 21:56:59 +0800

C++的cin和cout加快读写速度，用以下代码：

std::ios::sync_with_stdio(false);
std::cin.tie(0);

BFS 广度优先搜索 ( Breadth-First-Search )

Sun, 02 Mar 2025 19:02:19 +0800

原题单链接：https://www.luogu.com.cn/paste/sa0zary9 || https://rentry.org/3r68rga7

广度优先搜索算法(Breadth First Search)，又称为"宽度优先搜索", BFS是用于图的查找算法(要求能用图表示出问题的关联性)。

BFS可用于解决2类问题：

1.从A出发是否存在到达B的路径；DFS也可求

2.从A出发到达B的最短路径；数据小20以内的话, DFS也不是不可以题眼

整体思路

步骤

起始：将起点（源点，树的根节点）放入队列中
扩散：从队列中取出队头的结点，将它的相邻结点放入队列，不断重复这一步
终止：当队列为空时，说明我们遍历了所有的能到的结点，整个图能到的点都被搜索了一遍

时空复杂度

时间复杂度 : 最差情形下，BFS必须寻找所有到可能节点的所有路径，因此其时间复杂度为O(|V| + |E|)，其中|V|是节点的数目，而|E|是图中边的数目。

空间复杂度 : BFS的空间复杂度为 O(B^h)，其中B是最大分支系数，而h是树的最长路径长度(树的高度) 。由于对空间的大量需求，因此BFS并不适合解非常大的问题。

对于所有边长度相同的情况，比如地图的模型，bfs第一次遇到目标点，此时就一定是从根节点到目标节点最短的路径（因为每一次所有点都是向外扩张一步，你先遇到，那你就一定最短）。bfs先找到的一定是最短的。但是如果是加权边的话这样就会出问题了，bfs传回的是经过边数最少的解，但是因为加权了，这个解到根节点的距离不一定最短。比如1000+1000是只有两段，1+1+1+1有4段，由于bfs返回的经过边数最少的解，这里会返回总长度2000的那个解，显然不是距离最短的路径。此时我们就应该采用Dijkstra最短路算法解决加权路径的最短路了。

SPFA

例题

acw844. 走迷宫 ,

#include 

#define x first
#define y second

using namespace std;

const int N = 110;
typedef pair pii;

int n,m;
int g[N][N];
int dist[N][N];
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(int sx,int sy)
{
 memset(dist,-1,sizeof dist); // -1 means not visited
 q.push({sx,sy});
 dist[sx][sy]=0; // start point

 while (q.size()&&!q.empty()) // while queue is not empty
 {
 auto t=q.front();
 q.pop();

 for (int i = 0; i n||bm) continue; // out of bound
 if(g[a][b]!=0) continue; // if there is a wall
 if(dist[a][b]>0) continue; // if already visited

 q.push({a,b}); // push the next point
 dist[a][b]=dist[t.x][t.y]+1;

 if(a==n&&b==m)
 {
 return dist[a][b];
 }
 }
 }
 return dist[n][m];
}

int main()
{
 cin >> n >> m;
 for(int i=1;i> g[i][j];
 }
 }
 int res=bfs(1,1);
 cout 若打不开这个题就看这个 [P1746 离开中山路](https://www.luogu.com.cn/problem/P1746)

代码见下文。


# 习题课

### 热身 - 简单迷宫问题

#### [P1746 离开中山路](https://www.luogu.com.cn/problem/P1746) 1

```cpp
#include 

using namespace std;

typedef pair pii;

const int N=1010;
int n;
int mx1,my1,mx2,my2;
char g[N][N];
int dist[N][N];
int res;
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(int x,int y)
{
 memset(dist,-1,sizeof(dist));
 q.push({x,y});
 dist[x][y]=0;

 while (!q.empty())
 {
 auto t=q.front();
 q.pop();

 for(int i=0;in||bn)continue;
 if(g[a][b]!='0')continue;
 if(dist[a][b]>=0)continue;

 q.push({a,b});
 dist[a][b]=dist[t.first][t.second]+1;

 if(a==mx2&&b==my2)
 {
 return dist[a][b];
 }
 }
 }
 return dist[mx2][my2];
}

int main()
{
 cin>>n;
 for(int i=1;i>g[i][j];
 }
 }
 // for(int i=1;i>g[i]+1;
 // }
 cin>>mx1>>my1;
 cin>>mx2>>my2;
 res=bfs(mx1,my1);
 cout

using namespace std;
typedef pair pii;

const int N=410;
int n,m,x,y;
int dist[N][N];
pii q[N*N];

int dx[]={-2,-1,1,2,2,1,-1,-2};
int dy[]={1,2,2,1,-1,-2,-2,-1};

void bfs(int x,int y)
{
 memset(dist,-1,sizeof(dist));
 q[0]={x,y};
 dist[x][y]=0;
 int hh=0,tt=0;

 while(hhn||bm)continue;
 if(dist[a][b]>=0)continue;

 dist[a][b]=dist[t.first][t.second]+1;
 q[++tt]={a,b};
 }
 }
}

int main()
{ 
 scanf("%d %d %d %d",&n,&m,&x,&y);
 bfs(x,y);
 for(int i=1;i

using namespace std;

typedef pair pii;

const int N=510;
int n,m,a,b;
int dist[N][N];
pii q[N*N];

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int hh=0,tt=-1;

void bfs()
{
 while(hhn||bm)continue;
 if(dist[a][b]>=0)continue;

 dist[a][b]=dist[t.first][t.second]+1;
 q[++tt]={a,b};
 }
 }
}

int main()
{ 
 cin>>n>>m>>a>>b;
 memset(dist,-1,sizeof(dist));
 while(a--)
 {
 int x,y;
 cin>>x>>y;
 q[++tt]={x,y};
 dist[x][y]=0;
 }
 bfs();
 while(b--)
 {
 int x,y;
 cin>>x>>y;
 cout

using namespace std;

typedef pair pii;

const int N=40;
int n;
int g[N][N];
bool st[N][N];
pii q[N*N];

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

void bfs(int x,int y)
{
 q[0]={x,y};
 st[x][y]=true;
 int hh=0,tt=0;

 while(hhn+1||bn+1)continue;
 if(st[a][b])continue;
 if(g[a][b]==1)continue;

 st[a][b]=true;
 q[++tt]={a,b};
 }
 }

 return;
}

int main()
{ 
 cin>>n;
 for(int i=1;i>g[i][j];
 }
 }
 bfs(0,0);
 for(int i=1;i

using namespace std;

typedef pair pii;

const int N=310;

int m;
int dist[N][N];
int fire[N][N];
pii q[N*N];

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs()
{
 q[0]={0,0};
 dist[0][0]=0;
 int hh=0,tt=0;

 while(hh=0)continue; // 已访问过
 if(dist[t.first][t.second]+1>=fire[a][b])continue; // 预先检查，如果被砸死了就不用管这个点了

 dist[a][b]=dist[t.first][t.second]+1;
 q[++tt]={a,b};

 if(fire[a][b]==0x3f3f3f3f)return dist[a][b];
 }
 }
 return -1;
}

int main()
{ 
 cin>>m;
 memset(fire,0x3f,sizeof(fire));
 memset(dist,-1,sizeof(dist));
 while (m--)
 {
 int x,y,t;
 cin>>x>>y>>t;
 fire[x][y]=min(t,fire[x][y]);
 for(int i=0;i301||b301)continue;
 fire[a][b]=min(t,fire[a][b]);
 }
 }
 int res=bfs();
 cout

using namespace std;

typedef pair pii;

const int N = 510;
int m, n;
int high[N][N];
int flag[N][N];
int cnt_flag = 0;
pii q[N * N];
int x = 0, y = 0;
bool st[N][N];

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

bool check(int mid)
{
 q[0] = {x, y};
 st[x][y]=true;
 int cnt = 1;
 int hh = 0, tt = 0;

 while (hh m || b n)
 continue;
 if (st[a][b])
 continue;
 if (abs(high[t.first][t.second] - high[a][b]) > mid)
 continue;

 q[++tt] = {a, b};
 st[a][b] = true;

 if (flag[a][b] == 1)
 {
 cnt++;
 if (cnt == cnt_flag)
 {
 return true;
 }
 }
 }
 }
 return false;
}

int main()
{
 cin >> m >> n;
 for (int i = 1; i > high[i][j];
 }
 }
 for (int i = 1; i > flag[i][j];
 if (flag[i][j] == 1)
 {
 cnt_flag++;
 }
 }
 }
 for (int i = 1; i 

using namespace std;

int g[2][4];
unordered_map dist;
unordered_map> pre;
queue q;

void set1(string state)
{
 for (int i = 0; i = 0; i--, j++)
 {
 g[1][i] = state[j];
 }
}

string get1()
{
 string res;
 for (int i = 0; i = 0; i--)
 {
 res += g[1][i];
 }
 return res;
}

// 交换上下两行，A
string move0(string state)
{
 set1(state);
 for (int i = 0; i 0; i--)
 {
 g[0][i] = g[0][i - 1];
 g[1][i] = g[1][i - 1];
 }
 g[0][0] = v0, g[1][0] = v1;
 return get1();
}

// 中央四个元素顺时针旋转，C
string move2(string state)
{
 set1(state);
 char v0 = g[0][1], v1 = g[0][2], v2 = g[1][2], v3 = g[1][1];
 g[0][1] = v3, g[0][2] = v0, g[1][2] = v1, g[1][1] = v2;
 return get1();
}

int bfs(string start, string end)
{
 q.push(start);
 dist[start] = 0;
 while (q.size())
 {
 auto t = q.front();
 q.pop();

 if (t == end)
 {
 return dist[t];
 }

 string m[3];
 m[0] = move0(t), m[1] = move1(t), m[2] = move2(t);
 for (int i = 0; i > x)
 {
 end += char(x + '0');
 }
 int res = bfs(start, end);
 cout 

using namespace std;

typedef pair pii;

const int N = 510;
int n,m,xx1,yy1,xx2,yy2;
char g[N][N];
int dist[N][N];
deque q;

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

int bfs(int x,int y)
{
 q.push_back({x,y});
 dist[x][y]=0;

 while (q.size())
 {
 auto t=q.front();
 q.pop_front();
 char ch=g[t.first][t.second];

 for (int i = 0; i =n||b=m)continue;
 if(dist[a][b]>=0)continue;

 if(g[a][b]==ch)
 {
 dist[a][b]=dist[t.first][t.second];
 q.push_front({a,b});
 }

 if(g[a][b]!=ch)
 {
 dist[a][b]=dist[t.first][t.second]+1;
 q.push_back({a,b});
 }

 if(a==xx2&&b==yy2)return dist[xx2][yy2];
 }
 }
 return -1;
}

int main()
{
 while (cin >> n >> m, n != 0 && m != 0)
 {
 for (int i = 0; i > g[i];
 }
 memset(dist,-1,sizeof(dist));
 q.clear();
 cin>>xx1>>yy1>>xx2>>yy2;
 int res =bfs(xx1,yy1);
 cout

using namespace std;

typedef pair pii;
const int N=1100;

int n;
char g[N][N];
int dist[N][N];
int vis[N][N];
pii q[N*N];
int xx1,yy1,xx2,yy2;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs()
{
 memset(dist,-1,sizeof(dist));
 memset(vis,-1,sizeof(vis));

 dist[xx1][yy1]=0,dist[xx2][yy2]=0;
 vis[xx1][yy1]=1,vis[xx2][yy2]=2;
 q[0]={xx1,yy1},q[1]={xx2,yy2};
 int hh=0,tt=1;

 while(hhn||bn)continue;
 if(g[a][b]!='0')continue;

 if(vis[a][b]+vis[t.first][t.second]==3)
 {
 return dist[t.first][t.second]+dist[a][b]+1;
 }

 if(dist[a][b]>=0)continue;

 dist[a][b]=dist[t.first][t.second]+1;
 if(vis[a][b]==-1)vis[a][b]=vis[t.first][t.second];
 q[++tt]={a,b};
 }
 }
 return -1;
}

int main()
{
 cin>>n;
 for(int i=1;i>g[i]+1;
 }
 cin>>xx1>>yy1>>xx2>>yy2;
 int res=bfs();
 cout

using namespace std;

string end1="123804765";
unordered_map umap;
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(string st)
{
 q.push(st);
 umap[st]=0;

 while(q.size())
 {
 auto t=q.front();
 q.pop();

 if(t==end1)return umap[t];
 int distance=umap[t];

 int a=t.find('0');
 int xx1=a/3,yy1=a%3; //一维数组下标转换为二维数组下标

 for (int i = 0; i =3||yy2=3)continue;
 int tmp=xx2*3+yy2;
 swap(t[a],t[tmp]);

 if(!umap.count(t))
 {
 umap[t]=distance+1;
 q.push(t);
 }
 swap(t[a],t[tmp]);
 }
 }
 return -1;
}

int main()
{
 string start1;
 cin>>start1;
 int res=bfs(start1);
 cout

```cpp
#include 

using namespace std;

string start1;
string end1="123804765";
queue q;
unordered_map dist;
unordered_map vis;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};

int bfs(string st)
{
 dist[st]=0;
 dist[end1]=0;
 q.push(st),q.push(end1);
 vis[st]=1,vis[end1]=2;

 while(q.size())
 {
 auto t=q.front();
 q.pop();

 int distance=dist[t];
 int flag=vis[t];

 int a=t.find('0');
 int xx1=a/3,yy1=a%3; //一维数组下标转换为二维数组下标

 for (int i = 0; i =3||yy2=3)continue;
 int tmp=xx2*3+yy2;
 swap(t[a],t[tmp]);

 if(vis[t]+flag==3)
 {
 int res1=dist[t];
 swap(t[a],t[tmp]);
 int res2=dist[t];
 return res1+res2+1;
 }
 if(!dist.count(t))
 {
 dist[t]=distance+1;
 vis[t]=flag;
 q.push(t);
 }
 swap(t[a],t[tmp]);
 }
 }
 return -1;
}

int main()
{
 cin>>start1;
 if(start1==end1)
 {
 cout

## 作业 (上节课DFS过不去, 这节课可以用BFS试一试~)

#### [P1135 奇怪的电梯](https://www.luogu.com.cn/problem/P1135) dfs暴力过不去

### **Flood fill** --- **找连通块**

#### [P1596 Lake Counting S](https://www.luogu.com.cn/problem/P1596)

#### [P1451求细胞数量](https://www.luogu.com.cn/problem/P1451)

#### [P1331 海战](https://www.luogu.com.cn/problem/P1331)

#### [P1767 家族](https://www.luogu.com.cn/problem/P1767)

#### [SP15436 UCV2013H - Slick](https://www.luogu.com.cn/problem/SP15436)

### 迷宫问题

#### [P1683 入门](https://www.luogu.com.cn/problem/P1683)

#### [P1605 迷宫](https://www.luogu.com.cn/problem/P1605)

#### [P1443 马的遍历](https://www.luogu.com.cn/problem/P1443)

#### [P1747 好奇怪的游戏](https://www.luogu.com.cn/problem/P1747)

#### [P2298 Mzc和男家丁的游戏](https://www.luogu.com.cn/problem/P2298)

# 关于memset和0x3f

int a[100];

### memset(a,0x3f,sizeof(a) );

0x3f=0011 1111=63

C++中**int**型变量所占的位数为**4个字节**，即32位

0x3f显然不是int型变量中单个字节的最大值，应该是0x7f=0111 1111 B

**那为什么要赋值0x3f ??**

int

### 1.作为无穷大使用

因为4个字节均为0x3f时，0x3f3f3f3f的十进制是1061109567，也就是10^ 9级别的（和0x7fffffff一个数量级），而一般场合下的数据都是小于10^9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。

### 2.可以保证无穷大加无穷大仍然不会超限。

另一方面，由于一般的数据都不会大于10^9，所以当我们把无穷大加上一个数据时，它并不会溢出（这就满足了**“无穷大加一个有穷的数依然是无穷大”**），事实上0x3f3f3f3f+0x3f3f3f3f=2122219134，这非常大但却没有超过32-bit int_MAX的表示范围，所以0x3f3f3f3f**还满足了我们“无穷大加无穷大还是无穷大”的需求**。

首先要知道memset函数是**以字节为单位**进行赋值的；

#### void memset(void *s, int ch, size_t n)\;

函数解释：将s中前n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。

其实这里面的ch就是ascii为ch的字符；

将s所指向的某一块内存中的前n个 字节的内容全部设置为ch指定的ASCII值

递推与递归 DFS深度优先搜索

Thu, 27 Feb 2025 11:30:18 +0800

原题单链接：https://www.luogu.com/paste/vjf2z3hi || https://rentry.org/5yhk52ow

例题

跳台阶

#include 
using namespace std;
const int N=1e5;
int a[N];

int f(int n)
{
 if(a[n])return a[n];
 if(n==1)return 1;
 if(n==2)return 2;
 a[n]=f(n-1)+f(n-2);
 return a[n];
}

int main()
{
 int n;
 cin>>n;
 cout
using namespace std;

const int N=20;
int st[N];
int maxn;

void dfs(int n) // n 表示当前走到第n个位置，1表示不选，2表示选，0表示还没选
{
 if(n>maxn){
 for(int i=1;i>maxn;
 dfs(1);
 return 0;
}

递归实现排列型枚举

#include 
using namespace std;

const int N=20;

int n;
bool st[N];
int arr[N];

void dfs(int x)
{
 if(x>n){
 for(int i=1;i>n;
 dfs(1);
 return 0;
}

递归实现组合型枚举

#include 
using namespace std;

const int N=25;

int n,r;
int arr[N];

void dfs(int x,int start)
{
 if(x>r){
 for(int i=1;i>n>>r;
 dfs(1,1);
 return 0;
}

P1036 选数

#include 
using namespace std;

const int N=25;

int n,k;
int arr[N],xn[N];
int ans=0;

bool isprime(int x)
{
 if(xk)
 {
 int sum=0;
 for (int i = 1; i >n>>k;
 for(int i=1;i>xn[i];
 }
 dfs(1,1);
 cout
using namespace std;

const int N = 20;

int n;
int arr[N];
int ans = 0;
vector> ansarr;

void dfs(int x, int sum)
{
 if (sum > n)
 {
 return;
 }

 if (x > 10)
 {
 if (sum == n)
 {
 ans++;
 vector temp;
 for (int i = 1; i > n;
 dfs(1, 0);
 cout 
using namespace std;

const int N = 6;

int n,m;
int arr[N],mars[N],res=0;
bool st[N];

void dfs(int x)
{
 if(x>n)
 {
 res++;
 if(res==m+1)
 for (int i = 1; i > n >> m;
 for(int i = 1; i > mars[i];
 }
 dfs(1);
 return 0;
}

P1149 火柴棒等式指数 + 预处理

#include 
using namespace std;

int n;
int num[10010] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int a[5];
int ans = 0;

int col(int x){
 if(num[x]){
 return num[x];
 }
 else{
 int tempsum = 0;
 while(x){
 tempsum += num[x % 10];
 x /= 10;
 }
 return tempsum;
 }
}

void dfs(int x,int sum)
{
 if (sum > n-4)
 {
 return;
 }
 if (x > 3)
 {
 if (a[1] + a[2] == a[3] && sum == n - 4)
 {
 ans++;
 }
 return;
 }

 for (int i = 0; i > n;
 for (int i = 10; i 
using namespace std;

int n;
int s[15];
int b[15];
int st[15];
int ans = 1e9;

void dfs(int x)
{
 if (x > n)
 {
 bool has_tl = false;
 int sums = 1;
 int sumb = 0;
 for (int i = 1; i > n;
 for (int i = 1; i > s[i] >> b[i];
 }
 dfs(1);
 cout 
using namespace std;

int n, a, b;
int k[210];
bool st[210];
int ans[210];

void dfs(int x, int cnt)
{
 // if (cnt >= ans)
 // return;
 if (x n)
 return;

 // if (x == b)
 // {
 // ans = min(ans, cnt);
 // return;
 // }

 ans[x] = cnt;
 // 上楼
 if (x + k[x] 0 && !st[x - k[x]] && cnt + 1 > n >> a >> b;
 for (int i = 1; i > k[i];
 }
 dfs(a, 0);
 if (ans[b] == 1e9)
 ans[b] = -1;
 cout 
using namespace std;

const int N = 25;
char g[N][N];
int w, h;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
bool vis[N][N];
int res=0;

void dfs(int a, int b)
{
 for(int i=0;i= h || y = w)continue;
 if(g[x][y] != '.')continue;
 if(vis[x][y])continue;
 vis[x][y] = true;
 res++;
 dfs(x, y);
 }
}

int main()
{
 cin >> w >> h;
 for (int i = 0; i > g[i][j];
 for (int i = 0; i 
using namespace std;

const int N = 110;
int n, m;
char g[N][N];
bool st[N][N];
int res = 0;
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};

void dfs(int x, int y)
{
 for(int i = 0; i = n || b = m)
 {
 continue;
 }
 if(g[a][b] == 'W' && !st[a][b])
 {
 st[a][b] = true;
 dfs(a, b);
 }
 }
}

int main()
{
 cin >> n >> m;
 for (int i = 0; i > g[i][j];
 }
 }
 for (int i = 0; i 
using namespace std;

const int N = 10;
int n, k;
char g[N][N];
bool st[N];
int res = 0;

void dfs(int x, int cnt)
{
 if (cnt == k)
 {
 res++;
 return;
 }
 if (x >= n)
 return;
 for (int i = 0; i > n >> k, n > 0 && k > 0)
 {
 for (int i = 0; i > g[i];
 res = 0;
 dfs(0, 0);
 cout 
using namespace std;

const int N = 10;
int n, k;
int ans = 0;
int arr[N];

void dfs(int x, int start, int sum)
{
 if (sum > n)
 return;
 if (x > k)
 {
 if (sum == n)
 {
 ans++;
 }
 return;
 };
 for (int i = start; sum + i * (k - x + 1) > n >> k;
 dfs(1, 1, 0);
 cout 
using namespace std;

const int N = 25;
int n;
int ans = 0;
int used[N];
string s[N];
int g[N][N];

// dragon: the current dragon string
// x: the current index of the string
void dfs(string dragon, int x)
{
 ans = max(ans, (int)dragon.size());

 used[x]++;
 for(int i=0;i> n;
 for (int i = 0; i > s[i];
 }
 char start;
 cin >> start;

 for (int i = 0; i < n; i++)
 for (int j = 0; j < n; j++)
 {
 string a=s[i],b=s[j];
 for (int k = 1; k < min(a.size(),b.size()); k++)
 {
 if (a.substr(a.size()-k,k)==b.substr(0,k))
 {
 g[i][j]=k;
 break;
 }
 }
 
 }
 for (int i = 0; i < n; i++)
 {
 if (s[i][0] == start)
 {
 dfs(s[i], i);
 }
 }
 cout << ans << '\n';
 return 0;
}

进制转换

Tue, 18 Feb 2025 11:11:32 +0800

十进制转其他进制

#include 
using namespace std;

string s="0123456789ABCDEF";

void solve(int x,int m)
{
 // 递归
 if(x/m) solve(x/m,m);
 cout st;
 while (x)
 {
 st.push(x%m);
 x/=m;
 }
 while (!st.empty()){
 cout>x>>m;
 solve(x,m);
 return 0;
}

其他进制转十进制

#include 
using namespace std;

int n, m;
string es = "0123456789ABCDEF";

int main()
{
 cin >> n >> m;
 string s;
 cin >> s;
 int ans = 0;
 for (int i = 0; i < n; i++)
 {
 ans *= m;
 ans += es.find(s[i]);
 }
 cout << ans << '\n';
 return 0;
}

最大公因数（GCD）和最小公倍数（LCM）

Tue, 18 Feb 2025 01:24:30 +0800

// 计算两个数的 GCD
int gcd(int a, int b)
{
 while (b) // b!=0
 {
 int r = a % b;
 a = b;
 b = r;
 }
 return a;
}

// 计算两个数的 LCM
int lcm(int a, int b)
{
 return a / gcd(a, b) * b; // 先除后乘，避免溢出
}

// 计算三个数的 GCD
int gcd3(int a, int b, int c) {
 return gcd(gcd(a, b), c);
}

// 计算三个数的 LCM
int lcm3(int a, int b, int c) {
 return lcm(lcm(a, b), c);
}

算法 on 蛋蛋忧桑

ST稀疏表 (Sparse Table)

算法设计与分析：要点总结-3

贪婪算法（Greedy Algorithm）

1. 基本思想

2. 贪婪问题分类

贪婪算法与问题复杂性

经典例题

1. 工资分发问题（类似找零问题）

2. 活动安排问题

3. 多机调度问题

重要贪婪算法

1. Huffman树构造（最优编码问题）

2. 单源最短路径：Dijkstra算法

3. 最小生成树

算法设计与分析：要点总结-2

分治算法

二分法

重要例题

重要算法

冒泡排序

插入排序

快速排序

归并排序

算法竞赛读入数据相关操作

读入带空格的字符串

循环读入

快读

(2) 跳过输入 %*

(3) 宽度限制 %Ns

(4) 混合输入数字和字符串

(5) 检测输入结束（EOF）

printf 的高级用法

(1) 格式化输出

(2) 动态指定宽度/精度

(3) 输出 % 符号

(4) 打印字符串（限制长度）

(5) 对齐 + 填充

【转载】赛前小记 | 往期视频总结

首先是蓝桥杯的注意事项：

二分

BFS - 一石惊起千层浪，泛起层层涟漪~

整体思路

步骤

DP

图论板子

双指针&前缀和

acwing799最长连续不重复子序列

算法设计与分析：要点总结-1

算法概述

算法的5大特性

算法与计算过程的区别

算法描述的主要语言

渐进表示

定义

多项式定理

常见的多项式/指数限界函数

渐进符号O运算性质

重要例题

冒泡排序

警察抓小偷

竞赛预测

楼梯台阶问题

Hanoi塔

整数的划分

猴子吃桃问题

杨辉三角形

穿越沙漠问题（重点在于如何理解其思想）

牛顿迭代法

蛮力法

重要例题

百钱百鸡问题

解数字迷（ABCAB X A = DDDDDD）

狱吏问题（蛮力->数学技巧->深入挖掘数学规律）

二分查找与二分答案

AcWing789. 数的范围

P1182数列分段 Section II

P1163银行贷款

P3743小鸟的设备

动态规划做题步骤

**(2) 跳过输入 `%*`**

(3) 宽度限制 `%Ns`

`printf` 的高级用法

(3) 输出 `%` 符号

LCR 091. 粉刷房子简单dp

413. 等差数列划分如果满足等差，则f[i] = f[i - 1] + 1, 否则为0

279. 完全平方数简单预处理，最后一步：选择某个数作为最后一个

91. 解码方法正序dfs好写

646. 最长数对链最长上升子序列模板 + 排序

918. 环形子数组的最大和找找最大和、最小和和总和的关系

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性，01转移实现dfs不需要传vector的参数

1105. 填充书架枚举选哪个，转移方程有教学意义

1416. 恢复数组枚举选哪个，集合转移

2466. 统计构造好字符串的方案数爬楼梯

1043. 分隔数组以得到最大和枚举选哪个，集合转移

2400. 恰好移动 k 步到达某一位置的方法数目要对mem数组做偏移，`mem[now + N][cnt]` ，选其中一个的思路

1335. 工作计划的最低难度枚举选哪个思路，集合转移

7006. 销售利润最大化集合转移，预处理endi，选或不选

2008. 出租车的最大盈利选或不选

1235. 规划兼职工作选或不选 1751. 最多可以参加的会议数目 II 类似 2054. 两个最好的不重叠活动

376. 摆动序列考虑相邻两个数大小问题，枚举选哪个模型，dp转移可以直接01转移

2786. 访问数组中的位置使分数最大枚举每个数选或不选，记录上的数的奇偶性

1186. 删除一次得到子数组最大和子数组最大和 + 记录删没删

2369. 检查数组是否存在有效划分划分型dp 好像用不了记忆化搜索？

2466. 统计构造好字符串的方案数爬楼梯

P1149 火柴棒等式指数 + 预处理