保研机试——巨大坐标系问题

原创已于 2025-09-20 19:22:26 修改 · 598 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2025-09-02 21:36:39 首次发布

保研专栏收录该内容

13 篇文章

订阅专栏

第一步：识别问题特征

当你看到以下一个或多个特征时，立即意识到这是“巨大坐标系问题”：

坐标范围巨大：x, y 的范围达到 $10^9$ 甚至 $10^{18}$ 。
点/操作数量有限：有意义的点或查询的数量 q 在一个可接受的范围内（通常是 $105∼10610^5 \sim 10^6$ ）。
内存限制严格：通常为 256MB 或 512MB。
直接开二维数组 grid[N][N] 必将导致 MLE (内存超限)。

第二步：根据需求选择方案（决策流程）

拿到题目后，问自己以下几个关键问题，以决定使用哪种工具：

我需要利用坐标的“顺序”吗？
- 比如，是否需要查找“最近/下一个/上一个”点？是否需要按坐标排序？
- 是 -> 方案一：map，利用其自动排序特性。
我只关心“某个点是否存在”或“某个点上存了什么值”吗？
- 完全不关心点与点之间的顺序和距离。
- 是 -> 方案二：unordered_map，追求最快的平均访问速度。
我需要处理“一个区域/范围”内的信息吗？
- 比如，统计一个矩形内有多少个点？对一个矩形内的所有点进行修改？
- 是 -> 方案三：坐标压缩(离散化) + (树状)数组/线段树。

方案一：`map` —— 处理有序关系

适用场景

查找离某点最近的邻居（上下左右、对角线）。
查找某个坐标的前驱/后继。
需要按坐标顺序遍历所有点。
“飞镖”问题就是典型案例。

核心思想
map 底层是红黑树，它会根据键 (key) 自动排序。我们可以利用这个特性和二分查找函数 (lower_bound/upper_bound) 来高效地查找邻近元素。

模板代码

存储二维坐标点信息

#include <map>
#include <utility> // for pair

// T 可以是任何类型，如 int, bool, char, struct
map<pair<int, int>, T> points;

// --- 常用操作 ---
// 插入/更新: 在 (x,y) 放置值为 val 的标记
points[{x, y}] = val;

// 查询: 检查 (x,y) 是否有标记
if (points.count({x, y})) {
    // 存在
    T value = points.at({x, y}); 
}

// 删除
points.erase({x, y});

按行/列分组，快速查找邻居（“飞镖”问题核心技巧）

#include <map>
#include <vector>
#include <algorithm>

// cols[y] 存储了第 y 列所有点的 x 坐标 (自动有序)
map<int, vector<int>> cols; 

// --- 查找 (x, y) 正上方最近的点 ---
int target_x = -1;
if (cols.count(y)) {
    auto& x_coords = cols.at(y);
    // lower_bound 找到第一个 >= x 的元素
    auto it = lower_bound(x_coords.begin(), x_coords.end(), x);
    
    if (it != x_coords.begin()) {
        --it; // 回退一个位置，即为 < x 的最大元素
        target_x = *it;
    }
}
// target_x == -1 表示上方没有点

优缺点

优点：自动排序，功能强大，能处理复杂的邻近查询。
缺点：所有操作都是 $O(log⁡N)O(\log N)$ ，在海量查询下可能比哈希表慢。

方案二：`unordered_map` —— 最快的单点操作

适用场景

只关心某个点“存/不在”，例如记录棋盘上某个点是否被访问过。
统计每个坐标出现的次数。
对坐标顺序完全没有要求。

核心思想
利用哈希表，实现平均 $O (1)$ 的增、删、查。比 map 更快。

模板代码 (技巧：将二维坐标合并为 long long)

为了避免为 pair 写自定义哈希函数的麻烦，通常将二维坐标 (x, y) 转换成一个 long long 类型的数字作为键。

#include <unordered_map>

// C 是一个比所有 y 都大的常数, e.g., 1e9 + 7
const long long C = 2e9; // 假设 y < 2e9

// T 可以是任何类型
unordered_map<long long, T> points;

long long key = (long long)x * C + y;

// --- 常用操作 ---
// 插入/更新
points[key] = val;

// 查询
if (points.count(key)) {
    // 存在
    T value = points.at(key);
}

// 删除
points.erase(key);

优缺点

优点：极快！平均 $O (1)$ 的性能。
缺点：无序！无法进行邻近查找。有极低概率发生哈希碰撞导致性能下降。

方案三：坐标压缩 (离散化) —— 处理范围查询

适用场景

统计一个矩形区域内有多少个点。
对一个矩形区域进行统一的修改/赋值。
坐标的绝对值不重要，只有相对大小关系重要。

核心思想
将稀疏、巨大的坐标值（如 $10, 5000, 10^9$ ）映射到连续的、紧凑的整数索引（如 $0, 1, 2$ ），然后在这些紧凑的索引上使用树状数组、线段树等高效数据结构。

模板代码

#include <vector>
#include <algorithm>

// 假设 all_coords 存储了所有用到的 x 或 y 坐标
vector<int> all_coords; 

// --- 压缩步骤 ---
// 1. 排序
sort(all_coords.begin(), all_coords.end());
// 2. 去重
all_coords.erase(unique(all_coords.begin(), all_coords.end()), all_coords.end());

// --- 获取一个原始坐标 v 对应的压缩后索引 ---
int get_compressed_index(int v) {
    // lower_bound 返回第一个不小于 v 的元素的迭代器
    // 减去 begin() 得到从0开始的索引
    return lower_bound(all_coords.begin(), all_coords.end(), v) - all_coords.begin();
}

// --- 使用示例 ---
// int original_x = 1e9;
// int compressed_x = get_compressed_index(original_x);
// 现在就可以在比如 bit[compressed_x] 上操作了