竞争性编程中最常用的 10 个内置 C++ 函数

在竞争性编程中，使用内置函数可以大大提高程序的效率和简洁性。以下是竞争性编程中最常用的 10 个内置 C++ 函数：

1. std::sort()

在排序算法中，std::sort() 是必不可少的。它基于快速排序实现，可以将任意 STL 容器中存储的元素按指定规则排序。例如，将一个整数数组按升序排序：

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
	std::vector<int> nums = { 2, 5, 1, 8, 6 };
	std::sort(nums.begin(), nums.end());
	for (int num : nums) {
		std::cout << num << ' ';
	}  // 输出：1 2 5 6 8
}

2. std::cin 和 std::cout

标准输入和标准输出是竞争性编程中最常用的输入输出方式。使用 std::cin 和 std::cout 可以从标准输入读取数据并将数据输出到标准输出。例如，读取一个整数并输出它的两倍：

#include <iostream>

int main() {
	int num;
	std::cin >> num;
	std::cout << num * 2;
}

3. std::set()

std::set 是一个基于红黑树实现的集合，可以存储任意类型的值，并且保证元素不重复。例如，将一组整数存储在 std::set 中并输出：

#include <iostream>
#include <set>

int main() {
	std::set<int> nums = { 2, 5, 1, 8, 6 };
	for (int num : nums) {
		std::cout << num << ' ';
	}  // 输出：1 2 5 6 8
}

4. std::make_pair()

std::make_pair() 可以方便地创建一个 std::pair 对象，该对象包含两个值。例如，创建一个 int 和一个 char 对象并将它们打包在一个 std::pair 中：

#include <iostream>
#include <utility>

int main() {
	auto pair = std::make_pair(42, 'x');
	std::cout << pair.first << pair.second;
}

5. std::accumulate()

std::accumulate() 可以对任意可以迭代的容器进行归纳操作。例如，求一个整数数组的和：

#include <iostream>
#include <numeric>
#include <vector>

int main() {
	std::vector<int> nums = { 2, 5, 1, 8, 6 };
	auto sum = std::accumulate(nums.begin(), nums.end(), 0);
	std::cout << sum;  // 输出：22
}

6. std::map()

std::map 是一个关联数组容器，可以将任意类型的键映射到任意类型的值。例如，将一组学生的姓名和成绩储存在 std::map 中：

#include <iostream>
#include <map>
#include <string>

int main() {
	std::map<std::string, int> scores = {
		{"Alice", 94},
		{"Bob", 72},
		{"Charlie", 85}
	};
	std::cout << scores["Bob"];  // 输出：72
}

7. std::vector::erase()

std::vector::erase() 可以从 vector 中删除指定位置的元素或一定范围内的元素。例如，从一个整数数组中删除大于 5 的元素：

#include <iostream>
#include <vector>

int main() {
	std::vector<int> nums = { 2, 5, 1, 8, 6 };
	auto iter = nums.begin();
	while (iter != nums.end()) {
		if (*iter > 5) {
			iter = nums.erase(iter);
		} else {
			++iter;
		}
	}
	for (int num : nums) {
		std::cout << num << ' ';
	}  // 输出：2 5 1
}

8. std::next_permutation()

std::next_permutation() 寻找 STL 容器中下一个更大的排列，可以用于解决许多组合问题。例如，寻找一个字符串的字典序下一个排列：

#include <algorithm>
#include <iostream>
#include <string>

int main() {
	std::string s = "abc";
	do {
		std::cout << s << '\n';
	} while (std::next_permutation(s.begin(), s.end()));
}

9. std::upper_bound()

std::upper_bound() 在一个已经按顺序排列的 STL 容器中查找第一个大于某个值的元素，可以用于二分查找等算法。例如，从一个已经按顺序排列的整数数组中查找第一个大于等于 5 的元素：

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
	std::vector<int> nums = { 1, 2, 3, 5, 6, 8 };
	auto iter = std::upper_bound(nums.begin(), nums.end(), 5);
	if (iter != nums.end()) {
		std::cout << *iter;
	}  // 输出：6
}

10. std::bitset()

std::bitset() 是一个位集合类，可以存储固定数量的二进制位并支持位运算。例如，使用 std::bitset 存储 8 个二进制位并设置第 3 个和第 5 个位：

#include <bitset>
#include <iostream>

int main() {
	std::bitset<8> bits;
	bits.set(2);
	bits.set(4);
	std::cout << bits << '\n';
}

以上便是竞争性编程中最常用的 10 个内置 C++ 函数，它们能够有效提升编码效率和竞赛成绩。