1. 项目概述：为什么ACM选手需要一份自己的C++ STL总结

打ACM（国际大学生程序设计竞赛）的兄弟们都懂，赛场上时间就是一切。给你一道题，从读题、构思算法到敲代码、调试，整个过程可能就一两个小时。在这种高压环境下，你不可能现场去翻几百页的C++ Primer，更不可能去查cppreference.com的每个函数签名。你需要的是肌肉记忆——看到问题，手已经自动敲出了最合适的容器和算法。这份总结，就是帮你把STL（Standard Template Library）这把瑞士军刀，磨得又快又亮，让你在赛场上能信手拈来，把精力完全集中在算法逻辑本身，而不是语法细节上。

我见过太多新手，包括当年的我自己，在比赛时因为一个 vector 的下标越界，或者 sort 的比较函数写错，导致调试半天，最后痛失好局。这些坑，本质上都是对STL不够熟悉。这份总结的目的，就是帮你避开这些坑，把STL里最常用、最核心、最容易出错的部分，掰开揉碎了讲清楚。它不是一份完整的STL百科全书，而是一份经过实战筛选的“生存指南”。我们会聚焦在那些真正在ACM赛题中出现频率超过90%的组件和函数上，并且会重点强调它们的“坑点”和“最佳实践”。

2. 核心容器使用详解与避坑指南

STL容器是算法的基石，选对容器，问题就解决了一半。下面我们按使用频率和重要性，逐一拆解。

2.1 序列式容器：Vector, String, Deque

vector - 万能数组，但非万能 vector 是使用频率最高的容器，没有之一。它动态扩容的特性非常方便，但有几个关键点必须牢记：

• 初始化与预分配 ：在已知大概数据规模时，一定要使用 reserve() 预分配内存。比如你知道要存10万个 int ，直接 vector<int> v; v.reserve(100000); 。这能避免多次扩容带来的性能损失和迭代器失效。比赛时一个不经意的 push_back 导致 vector 扩容，可能让你原本O(n)的算法因为拷贝数据而超时。
• [] 与 at() 的区别 ： v[i] 不进行边界检查，访问越界是未定义行为，可能崩溃也可能输出奇怪结果； v.at(i) 会进行边界检查，越界抛出 std::out_of_range 异常。在ACM中，我们通常关闭异常（ -fno-exceptions 编译选项常见），且追求极致性能，所以都用 [] 。 这就要求你必须自己保证下标合法！ 这是很多段错误（Segmentation Fault）的根源。
• 迭代器失效 ：这是 vector 最大的坑。当你进行 push_back 、 insert 、 erase 、 resize 等可能引起内存重新分配的操作后， 所有指向该 vector 的迭代器、指针、引用都可能失效 。典型错误：在遍历容器时删除元素。

  // 错误示范：删除所有偶数
  vector<int> v = {1,2,3,4,5};
  for(auto it = v.begin(); it != v.end(); ++it) {
      if(*it % 2 == 0) {
          v.erase(it); // 删除后，it及其后面的迭代器全部失效！下次++it行为未定义。
      }
  }
  // 正确做法：利用erase返回值
  for(auto it = v.begin(); it != v.end(); ) {
      if(*it % 2 == 0) {
          it = v.erase(it); // erase返回被删除元素下一个位置的迭代器
      } else {
          ++it;
      }
  }
  // 或者使用remove-erase惯用法（后面算法部分会讲）
  

string - 不只是字符数组 C++的 string 是一个功能强大的类，但很多人只把它当 char[] 用。

• 与 char[] 的转换 ： c_str() 返回一个只读的C风格字符串指针，常用于需要 const char* 参数的函数（如 printf("%s", s.c_str()) ）。注意这个指针在 string 内容改变后可能失效。
• 拼接性能 ：频繁的 s = s + "a" + "b"; 会创建大量临时对象，效率低下。对于大量拼接，使用 += 操作符或者 append() 方法更高效。在C++11以后，也可以使用 std::to_string() 方便地将数字转为字符串再拼接。
• 子串操作 ： substr(pos, len) 非常常用，注意 len 的默认值是 npos ，意味着取到结尾。 find() 系列函数返回的是位置（ size_t 类型），找不到返回 string::npos 。判断是否找到一定要用 if(s.find(“sub”) != string::npos) ，不要直接 if(s.find(“sub”)) ，因为找到位置0时条件为假。

deque - 双端队列，何时使用？ deque 支持头尾O(1)时间的插入删除。它不像 vector 需要大片连续内存，而是分段连续，因此扩容代价更小。但它也有缺点：随机访问（ [] ）比 vector 慢一点，且内存占用稍高。

• 适用场景 ：需要频繁在序列两端进行插入删除操作时，例如BFS（广度优先搜索）的队列实现。虽然 queue 适配器默认就是用 deque 实现的，但如果你需要随机访问队列中的元素（某些特殊BFS题目），直接使用 deque 会更方便。
• 不适用场景 ：需要极致随机访问性能，或者绝大多数操作在尾部进行时， vector 仍是首选。

2.2 关联式容器：Set, Map及其无序版本

set/map - 基于红黑树的秩序维护者 它们内部元素是自动排序的（默认升序，可用自定义比较器），插入、删除、查找的复杂度都是O(log n)。

• 自定义排序 ：这是关键技巧。对于自定义结构体，你需要重载 < 运算符，或者提供一个仿函数（函数对象）。

  struct Point {
      int x, y;
      // 方法1：重载小于运算符
      bool operator<(const Point& other) const {
          return x < other.x || (x == other.x && y < other.y); // 先按x，再按y排序
      }
  };
  set<Point> s; // 可以直接使用
  
  // 方法2：使用仿函数
  struct Cmp {
      bool operator()(const Point& a, const Point& b) const {
          return a.x > b.x; // 按x降序排序
      }
  };
  set<Point, Cmp> s2;
  

• lower_bound 和 upper_bound ： s.lower_bound(val) 返回 第一个大于等于 val的元素的迭代器； s.upper_bound(val) 返回 第一个大于 val的元素的迭代器。这对于处理区间、查找临界值非常有用。注意，它们有成员函数版本（ s.lower_bound ）和全局函数版本（ std::lower_bound(s.begin(), s.end()) ）。对于 set/map ， 一定要用成员函数版本 ，因为全局版本是线性复杂度，成员函数版本是O(log n)。
• map 的 [] 操作符 ： m[key] 如果 key 不存在，会插入一个 key-default_value 的键值对。这有时很方便（比如做计数器 m[c]++ ），但有时很危险（比如你只想查询，却意外改变了map）。如果你只想查询，应该使用 find() 方法。

unordered_set/unordered_map - 基于哈希表的性能怪兽 在C++11之后，它们成为了处理大量数据、不需要顺序时的首选。查找、插入、删除的平均复杂度是O(1)，最坏O(n)。

• 哈希函数与相等判断 ：对于自定义类型，你需要提供两个东西：1) 哈希函数；2) 相等比较函数。

  struct MyHash {
      size_t operator()(const Point& p) const {
          return hash<int>()(p.x) ^ (hash<int>()(p.y) << 1); // 一个简单的组合哈希
      }
  };
  struct MyEqual {
      bool operator()(const Point& a, const Point& b) const {
          return a.x == b.x && a.y == b.y;
      }
  };
  unordered_set<Point, MyHash, MyEqual> us;
  

• 性能陷阱 ：哈希冲突会导致性能退化。如果题目故意构造哈希冲突的数据（哈希攻击）， unordered_map 可能退化成链表，导致超时。在知道数据范围不大或可以离散化时，用数组替代是更安全的选择。比赛时如果用了 unordered_map 莫名超时，可以尝试换成 map 看看。
• 内存与扩容 ： unordered_map 的内存占用比 map 高，因为它需要维护桶（buckets）。可以调用 reserve(n) 预分配空间来减少扩容次数。

2.3 容器适配器：Stack, Queue, Priority_queue

它们是基于底层容器（默认 deque 或 vector ）封装而成的，提供特定的接口。

• stack 和 queue ：接口简单。注意它们没有迭代器，不能遍历。 stack 常用于DFS递归转非递归、表达式求值、括号匹配。 queue 用于BFS。
• priority_queue - 优先队列（堆） ：这是实现Dijkstra最短路径算法、哈夫曼编码等贪心算法的利器。默认是 大顶堆 （最大元素在顶）。
  • 自定义比较器 ：与 set 相反。如果你想实现小顶堆，需要提供 greater 比较器。

    // 大顶堆（默认）
    priority_queue<int> pq;
    // 小顶堆
    priority_queue<int, vector<int>, greater<int>> min_pq;
    // 自定义结构体，重载<运算符（注意方向！）
    struct Node {
        int dist, id;
        bool operator<(const Node& other) const {
            return dist > other.dist; // 注意：想让dist小的优先级高，这里要写>
        }
    };
    priority_queue<Node> pq; // 此时top()得到的是dist最小的元素
    

  • 性能注意 ： priority_queue 的 push 和 pop 是O(log n)， top 是O(1)。它没有 find 或随机访问操作。如果需要修改堆中某个元素的值并调整堆（如Dijkstra算法中更新距离），标准库的 priority_queue 不支持，需要手写堆或者使用 set 来模拟（将 {dist, id} 作为元素，修改时先删除旧值再插入新值）。

3. 算法库高频函数实战解析

STL的 <algorithm> 库提供了大量泛型算法，熟练使用能极大减少代码量。以下是最核心的几个。

3.1 排序与查找：Sort, Lower_bound, Binary_search

sort - 排序核心

• 基本使用 ： sort(begin, end) ，区间是[begin, end)。
• 自定义比较 ：这是重点和易错点。比较函数必须满足 严格弱序 （strict weak ordering）。简单说，对于自定义类型，你需要告诉 sort “小于”意味着什么。

  vector<Point> v;
  // 方法1：使用函数指针或lambda（推荐lambda，C++11以上）
  sort(v.begin(), v.end(), [](const Point& a, const Point& b) {
      return a.x < b.x || (a.x == b.x && a.y < b.y);
  });
  // 方法2：重载结构体的<运算符，然后直接sort(v.begin(), v.end())
  // 方法3：定义全局比较函数或函数对象
  

  重要陷阱 ：比较函数必须保证如果 comp(a, b)==true ，则 comp(b, a)==false 。并且，如果 !comp(a,b) && !comp(b,a) ，则认为a和b“等价”。违反这个规则会导致未定义行为，在有些编译器上可能正常运行，换一个环境就崩溃。

  // 错误示例：试图按非升序排序，但写错了
  sort(v.begin(), v.end(), [](int a, int b) { return a >= b; }); // 错误！>=不满足严格弱序
  // 正确写法：降序排序应该用`a > b`，或者直接用`greater<int>()`
  sort(v.begin(), v.end(), greater<int>());
  

lower_bound/upper_bound - 有序区间查找 这两个函数作用于 已排序 的区间，使用二分查找，复杂度O(log n)。

• 区别 ： lower_bound 找第一个**>=val 的位置， upper_bound 找第一个 >val**的位置。
• 获取元素索引 ：通常我们得到的是迭代器，要转成下标：

  vector<int> v = {1,2,2,3,4};
  auto it = lower_bound(v.begin(), v.end(), 2);
  int index = it - v.begin(); // index = 1
  

• 判断元素是否存在 ：不能直接用 lower_bound 的结果与 val 比较，因为迭代器可能指向 end() 。通常结合 binary_search 使用，或者：

  auto it = lower_bound(v.begin(), v.end(), val);
  if(it != v.end() && *it == val) {
      // 找到
  }
  

  binary_search(begin, end, val) 只返回bool，告诉你是否存在，不返回位置。

3.2 排列与最值：Next_permutation, Min/Max_element

next_permutation - 全排列生成器 这个函数按字典序生成下一个排列。如果当前排列已经是最大（降序），则返回 false 并重置为最小排列（升序）。 非常适用于暴力枚举所有排列的题目 。

vector<int> v = {1,2,3};
do {
    // 处理当前排列v
} while(next_permutation(v.begin(), v.end()));

注意：使用前 必须确保序列是升序的 （最小的排列），否则会从当前状态开始生成，漏掉前面的排列。如果序列中有重复元素， next_permutation 会生成所有 不重复 的排列，非常智能。

min_element/max_element - 极值查找 返回区间内最小/最大元素的 迭代器 。比手动写循环更安全简洁。

vector<int> v = {5,2,8,1};
auto min_it = min_element(v.begin(), v.end()); // 指向1
auto max_it = max_element(v.begin(), v.end()); // 指向8
int min_val = *min_it;
int min_index = min_it - v.begin(); // 获取下标

对于多个元素比较（如 min(a, b, c) ），可以使用 std::min({a, b, c}) 的初始化列表形式（C++11）。

3.3 删除与填充：Remove-erase惯用法, Fill

remove-erase 惯用法 这是STL中最经典的惯用法之一，用于真正删除容器中满足条件的元素。 remove 算法本身 并不删除元素 ，它只是把不满足条件的元素移动到前面，返回一个指向新的“逻辑结尾”的迭代器。真正的删除需要配合容器的 erase 方法。

vector<int> v = {1,2,3,2,5};
// 删除所有值为2的元素
auto new_end = remove(v.begin(), v.end(), 2);
// 此时v的内容变为 {1,3,5,?,?}，后面两个是残留的旧值（2和5），new_end指向第一个?的位置
v.erase(new_end, v.end()); // 真正删除尾部多余元素
// 现在v = {1,3,5}

对于关联容器（ set/map ），直接使用 erase(key) 或 erase(iterator) 即可。

fill - 区间填充 快速将一个区间填充为特定值，比用循环赋值更清晰。

vector<int> v(10);
fill(v.begin(), v.end(), -1); // 全部填充为-1
fill(v.begin(), v.begin()+5, 0); // 前5个填充为0

类似的还有 fill_n(begin, n, value) ，填充从 begin 开始的n个元素。

4. 数值算法与实用工具函数

这部分函数散落在 <numeric> 和 <utility> 等头文件中，但实用性极强。

4.1 累积与内积：Accumulate, Partial_sum

accumulate - 求和/更一般的累积 默认是求和，但第三个参数可以指定初始值，第四个参数可以指定二元操作函数，使其功能非常强大。

vector<int> v = {1,2,3,4,5};
int sum = accumulate(v.begin(), v.end(), 0); // 求和，0是初始值
int product = accumulate(v.begin(), v.end(), 1, multiplies<int>()); // 求乘积，1是初始值
// 自定义操作：连接字符串
vector<string> strs = {"Hello", " ", "World"};
string concat = accumulate(strs.begin(), strs.end(), string("")); // 注意初始值要是string类型

partial_sum - 求前缀和 计算前缀和（或更一般的前缀“累积”），结果可以存回原容器或另一个容器。这是解决许多区间查询问题的核心工具。

vector<int> v = {1,2,3,4,5};
vector<int> prefix(v.size());
partial_sum(v.begin(), v.end(), prefix.begin());
// prefix = {1, 3, 6, 10, 15}
// 结合差分数组，可以高效处理区间加减、区间求和问题

4.2 交换与移动：Swap, Move (C++11)

swap ：交换两个同类型对象的值。对于STL容器和大多数标准类型， std::swap 是高效的特化版本（通常是O(1)复杂度）。自己写的类如果管理了资源（如动态内存），最好也提供 swap 成员函数或特化 std::swap 。

移动语义（C++11） ：虽然 move 本身是一个强制类型转换（ std::move ），但它代表了现代C++的重要思想。理解“移动”而非“拷贝”可以提升性能。例如，在向容器中添加一个临时创建的大的对象时，使用 v.push_back(std::move(temp_obj)) 可以避免昂贵的拷贝，只转移资源所有权。在ACM中，对于复杂的结构体，如果确认某个对象之后不再使用，可以考虑使用 move 来提升效率。

4.3 元组与配对：Tuple, Pair, Tie

pair ：将两个值捆绑在一起，例如 pair<int, string> 。常用在需要返回两个值的函数中，或者作为 map 的元素（ map 的 value_type 就是 pair<const Key, T> ）。可以使用 make_pair 创建，也可以用 {} 初始化（C++11）。

tuple (C++11) ： pair 的泛化，可以捆绑任意多个值。使用 make_tuple 创建，用 get<i>(my_tuple) 访问第i个元素。

tie (C++11) ：这是一个非常方便的工具，用于将 tuple 或 pair 解包到变量中，或者创建用于比较的 tuple 。

// 解包
pair<int, string> p = {1, "hello"};
int id; string name;
tie(id, name) = p; // id=1, name="hello"

// 用于多关键字比较（替代复杂的if-else链）
struct Node {
    int a, b, c;
    bool operator<(const Node& other) const {
        return tie(a, b, c) < tie(other.a, other.b, other.c); // 依次比较a,b,c
    }
};

tie 在实现多关键字排序或比较时，能让代码异常清晰。

5. 输入输出与性能优化实战

ACM比赛对程序的运行时间和内存有严格限制，I/O常常是第一个性能瓶颈。

5.1 关闭流同步与解除绑定

默认情况下，C++的 cin/cout 与C的 stdio 是同步的，以保证混用 scanf/printf 和 cin/cout 时顺序正确。但这会带来额外的开销。在**确定只使用 cin/cout **的情况下，可以关闭同步来大幅提升速度。

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

• ios::sync_with_stdio(false) ：关闭与C标准输入输出的同步。
• cin.tie(nullptr) 和 cout.tie(nullptr) ：解除 cin 和 cout 的绑定。默认情况下，每次 cin 操作前都会 flush``cout 的缓冲区，以保证提示信息能先显示。解除绑定后，它们独立操作，减少不必要的刷新。

重要警告 ：一旦执行了 sync_with_stdio(false) ，就 绝对不能 再混用 scanf/printf 和 cin/cout ，否则输出顺序会混乱。同时，关闭绑定后，如果需要交互式输出（如先 cout 提示语，再 cin 输入），需要手动刷新缓冲区（ cout << endl; 或 cout << flush; ）。

5.2 使用“\n”替代endl

endl 会在输出换行符的同时刷新输出缓冲区。频繁的刷新缓冲区是低效的。在比赛中，除非题目要求立即输出（很少见），否则一律使用 \n 。

cout << "Hello World\n"; // 好
cout << "Hello World" << endl; // 不好（在循环中尤其糟糕）

5.3 字符串快速转换与解析

对于需要频繁进行字符串和数字转换的题目（如大数运算、复杂输入格式），使用 stringstream 虽然方便但较慢。可以考虑：

• 自己写解析函数 ：对于已知格式的整数输入，手写一个 read_int() 函数，用 getchar() 逐字符读取并计算，通常比 cin 或 scanf 更快。

  int read_int() {
      int x = 0, f = 1;
      char ch = getchar();
      while(ch < '0' || ch > '9') { if(ch == '-') f = -1; ch = getchar(); }
      while(ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
      return x * f;
  }
  

• 使用 std::stoi , std::stoll 等 ：如果已经有一个 string ，将其转为数字，这些函数比 stringstream 高效。

5.4 内存与时间估算

这是ACM的基本功。在写代码前，要对算法的时间和空间复杂度有清晰估算。

• 时间复杂度 ：C++在OJ上，1秒通常能完成1e8~5e8次基本操作。O(n^2)的算法，n大概在1e4量级；O(n log n)的算法，n可以到1e6；O(n)的算法，n可以到1e7甚至更高。
• 空间复杂度 ：注意全局数组的大小。一个 int 是4字节，一个 long long 是8字节。开一个 int[1000000] 的全局数组大约是4MB。通常比赛内存限制在256MB或512MB，要避免开过大的数组（特别是多维数组）。使用 vector 可以动态管理，但也要注意总大小。
• 局部变量 ：大的数据结构（如大数组）不要开在函数内部（栈空间），栈空间通常只有几MB，容易导致栈溢出（Stack Overflow）。应该开成全局变量，或者用 vector 在堆上分配。

6. 常见问题排查与调试技巧

即使再熟练，代码也难免出bug。掌握高效的调试技巧至关重要。

6.1 典型编译错误与运行时错误

• CE (Compilation Error) ：

  • 缺少头文件 ：忘记 #include <vector> , <algorithm> 等。
  • 语法错误 ：括号/花括号不匹配，分号缺失，模板符号 >> 在C++11以前需要写成 > > （中间有空格）。
  • 未定义标识符 ：函数或变量名拼写错误，或者作用域不对。

• RE (Runtime Error) ：

  • 段错误 (Segmentation Fault) ：最常见。原因包括：数组/容器下标越界、访问空指针/野指针、栈溢出（递归太深或局部数组太大）。
  • 浮点错误 (Floating Point Exception) ：除以零、对负数开平方等。
  • 内存超限 (Memory Limit Exceeded) ：数组开得太大，或者递归/动态分配内存没有释放（虽然ACM程序结束即释放，但中间过程可能爆掉）。

• TLE (Time Limit Exceeded) ：

  • 算法复杂度太高。
  • 死循环。
  • 输入输出效率低下（未关闭流同步、频繁使用 endl ）。
  • 在 unordered_map 上遭遇哈希攻击。

• WA (Wrong Answer) ：

  • 最头疼的错误。可能是算法逻辑错误、边界条件没处理好、初始化不正确、数据类型溢出等。

6.2 调试方法与技巧

• 静态查错 ：写完代码后，先不要运行，静下心来从头到尾读一遍代码。模拟一些简单数据在脑中运行。这能发现很多低级错误。
• 输出调试法 (printf debugging) ：在关键位置输出变量中间值。这是ACM中最常用、最有效的调试手段。
  • 使用 cerr 输出调试信息，它默认输出到标准错误，不影响程序的标准输出，且通常不受OJ的答案比对影响。
  • 使用 #ifdef LOCAL 之类的宏，方便在本地和提交时切换调试代码。

  #define LOCAL
  #ifdef LOCAL
  #define debug(...) fprintf(stderr, __VA_ARGS__)
  #else
  #define debug(...) 42
  #endif
  // 使用时：debug("value of x = %d\n", x);
  

• 构造边界数据和特殊数据 ：
  • n=0, n=1, n=最大值。
  • 数据全部相等、递增、递减。
  • 有负数、有零的情况。
• 对拍 ：写一个绝对正确但可能很慢的暴力程序（ brute.cpp ），和你的优化程序（ sol.cpp ）用同一个随机数据生成器（ gen.cpp ）测试，比较输出。这是找出 WA 的终极武器。可以用脚本自动化这个过程。
• 使用调试器 ：本地开发时，熟练使用GDB（命令行）或IDE集成的调试器（如VS Code, CLion）。设置断点、单步执行、查看变量值、监视表达式，对于复杂逻辑的调试非常有用。

6.3 STL相关典型错误速查表

错误现象	可能原因	解决方案
程序崩溃（段错误）	vector / string 使用 [] 越界访问。	检查下标范围，使用 .at() 调试（提交时改回 [] ）。
程序崩溃或输出乱码	迭代器失效后继续使用（如在 for 循环中对容器增删元素）。	使用 erase 返回值更新迭代器，或使用 remove-erase 惯用法。
map 查找结果不对	使用了 map[key] 进行查询，意外插入了默认值。	查询使用 find() 方法。
set 中自定义类型无法插入或排序错误	未提供正确的比较器（ operator< 或仿函数），或比较器不满足严格弱序。	检查比较逻辑，确保不会出现 a<b 和 b<a 同时为真。
priority_queue 不是小顶堆	默认是大顶堆，自定义比较器方向写反。	记住：默认 less 是大顶堆；想要小顶堆用 greater 或自定义比较时让“优先级高”的返回 true （即 a>b 返回 true 得到小顶堆）。
sort 排序结果异常或崩溃	自定义比较函数不满足严格弱序（如使用了 >= 或 <= ）。	确保比较函数使用 < 或 > 定义“小于”关系。
lower_bound 结果不对	对未排序的区间使用。	确保区间在使用前已排序。
unordered_map 超时	遭遇哈希碰撞攻击。	换用 map ，或自定义更复杂的哈希函数（如 mt19937 随机哈希）。
输出顺序混乱	关闭了流同步后又混用 cin/cout 和 scanf/printf 。	确保只使用一套I/O函数。

7. 赛场策略与代码模板管理

最后，分享一些实战策略。

• 准备代码模板 ：将常用的代码片段（如快速I/O、常用宏定义、数据结构定义——并查集、线段树、树状数组等）提前写好，存成一个 template.cpp 文件。比赛开始后，直接复制粘贴，能节省大量时间并减少敲错代码的风险。模板要精简，只包含你最熟悉、最常用的部分。
• 先写暴力，再优化 ：对于不确定的题目，先写一个保证正确的暴力解法（O(n^2)等）。这有三个好处：1) 用于对拍验证优化算法的正确性；2) 在小数据上测试逻辑；3) 如果时间不够，暴力可能能骗到部分分。
• 注意数据范围与溢出 ：这是 WA 的常见原因。看到题目先看数据范围。如果涉及乘法或累加，立刻考虑用 long long 。 int 的范围大约是±2e9， long long 大约是±9e18。
• 使用 typedef 或 using 简化代码 ：

  typedef long long ll;
  typedef vector<int> vi;
  typedef pair<int, int> pii;
  #define rep(i, a, b) for(int i = a; i < (b); ++i) // 简化循环
  

  这能让代码更清晰，尤其是涉及复杂嵌套类型时，如 vector<vector<pair<int, ll>>> 。
• 保持冷静，合理分配时间 ：ACM是团队赛，也是心理战。遇到卡题时，和队友讨论，或者换一道题做。一道题长时间（如1小时）没有进展，就应该考虑放弃或寻求帮助。永远先保证有题目能稳定得分。

这份总结里的每一个点，几乎都是我在无数次的 WA 、 TLE 和 RE 中踩过的坑。STL是工具，工具用得好，能让你如虎添翼；用不好，反而会束手束脚。最好的学习方法，就是在理解这些原理和技巧的基础上，多写代码，多做题，把知识变成肌肉记忆。当你在赛场上能不假思索地敲出正确的STL代码时，你就离奖牌更近了一步。