# C++ 算法竞赛（ICPC/CCPC）标准框架与流加速完全指南

在算法竞赛中，一个结构良好、支持快速 I/O 且不易写出 Bug 的基础模板，是保证选手在有限时间内稳定发挥的关键。

---

## 目录
1. [ICPC 标准竞赛基础模板](#一icpc-标准竞赛基础模板)
2. [头文件与万能头机制](#二头文件与万能头机制)
3. [I/O 流加速核心控制（关闭同步流）](#三io-流加速核心控制)
4. [常用类型别名与宏定义](#四常用类型别名与宏定义)
5. [多组测试用例（Multi-Testcases）结构与避坑](#五多组测试用例结构与避坑)
6. [进阶技巧：本地调试与极致快读](#六进阶技巧本地调试与极致快读)

---

## 一、ICPC 标准竞赛基础模板

以下模板兼容 **C++11 及以上标准**，采用模块化的 `solve()` 设计，便于切换单测试用例与多测试用例：

```cpp
#include <bits/stdc++.h>
using namespace std;

// 常用类型别名
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

// 常用常量
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1e9 + 7; // 或 998244353

// 核心解题函数
void solve() {
    int n;
    if (!(cin >> n)) return;
    
    // 业务逻辑写在这里
    cout << n << "\n";
}

int main() {
    // 1. 关闭 I/O 同步，开启流加速
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

// 2. 控制测试用例组数
    int T = 1;
    // cin >> T; // 如果题目包含多组数据，取消本行注释
    
    while (T--) {
        solve();
    }

return 0;
}
```

---

## 二、头文件与万能头机制

### 1. 万能头文件 `<bits/stdc++.h>`
* **包含内容**：它并不是 C++ 标准库的一部分，而是 GNU GCC 编译器的扩展头文件，包含了几乎所有 C++ 标准库组件（如 `<iostream>`, `<vector>`, `<algorithm>`, `<cmath>`, `<map>`, `<queue>` 等）。
* **优缺点**：
  * **优点**：无需记忆冗长的头文件列表，极大地提高敲代码的速度。
  * **缺点**：编译时间稍有增加（竞赛中评测时影响可忽略不计）。在 MSVC (Visual Studio) 默认环境下不支持，需自行配置。

### 2. 命名空间 `using namespace std;`
竞赛中普遍直接引入 `std` 命名空间。
> ⚠️ **避坑提醒**：避免定义与 `std` 冲突的全局变量名，例如：
> - `hash`（与 `std::hash` 冲突）
> - `next`（与 `std::next` 冲突）
> - `rank`（与 `std::rank` 冲突）
> - `y1`, `y0`, `yn`（在 `<cmath>` 中为 Bessel 函数）

---

## 三、I/O 流加速核心控制

C++ 中的 `std::cin` 和 `std::cout` 默认较慢，主要原因有两个：**与 C 标准 I/O 缓冲区同步** 以及 **`cin` 与 `cout` 的默认绑定刷新机制**。

### 1. 三行核心加速代码

```cpp
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
```

#### ① `std::ios::sync_with_stdio(false);`
* **原理**：C++ 为了保证选手可以混用 `scanf`/`printf` 与 `cin`/`cout`，默认开启了 C++ 流缓冲区与 C 标准 stdio 缓冲区的同步。
* **效果**：设为 `false` 后解除了同步，`cin/cout` 将拥有独立的缓冲区，读取速度大幅提升，**性能基本与 `scanf/printf` 持平甚至更快**。

#### ② `std::cin.tie(nullptr);`
* **原理**：默认情况下，`cin` 与 `cout` 是**绑定（tied）**在一起的。这意味着每次执行 `cin` 之前，程序都会强制调用 `cout.flush()` 刷新输出缓冲区（确保交互题能先打印提示语，再等待用户输入）。
* **效果**：解绑后，`cin` 不会再触发无意义的 `cout` 刷新，大幅减少 I/O 阻塞。

#### ③ `std::cout.tie(nullptr);`
* **原理**：虽然 `cout` 默认并未绑定其他流，但作为模板规范写上，可以防止因复杂重定向导致的偶发绑定。

---

### 2. 致命杀手：`std::endl` vs `'\n'`

* **`std::endl` 的本质**：输出换行符 `'\n'` **并强制调用 `flush()` 刷新缓冲区**。
* **危害**：在输出 $10^5 \sim 10^6$ 行数据时，频繁触发系统调用 `flush()` 会导致程序直接 **TLE（Time Limit Exceeded）**。
* **准则**：
  * **常规题目**：一律使用 `'\n'` 或 `"\n"`。
  * **交互题（Interactive Problems）**：必须使用 `std::endl` 或手动 `fflush(stdout)` / `cout.flush()` 来传递信息给评测机。

---

### 3. 流加速后的【三大绝对禁忌】

1. ❌ **严禁混用 C 和 C++ 的 I/O**：一旦开启 `sync_with_stdio(false)`，**绝对不能**在代码中混用 `scanf`/`printf`/`getchar`/`puts` 与 `cin`/`cout`，否则会导致输入输出顺序错乱（Undefined Behavior）。
2. ❌ **不要在交互题中随意解绑 `cin.tie(nullptr)`**（除非每次输出都手动 `cout << endl` 或 `cout.flush()`）。
3. ❌ **不要依赖未刷新流的调试信息**：调试打印如果没加 `\n` 或没有 flush，程序奔溃时调试日志可能来不及输出。

---

## 四、常用类型别名与宏定义

在实战中，推荐保持宏的简洁，不宜过度缩写导致可读性崩塌。

```cpp
// 1. 类型缩写
using ll = long long;
using ull = unsigned long long;
using ld = long double;

// 2. 容器快速遍历
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()

// 3. 循环简化（根据个人习惯选配）
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

// 4. Pair 快速访问
#define fi first
#define se second
```

---

## 五、多测试用例结构与避坑

ICPC/Codeforces 绝大多数题目是多组测试数据（$T$ 组输入）。

### 常见 Bug：全局变量未彻底初始化

```cpp
const int N = 200005;
int a[N];
vector<int> adj[N]; // 邻接表

void solve() {
    int n;
    cin >> n;
    
    // ⚠️ 极其危险的错误写法：
    // memset(a, 0, sizeof(a));  // 如果 T=10000 且 N=200000，每轮整体 memset 会直接 TLE！

// ✅ 正确做法：只清空本轮用到的范围
    for (int i = 1; i <= n; ++i) {
        a[i] = 0;
        adj[i].clear();
    }

for (int i = 1; i <= n; ++i) cin >> a[i];
    // ...
}
```

> **复杂度避坑准则**：在多组数据下，复杂度必须与 $\sum N$ 挂钩。每次清理全局数组时，**只清空到当前 $n$ 的大小**，切忌无脑 `memset(arr, 0, sizeof(arr))`。

---

## 六、进阶技巧：本地调试与极致快读

### 1. 本地重定向调试宏（文件 I/O 隔离）

在本地写题时，通常建立 `in.txt` 将测试用例粘贴进去，避免反复在控制台复制粘贴：

```cpp
int main() {
    // 仅在本地非评测机环境下执行文件重定向
    #ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    #endif

ios::sync_with_stdio(false);
    cin.tie(nullptr);

int T = 1;
    if (cin >> T) {
        while (T--) solve();
    }
    return 0;
}
```
*大部分主流 OJ（Codeforces, AtCoder, PTA, 洛谷）都会在后台内置 `ONLINE_JUDGE` 宏定义，提交时该代码块会自动失效。*

---

### 2. 极致快读（Fast I/O - `getchar` 版）

在少数极端卡常题目（例如输入数据量在 $10^7$ 级别，常规流加速仍可能超时）中，可以使用基于 `getchar` / `fread` 的快读模板：

```cpp
// 快速读取任意整型（支持正负数）
template <typename T>
inline void read(T &x) {
    x = 0;
    bool neg = false;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') neg = true;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 3) + (x << 1) + (ch ^ 48); // 等价于 x * 10 + (ch - '0')
        ch = getchar();
    }
    if (neg) x = -x;
}

// 快速写入整数
template <typename T>
inline void write(T x) {
    if (x < 0) {
        putchar('-');
        x = -x;
    }
    if (x > 9) write(x / 10);
    putchar(x % 10 + '0');
}
```

---

## 七、总结对比表

C++ 算法竞赛（ICPC/CCPC）标准框架与流加速完全指南

在算法竞赛中，一个结构良好、支持快速 I/O 且不易写出 Bug 的基础模板，是保证选手在有限时间内稳定发挥的关键。

一、ICPC 标准竞赛基础模板

以下模板兼容 C++11 及以上标准，采用模块化的 solve() 设计，便于切换单测试用例与多测试用例：

#include <bits/stdc++.h>
using namespace std;

// 常用类型别名
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

// 常用常量
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1e9 + 7; // 或 998244353

// 核心解题函数
void solve() {
    int n;
    if (!(cin >> n)) return;

    // 业务逻辑写在这里
    cout << n << "\n";
}

int main() {
    // 1. 关闭 I/O 同步，开启流加速
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    // 2. 控制测试用例组数
    int T = 1;
    // cin >> T; // 如果题目包含多组数据，取消本行注释

    while (T--) {
        solve();
    }

    return 0;
}

二、头文件与万能头机制

1. 万能头文件 `<bits/stdc++.h>`

包含内容：它并不是 C++ 标准库的一部分，而是 GNU GCC 编译器的扩展头文件，包含了几乎所有 C++ 标准库组件（如 <iostream>, <vector>, <algorithm>, <cmath>, <map>, <queue> 等）。
优缺点：
优点：无需记忆冗长的头文件列表，极大地提高敲代码的速度。
缺点：编译时间稍有增加（竞赛中评测时影响可忽略不计）。在 MSVC (Visual Studio) 默认环境下不支持，需自行配置。

2. 命名空间 `using namespace std;`

竞赛中普遍直接引入 std 命名空间。

⚠️ 避坑提醒：避免定义与 std 冲突的全局变量名，例如： - hash（与 std::hash 冲突） - next（与 std::next 冲突） - rank（与 std::rank 冲突） - y1, y0, yn（在 <cmath> 中为 Bessel 函数）

三、I/O 流加速核心控制

C++ 中的 std::cin 和 std::cout 默认较慢，主要原因有两个：与 C 标准 I/O 缓冲区同步 以及 cin 与 cout 的默认绑定刷新机制。

1. 三行核心加速代码

ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);

① `std::ios::sync_with_stdio(false);`

原理：C++ 为了保证选手可以混用 scanf/printf 与 cin/cout，默认开启了 C++ 流缓冲区与 C 标准 stdio 缓冲区的同步。
效果：设为 false 后解除了同步，cin/cout 将拥有独立的缓冲区，读取速度大幅提升，性能基本与 scanf/printf 持平甚至更快。

② `std::cin.tie(nullptr);`

原理：默认情况下，cin 与 cout 是绑定（tied）在一起的。这意味着每次执行 cin 之前，程序都会强制调用 cout.flush() 刷新输出缓冲区（确保交互题能先打印提示语，再等待用户输入）。
效果：解绑后，cin 不会再触发无意义的 cout 刷新，大幅减少 I/O 阻塞。

③ `std::cout.tie(nullptr);`

原理：虽然 cout 默认并未绑定其他流，但作为模板规范写上，可以防止因复杂重定向导致的偶发绑定。

2. 致命杀手：`std::endl` vs `'\n'`

std::endl 的本质：输出换行符 '\n' 并强制调用 flush() 刷新缓冲区。
危害：在输出 $10^5 \sim 10^6$ 行数据时，频繁触发系统调用 flush() 会导致程序直接 TLE（Time Limit Exceeded）。
准则：
常规题目：一律使用 '\n' 或 "\n"。
交互题（Interactive Problems）：必须使用 std::endl 或手动 fflush(stdout) / cout.flush() 来传递信息给评测机。

3. 流加速后的【三大绝对禁忌】

❌ 严禁混用 C 和 C++ 的 I/O：一旦开启 sync_with_stdio(false)，绝对不能在代码中混用 scanf/printf/getchar/puts 与 cin/cout，否则会导致输入输出顺序错乱（Undefined Behavior）。
❌ 不要在交互题中随意解绑 cin.tie(nullptr)（除非每次输出都手动 cout << endl 或 cout.flush()）。
❌ 不要依赖未刷新流的调试信息：调试打印如果没加 \n 或没有 flush，程序奔溃时调试日志可能来不及输出。

四、常用类型别名与宏定义

在实战中，推荐保持宏的简洁，不宜过度缩写导致可读性崩塌。

// 1. 类型缩写
using ll = long long;
using ull = unsigned long long;
using ld = long double;

// 2. 容器快速遍历
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()

// 3. 循环简化（根据个人习惯选配）
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

// 4. Pair 快速访问
#define fi first
#define se second

五、多测试用例结构与避坑

ICPC/Codeforces 绝大多数题目是多组测试数据（$T$ 组输入）。

常见 Bug：全局变量未彻底初始化

const int N = 200005;
int a[N];
vector<int> adj[N]; // 邻接表

void solve() {
    int n;
    cin >> n;

    // ⚠️ 极其危险的错误写法：
    // memset(a, 0, sizeof(a));  // 如果 T=10000 且 N=200000，每轮整体 memset 会直接 TLE！

    // ✅ 正确做法：只清空本轮用到的范围
    for (int i = 1; i <= n; ++i) {
        a[i] = 0;
        adj[i].clear();
    }

    for (int i = 1; i <= n; ++i) cin >> a[i];
    // ...
}

复杂度避坑准则：在多组数据下，复杂度必须与 $\sum N$ 挂钩。每次清理全局数组时，只清空到当前 $n$ 的大小，切忌无脑 memset(arr, 0, sizeof(arr))。

六、进阶技巧：本地调试与极致快读

1. 本地重定向调试宏（文件 I/O 隔离）

在本地写题时，通常建立 in.txt 将测试用例粘贴进去，避免反复在控制台复制粘贴：

int main() {
    // 仅在本地非评测机环境下执行文件重定向
    #ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    if (cin >> T) {
        while (T--) solve();
    }
    return 0;
}

大部分主流 OJ（Codeforces, AtCoder, PTA, 洛谷）都会在后台内置 ONLINE_JUDGE 宏定义，提交时该代码块会自动失效。

2. 极致快读（Fast I/O - `getchar` 版）

在少数极端卡常题目（例如输入数据量在 $10^7$ 级别，常规流加速仍可能超时）中，可以使用基于 getchar / fread 的快读模板：

// 快速读取任意整型（支持正负数）
template <typename T>
inline void read(T &x) {
    x = 0;
    bool neg = false;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') neg = true;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 3) + (x << 1) + (ch ^ 48); // 等价于 x * 10 + (ch - '0')
        ch = getchar();
    }
    if (neg) x = -x;
}

// 快速写入整数
template <typename T>
inline void write(T x) {
    if (x < 0) {
        putchar('-');
        x = -x;
    }
    if (x > 9) write(x / 10);
    putchar(x % 10 + '0');
}

七、总结对比表

方式	易用性	性能表现	适用场景
未加速 `cin/cout`	高	较差（极易 TLE）	不推荐在竞赛中使用
`scanf / printf`	中（需记格式符）	优	基础 C 风格竞赛、格式化输出
流加速 `cin/cout` + `'\n'`	最高	优（与 scanf 相当）	各大算法竞赛首选标准
`fread / getchar` 快读	低（代码长）	极致（极限卡常）	数据量在 $10^6 \sim 10^7$ 以上的极端卡常题

—— 本文来自火龙信奥（义乌睿码科技）：义乌青少年信息学奥赛与编程教育平台，专注 CSP-J/S、NOIP、GESP 竞赛培训，线上线下融合教学，助力编程升学。网址：hlcoding.com

C++框架