小鲸鱼的梦境
0%

洛谷刷题记录

发表于 更新于 分类于 Valine：
本文字数： 23k 阅读时长 ≈ 21 分钟

前言

本文为洛谷刷题记录, 对应题目网址为 https://www.luogu.com.cn/problem/ 后面加上题目编号 如https://www.luogu.com.cn/problem/P1000

洛谷在线IDE: https://www.luogu.com.cn/ide

做题顺序题单来源: https://studyingfather.com/archives/841

使用三种编程语言，分别是 Python, C++, Java, 虽然没有标签但三种语言都有各自的特点应该很好辨认:

  • C++ 的带有头文件典型的如 #include <bits/stdc++.h>, 一般也有 using namespace std;
  • Java 代码一般是 public class Main 类，以及 import Java.util.*;
  • 除了上述两种剩下的就是 Python 代码了，和前面两种语言相比特点是没有分号和大括号
  • 用什么语言做题看心情，不保证每题都有三语言解法

小技巧

C++字符串流

但是对于大量数据只能一个数一个数转换，颇为繁琐

还有一种方法就是 stringstream (使用stringstream 需包含头文件 <sstream>）

1
2
3
4
5
int a = 123, b = 456, c = 789;

stringstream ss;

ss << a << b << c;

以上几行把a b c三个变量读入字符串流中，这样就可以把a b c三个变量无缝衔接起来，但是需要注意的是，stringstream型不能直接输出，也不支持迭代器，需要利用stringstream类的成员函数str()才能把它当成普通字符串来用，例如

1
string s = ss.str();

而把字符串转为数值的话也是用stringstream，例如上面的ss就可以转换为一个int型

1
2
3
int i;

ss >> i;

以上都是C++的方法，c语言有sprintf和sscanf，对应stringstream字符串流的读和写，<stdlib.h>中还有数值与字符串相互转换的iota和atoi函数，感兴趣的可以自己去了解。用c语言的sprintf比C++的字符串流效率高，但是我还是想用C++的字符串，为啥？因为C++字符串的可拓展性和灵活性比较高嘛hhhh

C++输入输出问题

关同步，不能 cin, scanf 和 cout, printf 混用了，但能加快 cin, cout 的速度, 注意也不要用 endl 而用 "\n" 代替

1
2
3
4
5
6
7
8
9
10
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    // 解题代码
    memset(vis,0,sizeof(vis));//初始化数组
}

输入输出重定向

1
2
3
4
5
6
7
#include <cstdio>
int main() {
    // 标准声明：FILE *freopen( const char *path, const char *mode, FILE *stream );
    freopen("P1000.in", "r", stdin);  // 输入流重定向
    freopen("P1000.out", "w", stdout);  // 输出流重定向
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import Java.io.FileInputStream;
import Java.io.FileNotFoundException;
import Java.io.FileOutputStream;
import Java.io.PrintStream;
import Java.util.Scanner;

public class Main {
    public static void main(String[] args) throws FileNotFoundException {
        // 标准输入流重定向
        System.setIn(new FileInputStream("luogu.in"));
        // 标准输出流重定向
        System.setOut(new PrintStream(new FileOutputStream("luogu.out")));
        Scanner sc = new Scanner(System.in);
        // 设置分隔符（可以使用正则匹配）
        sc.useDelimiter("\n");
        System.out.println(sc.nextLine());
        sc.close();
    }
}

快速幂和快速素数判断

  • 最简单的方法是对 \(2 ~ \sqrt{n}\) 进行取余测试
  • 给出了数据范围可以直接打出素数表
  • Rabin-Miller测试（底分别是\(2,3,5,7,11,13,17\)的7次测试最小反例是 \(341550071728321\), 在该范围内可以认为 “伪素数” 就是 素数）（\(2, 325, 9375, 28178, 450775, 9780504, 1795265022\)这组数在 \(2^{64}\)内都没有反例）
  • 再优化，快速幂，FFT等等都能上，不过数据量没大到需要这些优化的程度

Rabin-Miller测试

摘自知乎

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
typedef long long ll;
ll qpow(ll a, ll n, ll p)    // 快速幂
{
    ll ans = 1;
    while (n) {
        if (n & 1)
            ans = (__int128)ans * a % p;    // 注意！中间结果可能溢出，需要使用__int128过渡
        a = (__int128)a * a % p;
        n >>= 1;
    }
    return ans;
}
bool is_prime(ll x) {
    if (x < 3)    // 特判1，2
        return x == 2;
    if (x % 2 == 0)    // 特判偶数
        return false;
    ll A[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022}, d = x - 1, r = 0;
    while (d % 2 == 0)    // 算出d, r
        d /= 2, ++r;
    // 或：r = __builtin_ctz(d), d >>= r;
    for (auto a : A) {
        ll v = qpow(a, d, x);    // a^d
        // 如果a^d≡0，说明是a是x的倍数；如果a^d≡1或-1，说明这串数接下来一定都是1，不用继续计算
        if (v <= 1 || v == x - 1)
            continue;
        for (int i = 0; i < r; ++i) {
            v = (__int128)v * v % x;         // 同样使用__int128过渡
            if (v == x - 1 && i != r - 1)    // 得到-1，说明接下来都是1，可以退出了
            {
                v = 1;
                break;
            }
            // 在中途而非开头得到1，却没有经过-1，说明存在其他数字y≠-1满足y^2≡1，则x一定不是奇素数
            if (v == 1)
                return false;
        }
        if (v != 1)    // 查看是不是以1结尾
            return false;
    }
    return true;
}

自己改写的(甚至可以说是抄的。。。)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
long quickpow(int x, int n, int mod) {
    // x ^ n % mod 快速幂
    long ans = 1;
    while (n != 0) {
        if (n & 1 == 1)
            ans = ans * x % mod;
        x = x * x % mod;
        n >>= 1;
    }
    return ans;
}

bool isprime(int x) {
    if (x < 3) return x == 2;
    if (x % 2 == 0) return false;
    int s[] = {2, 3, 5, 7, 11, 13, 17};
    int d = x - 1, r = 0;
    while (d % 2 == 0) {
        d >>= 1;
        ++r;
    }
    for (int b : s) {
        long y = quickpow(b, d, x);
        if (y == 1 || y == 0 || y == x - 1) continue;
        for (int i = 0; i < r; ++i) {
            y = y * y % x;
            if (y == x - 1 && i != r - 1) {
                y = 1;
                break;
            }
            if (y == 1) return false;
        }
        if (y != 1) return false;
    }
    return true;
}

矩阵快速幂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class Main {
    public int[][] matrix_mul(int[][] A, int[][] B, int mod) {
        // 简单矩阵乘法
        int r = A.length, c = B[0].length, d = B.length;
        if (d != A[0].length) // 不合理的矩阵乘法
            return null;
        int[][] s = new int[r][c];
        for (int i = 0; i < r; ++i) {
            for (int k = 0; k < d; ++k) {
                long tmp = (long) A[i][k];
                for (int j = 0; j < c; ++j) {
                    s[i][j] = (int) ((tmp * B[k][j] + s[i][j]) % mod);
                }
            }
        }
        return s;
    }

    public int[][] quickpow(int[][] A, int n, int mod) {
        // 矩阵快速幂
        int r = A.length;
        // 初值为 单位矩阵
        int[][] s = new int[r][r];
        for (int i = 0; i < r; ++i)
            s[i][i] = 1;
        while (n != 0) {
            if ((n & 1) == 1)
                s = matrix_mul(s, A, mod);
            A = matrix_mul(A, A, mod);
            n >>= 1;
        }
        return s;
    }

    public int[][] matrix_mul(int[][] A, int[][] B) {
        // 简单矩阵乘法(不取模版本)
        int r = A.length, c = B[0].length, d = B.length;
        if (d != A[0].length) // 不合理的矩阵乘法
            return null;
        int[][] s = new int[r][c];
        for (int i = 0; i < r; ++i) {
            for (int k = 0; k < d; ++k) {
                for (int j = 0; j < c; ++j) {
                    s[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return s;
    }

    public int[][] quickpow(int[][] A, int n) {
        // 矩阵快速幂(不取模版本)
        int r = A.length;
        // 初值为 单位矩阵
        int[][] s = new int[r][r];
        for (int i = 0; i < r; ++i)
            s[i][i] = 1;
        while (n != 0) {
            if ((n & 1) == 1)
                s = matrix_mul(s, A);
            A = matrix_mul(A, A);
            n >>= 1;
        }
        return s;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from typing import List

def matrix_mul(x: List[List[int]], y: List[List[int]], mod: int = 0) -> List[List[int]]:
    """矩阵乘法"""
    n1, n2, m1, m2 = len(x), len(x[0]), len(y), len(y[0])
    if n2 != m1:  # 无法做矩阵乘法
        return False
    ans = []
    for i in range(n1):
        # row = [sum((x[i][k] * y[k][j] % mod) if mod else x[i][k] * y[k][j] for k in range(m1)) for j in range(m2)]
        row = []
        for j in range(m2):
            s = 0
            for k in range(m1):
                if mod:
                    s += x[i][k] * y[k][j] % mod
                else:
                    s += x[i][k] * y[k][j]
            row.append(s)
        ans.append(row)
    return ans


def quickpow(x: List[List[int]], n: int, mod: int = 0) -> List[List[int]]:
    """矩阵快速幂"""
    # 初值是与 x 同阶的单位矩阵
    s = len(x)
    ans = [[int(i == j) for j in range(s)] for i in range(s)]
    while n:
        if n & 1:
            ans = matrix_mul(ans, x, mod)
        x = matrix_mul(x, x, mod)
        n >>= 1
    return ans

题单

附上题单，防止某天链接崩溃了, 也记录下做完的题目

Part 0 试机题

三道试机题目。

Part 1 入门阶段

本部分内容针对入门 OIer ，主要是语言基础内容。

Part 1.1 从零开始

语言基础题。

Part 1.2 数组基础

数组可以用于存储大量的信息。

Part 1.3 字符串基础

字符串是特殊的数组，但它也有很多自身的特点。

Part 1.4 函数，递归及递推

这是初学者最难理解的部分，建议画出递归图来理解递归的过程。

Part 2 基础算法

这一部分的内容包含了 OI 中的基础算法，供各位巩固基础。

当然，这里面也有一些难度比较高的题目。

Part 2.1 模拟

模拟，顾名思义就是题目要求你做什么你就做什么，这样的题目很考验选手的代码组织能力。

这里不仅仅有非常基础的模拟，也有一些非常复杂的题目。

Part 2.2 排序算法

通过排序，我们可以将数据有序化，这让我们对数据的处理方便了很多。

Part 2.3 二分答案

对一个满足单调性质的问题，我们可以采用二分答案的方法来解决。

Part 2.4 分治

分治，即分而治之，将大问题分解为小问题，分别求解，最后合并结果。

Part 2.5 贪心

贪心，指的是决策时都采取当前最优解的算法。有的时候，这样做确实可以获得最优解。

Part 2.6 构造

构造题是一种形式灵活多样的题型。正是因为这个特点，使得构造题没有一种通用的方法。

Part 2.7 高精度

在 C++ 中，long long 都无法表示我们需要的整数时怎么办？那就用Python高精度吧！

Part 2.8 前缀和 & 差分

前缀和是一种重要的预处理，能大大降低查询的时间复杂度，而差分则是一种和前缀和相对的策略。

Part 3 搜索

搜索其实就是高级的枚举，很多题目都可以用搜索完成。就算不能，搜索也是骗分神器。

Part 3.1 深度优先搜索

深度优先搜索（DFS），即按照深度优先的顺序搜索的算法。

深度优先搜索一般使用栈来实现。

Part 3.2 广度优先搜索

广度优先搜索（BFS），即优先扩展浅层节点，逐渐深入的搜索算法。

广度优先搜索一般使用队列来实现。

Part 3.3 记忆化搜索

通过将已经遍历的状态记录下来，从而减少重复的搜索量，这就是记忆化搜索。

动态规划的时候，记忆化搜索也是一种高效简洁的实现方式。

Part 3.4 搜索的剪枝

对于一些不必要搜索的部分，我们可以避免访问这些状态，从而提高搜索效率。

Part 3.5 双向搜索

在搜索时，如果能从初态和终态出发，同时进行搜索，就可以减小搜索树的规模，提高时间效率。

Part 3.6 A*

在 BFS 中，如果能设计一个合理的估价函数，就可以更快扩展到最优解。这就是 A*算法。

Part 3.7 IDA*

像 BFS 那样，每次只扩展一层节点，却采用 DFS 方式来遍历搜索树，这就是迭代加深搜索。

再加上一个估价函数来减小搜索量，就是 IDA*了。

Part 3.8 DLX

算法 X 是通过回溯法求解精确覆盖问题的算法，而删除列这一操作可以使用舞蹈链加速。

Part 4 动态规划

动态规划是一种重要的思维方法，通过利用已有的子问题信息高效求出当前问题的最优解。

Part 4.1 线性动态规划

线性动态规划，即具有线性阶段划分的动态规划。

Part 4.2 背包动态规划

背包动态规划是线性动态规划中特殊的一类，NOIP中考到的次数也不少。

Part 4.3 区间动态规划

区间动态规划一般以区间作为动态规划的阶段。

Part 4.4 树形动态规划

树形动态规划，即在树上进行的动态规划。

因为树的递归性质，树形动态规划一般都是递归求解的。

Part 4.5 状态压缩动态规划

将一个状态压缩为一个整数（通常为二进制数），就可以在更为方便地进行状态转移的同时，达到节约空间的目的。

Part 4.6 倍增优化动态规划

利用倍增的方式，我们可以将状态转移的效率大大提高。

Part 4.7 数据结构优化动态规划

利用数据结构来维护已有信息，也可以达到优化状态转移的目的。

Part 4.8 单调队列优化动态规划

借助单调队列，排除不可能的决策，可以起到优化状态转移的效果。

Part 4.9 斜率优化动态规划

通过用单调队列维护一个凸壳，来达到优化转移的目的。

Part 4.10 决策单调性优化动态规划

利用决策间的递变规律，也能实现优化状态转移的目的。

Part 4.11 数位统计类动态规划

统计一个区间中满足条件的数有多少，就是数位统计类动态规划。

Part 4.12 轮廓线动态规划

轮廓线动态规划（即常说的插头 DP）是一种特殊的状压动态规划，通过以轮廓线为状态来实现状态转移。

Part 5 字符串

字符串问题有很多自己的特点。

Part 5.1 字符串哈希

字符串哈希通过牺牲很小的准确率，达到快速进行字符串匹配的效果。

Part 5.2 KMP

KMP 算法可以用来解决模式串匹配问题。

Part 5.3 Manacher

Manacher 可以在线性时间内求出一个字符串的最长回文子串。

Part 5.4 Trie树

Trie树可以像查字典一样把多个字符串组织到一棵树上。

Part 5.5 AC自动机

AC自动机可以看成是 KMP 和 Trie 的结合体，用于解决多字符串匹配问题。

Part 5.6 回文自动机

回文自动机是解决回文串问题的有力工具。

Part 5.7 后缀数组

后缀数组可以解决很多字符串匹配的问题。

Part 5.8 后缀自动机

后缀自动机是一种处理字符串问题的强大工具。

Part 6 数学

OI 中的数学知识很多，也有些杂乱。

Part 6.1 位运算

将十进制整数转换为二进制后，有很多按位运算的运算符。

如果能善于利用位运算的一些性质，往往能达到事半功倍的效果。

Part 6.2 整除相关

与整除相关的概念有很多，比较常用的有素数，最大公约数和欧拉函数。

Part 6.2.1 素数

素数，指的是除 1 和它本身之外没有其他约数的数。

Part 6.2.2 最大公约数

如果两个数有一个共同的约数，那么这个约数就被称为公约数。最大公约数就是指这两个数的所有公约数中，最大的一个。

求解两个数的最大公约数，可以采用欧几里得算法解决。

Part 6.2.3 欧拉函数

欧拉函数 ​ 表示了小于 ​ 的数字中，与 ​ 互质的数字个数。

Part 6.3 同余方程

求解同余方程往往可以引出不少话题。

Part 6.3.1 线性同余方程&乘法逆元

线性同余方程是同余方程中最基础的内容。

Part 6.3.2 中国剩余定理

中国剩余定理可以快速解一元线性同余方程组。

Part 6.3.3 高次同余方程

BSGS 算法可以高效计算离散对数。

而高次剩余的求解更加复杂，其中二次剩余作为高次剩余中比较特殊的情况，可以使用 Cipolla 法求解。

Part 6.4 博弈论

博弈论考虑游戏中的个体的预测行为和实际行为，并研究它们的优化策略。

Part 6.5 概率与期望

概率和期望是紧密相连的，OI 中往往会出现和概率期望相关的动态规划问题。

Part 6.6 组合数学

组合数学常常与计数问题，概率期望紧密相连。

Part 6.6.1 排列组合

排列组合是组合数学的基础。

Part 6.6.2 卡特兰数&斯特林数

卡特兰数和斯特林数是两类常见的组合递推数列。

Part 6.6.3 容斥原理

容斥原理常常用于解决集合的计数问题。

Part 6.7 线性代数

线性代数主要用于解决线性关系问题。

Part 6.7.1 矩阵

利用矩阵优化数列递推，可以实现复杂度从线性到对数级的转变。

Part 6.7.2 高斯消元

高斯消元可以用来求解方程组。

Part 6.7.3 线性基

线性基可以求解最大异或和的一类问题。

Part 6.8 多项式

对多项式的运算进行优化，从而能够解决规模更大的问题。

Part 6.9 莫比乌斯反演

运用莫比乌斯反演，我们可以将一些函数转化，从而降低计算难度。

Part 6.10 筛法

利用数列的性质，有多种筛法可以求出我们想要的信息。

Part 6.11 线性规划

线性规划是研究线性约束条件下线性目标函数极值问题的方法。

Part 6.12 数值方法

在算法领域，有很多求近似值的数值方法。

Part 6.12.1 三分法

三分法可以求出一个单峰 / 单谷函数的极值。

Part 6.12.2 自适应辛普森法

自适应辛普森法可以高效求出给定函数的数值积分。

Part 6.13 置换群

置换群通常用来解决一些涉及“本质不同”的计数问题。

Part 7 数据结构

灵活地运用数据结构可以高效地查询并处理需要的信息。

Part 7.1 链表

在一个数列中高效插入一个元素，链表毫无疑问是最好的选择。

Part 7.2 栈

栈，是一种后进先出（FILO）的数据结构。

Part 7.3 队列

队列，是一种先进先出（FIFO）的数据结构。

Part 7.4 并查集

并查集常用于处理一些不相交集合的合并和查询问题。

Part 7.5 二叉堆

二叉堆是一棵完全二叉树，堆中某个节点的值总是不大于或不小于其父节点的值。

Part 7.6 ST表

ST表可以离线查询区间最值。

Part 7.7 树状数组

树状数组是一种简洁高效的树形数据结构。

Part 7.8 线段树

线段树的通用性比树状数组更强，可以处理更多涉及区间操作的题目。

Part 7.9 分块

分块是一种非常通用的暴力方法，虽然效率不如线段树和树状数组，但可以解决很多线段树和树状数组处理不了的问题。

Part 7.10 可并堆

可并堆分为左偏树和配对堆两种，它们都具有堆的性质，且可以高效合并。

Part 7.11 主席树

主席树，即可持久化权值线段树。

Part 7.12 平衡树

二叉搜索树可以用来维护有序序列。

为了保证查询效率，有多种使二叉搜索树保持平衡的实现方法。

Part 7.13 树链剖分

树链剖分可以将任意一条树上路径划分成若干条连续的链，并用线段树等数据结构高效维护链上信息。

Part 7.14 树套树

树套树可以用来维护多维度信息。

Part 7.15 动态树

Link-Cut Tree 可以用来解决动态树一类问题。

Part 7.16 可持久化数据结构

可持久化数据结构实现了在更新信息的时候保留历史版本。

Part 7.17 K-D Tree

K-D Tree 是一种高效处理 ​ 维信息的数据结构。

Part 7.18 珂朵莉树

珂朵莉树，是一种基于 std::set 的暴力数据结构，在数据随机的情况下表现优秀。

Part 8 图论

图论是数学的一个分支，它以图为研究的对象。

Part 8.1 图的存储与遍历

这里的图论内容都比较简单，涉及图的存储以及遍历图的方式。

Part 8.2 最短路问题

很多题目都可以转化为最短路的模型。因此，掌握最短路算法非常重要。

Part 8.3 树上问题

作为一种特殊的图，树上的问题具有很多鲜明的特点。

Part 8.3.1 二叉树

二叉树是一种特殊的树，它有很多特殊的性质。

Part 8.3.2 树的直径

树的直径被定义为树上最远的两点间的距离。

计算树的直径，可以通过两遍 DFS 解决。

Part 8.3.3 最近公共祖先

两个点的最近公共祖先，即两个点的所有公共祖先中，离根节点最远的一个节点。

求解最近公共祖先，常用的方法是树上倍增或者树链剖分。

Part 8.4 生成树

用 ​ 条边将图上的 ​ 个点连接起来，形成的树就被称为生成树。

Part 8.5 拓扑排序

将一个有向无环图排序，使得所有排在前面的节点不能依赖于排在后面的节点，这就是拓扑排序。

Part 8.6 差分约束

差分约束要解决的问题是：求出一组 ​ 元不等式的一组解，使得所有约束关系都能得到满足。

Part 8.7 图的连通性相关

利用 Tarjan 算法，我们可以解决很多与图的连通性相关的问题。

Part 8.8 二分图

二分图上的不少问题都可以转化成网络流解决，当然也有独特的其他方法。

Part 8.9 网络流

网络流是图论中一个重要的分支，很多题目都可以通过建立网络流的模型来解决。

Part 8.9.1 最大流

最大流，即求网络中最大的流量。

Part 8.9.2 最小割

最小割，即求一个边权最小的边集，使得源点和汇点不再连通。

可以证明，最大流=最小割。

Part 8.9.3 费用流

在网络流中给边加上一个参数——费用，就出现了费用流。

Part 8.9.4 上下界网络流

在网络流问题中给每条边的流量增加一个下界，就有了上下界网络流。

Part 8.10 2-SAT

k-SAT 问题的目标是对一些布尔变量赋值，满足限定的条件。

在 k-SAT 问题中，2-SAT 问题属于较为容易解决的一类。

Part 8.11 点分治

点分治是一种可以高效统计树上路径信息的算法。

Part 8.12 虚树

将一些无用的点从树上删去，从而达到降低树的规模的效果。

Part 8.13 矩阵树定理

矩阵树定理可以解决图的生成树计数问题。

Part 9 计算几何

试着用计算机来解决几何问题吧！

Part 9.1 凸包

凸包指在平面上能包含所有给定点的最小凸多边形。

Part 9.2 旋转卡壳

旋转卡壳是一种求出凸包所有对踵点对的算法。

Part 9.3 半平面交

多个半平面的交集称之为半平面交。

Part 10 杂项

这里的专题，有很多都难以纳入前面的类别中，故将他们单独列入了杂项。

Part 10.1 模拟退火

模拟退火是一种随机化算法。当一个问题的方案数量极大（甚至是无穷的）而且不是一个单峰函数时，我们常使用模拟退火求解。

Part 10.2 0/1 分数规划

0/1 分数规划用来求一个分式的极值。

Part 10.3 离线算法

当题目不要求强制在线时，我们可以一次性读入所有询问来处理。

Part 10.3.1 CDQ 分治

CDQ 分治是一个基于分治思想的离线算法。

Part 10.3.2 整体二分

整体二分，顾名思义就是把多个查询一起二分解决。

Part 10.3.3 莫队

莫队算法可以解决不少离线区间询问问题。

Part 10.4 奇怪的题目

OI 界中有一些非常规套路的题目，这里放出来分享。

Part 10.5 非传统题

在 NOI 等比赛中，非传统题正越来越频繁出现。

非传统题主要包括以下几类：提交答案题，交互题，通信题。

Part 10.5.1 提交答案题

给你一些输入，你只需要提交这些输入对应的答案，即为提交答案题。

end

有必要二刷的题目

没做完的题目

--- ♥ end ♥ ---

欢迎关注我呀~