C++ STL set核心特性与算法竞赛应用

1. 理解set的核心特性与应用场景

在算法竞赛和编程能力认证考试（如GESP）中，std::set是最常用的STL容器之一。它基于红黑树实现，具有三个核心特性：

1. 自动去重：插入重复元素时自动忽略，无需手动处理
2. 有序存储：元素默认按升序排列（可通过自定义比较器修改）
3. 高效操作：插入、删除、查找的时间复杂度均为O(logn)

这些特性使set特别适合解决以下三类问题：

• 需要去重并有序输出的场景
• 需要频繁查询元素是否存在的场景
• 需要动态维护有序集合的场景

提示：虽然unordered_set的查找效率更高（O(1)），但它不保证元素顺序，在需要有序输出的场景中无法替代set。

2. 基础应用：自动去重与有序输出

2.1 典型题目解析：洛谷P1059

题目重述

给定n个可能重复的整数，要求：

1. 去除重复数字
2. 按升序输出剩余数字

解题思路分析

传统方法需要：

1. 排序（O(nlogn)）
2. 遍历去重（O(n)）

而使用set只需：

1. 将所有元素插入set（自动去重+排序，n次插入总时间O(nlogn)）
2. 直接遍历输出

虽然时间复杂度相同，但代码量减少50%以上，且不易出错。

完整实现代码

cpp复制#include <iostream>
#include <set>
using namespace std;

int main() {
    int n, x;
    set<int> s;
    
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> x;
        s.insert(x);  // 自动去重
    }
    
    cout << s.size() << endl;
    for (auto it = s.begin(); it != s.end(); ++it) {
        cout << *it << " ";  // 自动有序输出
    }
    
    return 0;
}

关键技巧说明

1. s.size()直接获取去重后的元素数量
2. 迭代器遍历时，begin()到end()默认按升序排列
3. 插入操作的时间复杂度为O(logn)，n次插入总时间O(nlogn)

3. 进阶应用：存在性判断与动态维护

3.1 典型题目：洛谷P1540（内存管理）

题目特点

需要维护一个固定大小的集合，当新元素到来时：

1. 如果已在集合中，直接跳过
2. 如果不在且集合未满，加入集合
3. 如果不在且集合已满，移除最早元素后加入

set的适用性分析

虽然队列更适合处理FIFO逻辑，但set可以：

1. 快速判断元素是否存在（O(logn)）
2. 配合队列实现高效管理

优化实现方案

cpp复制#include <iostream>
#include <set>
#include <queue>
using namespace std;

int main() {
    int m, n, x, ans = 0;
    set<int> s;
    queue<int> q;
    
    cin >> m >> n;
    for (int i = 0; i < n; ++i) {
        cin >> x;
        if (s.find(x) == s.end()) {  // 快速存在性判断
            ++ans;
            if (s.size() >= m) {
                s.erase(q.front());  // 移除最早元素
                q.pop();
            }
            s.insert(x);
            q.push(x);
        }
    }
    cout << ans;
    return 0;
}

性能对比

• 纯数组实现：查找O(n)，总时间O(n^2)
• set实现：查找O(logn)，总时间O(nlogn)
  当n=1000时，速度提升约10倍

4. 高阶应用：双set维护动态中位数

4.1 典型题目：洛谷P1168（动态中位数）

问题难点

需要实时维护一个不断增长的序列，在每次插入后立即输出当前中位数。

解决方案设计

使用两个set构成对顶堆结构：

1. left：存较小的一半，有序递减
2. right：存较大的一半，有序递增
   始终保持：

• left.size() == right.size()（偶数个）
• 或left.size() == right.size()+1（奇数个）

核心代码实现

cpp复制#include <iostream>
#include <set>
using namespace std;

int main() {
    int n, x;
    multiset<int, greater<int>> left;  // 允许重复的降序set
    multiset<int> right;               // 允许重复的升序set
    
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> x;
        
        // 插入策略
        if (left.empty() || x <= *left.begin()) {
            left.insert(x);
        } else {
            right.insert(x);
        }
        
        // 平衡两个set
        if (left.size() > right.size() + 1) {
            right.insert(*left.begin());
            left.erase(left.begin());
        } else if (right.size() > left.size()) {
            left.insert(*right.begin());
            right.erase(right.begin());
        }
        
        // 输出中位数
        if (i % 2) cout << *left.begin() << endl;
    }
    return 0;
}

复杂度分析

• 每次插入：O(logn)
• 每次平衡：O(logn)
• 总体复杂度：O(nlogn)
  相比排序解法（每次O(nlogn)）效率显著提升

5. 实战技巧与常见问题

5.1 set使用中的注意事项

1. 自定义排序规则：

cpp复制struct cmp {
    bool operator()(const int& a, const int& b) const {
        return a > b;  // 改为降序
    }
};
set<int, cmp> customSet;

2. 元素删除的三种方式：

cpp复制s.erase(key);      // 删除特定值
s.erase(iterator); // 删除迭代器位置
s.erase(first, last); // 删除区间

3. 边界元素访问：

cpp复制auto minVal = *s.begin();    // 最小元素
auto maxVal = *s.rbegin();   // 最大元素

5.2 性能优化技巧

1. 预先分配内存：

cpp复制set<int> s;
s.reserve(10000);  // 预先分配空间减少rehash

2. 使用emplace代替insert：

cpp复制s.emplace(42);  // 避免临时对象构造

3. 批量操作优化：

cpp复制vector<int> v{1,2,3};
s.insert(v.begin(), v.end());  // 比循环插入更高效

5.3 常见问题排查

1. 迭代器失效问题：

cpp复制auto it = s.begin();
s.erase(it++);  // 正确：先使用后递增
// s.erase(it); it++;  // 错误：迭代器已失效

2. 自定义类型需要重载运算符：

cpp复制struct Point {
    int x,y;
    bool operator<(const Point& p) const {
        return x < p.x || (x == p.x && y < p.y);
    }
};
set<Point> pointSet;

3. multiset与set的区别：

• multiset允许重复元素
• set的count()只能是0或1
• multiset的erase(key)会删除所有相同元素

6. 竞赛中的扩展应用

6.1 离散化处理

当数据范围很大但实际值较少时，可以用set实现离散化：

cpp复制set<int> uniqueValues;
map<int, int> discretized;
// 收集所有可能的值
for (int x : originalData) {
    uniqueValues.insert(x);
}
// 建立映射关系
int idx = 0;
for (int val : uniqueValues) {
    discretized[val] = ++idx;
}

6.2 最近邻查找

利用有序特性快速查找最近元素：

cpp复制auto findClosest(set<int>& s, int target) {
    auto it = s.lower_bound(target);
    if (it == s.begin()) return *it;
    if (it == s.end()) return *--it;
    
    int a = *it, b = *--it;
    return abs(a-target) < abs(b-target) ? a : b;
}

6.3 区间统计

统计值在[L,R]范围内的元素数量：

cpp复制int countInRange(set<int>& s, int L, int R) {
    auto first = s.lower_bound(L);
    auto last = s.upper_bound(R);
    return distance(first, last);  // O(k)复杂度
}

在实际编程竞赛中，熟练掌握set的这些高级用法可以大幅提升解题效率。建议从基础题目开始练习，逐步过渡到复杂场景的应用。