更有效的结构为 unordered_map<pair<int, int>, int>

Question

我有大约 20,000,000 个 pair<int, int> 需要关联到 ints。我用unordered_map<pair<int, int>, int> 这样做了。分析我的算法表明检查条目是否存在

bool exists = myMap[make_pair(a, b)] != NULL

是性能瓶颈。我认为从unordered_map 检索这些信息会非常快，因为它是 O(1)。但是如果常数很大，常数时间可能会很慢......

我的哈希函数是

template <>
struct tr1::hash<pair<int, int> > {
public:
        size_t operator()(pair<int, int> x) const throw() {
             size_t h = x.first * 1 + x.second * 100000;
             return h;
        }
};

你知道我的问题有什么更好的数据结构吗？

显然我不能只将信息存储在矩阵中，因此内存量不适合现有的任何计算机。我所知道的分布是myMap[make_pair(a, a)] 不存在任何a。并且所有ints 都在从 0 到大约 20,000,000 的连续范围内。

将其视为一个稀疏的 20,000,000x20,000,000 矩阵，其中包含大约 20,000,000 个条目，但从不在主对角线上。

建议

vector<pair<int, int>>*（具有 N 个条目的数组）是否会更快？ a 的查找将是微不足道的（只是数组的索引），然后我将遍历该向量，将该对的 first 值与 b 进行比较。

大更新

我上传了raw data，这样你就可以看到结构了。

Answer 1

作为建议，我选择了带有 N 个条目的 vector<pair<int, int>>*。它比unordered_map 快大约 40%。

Answer 2

主要的事情绝对是避免在每次搜索时添加默认构造的元素：

bool exists = myMap[make_pair(a, b)] != NULL; // OUCH

bool exists = myMap.find(make_pair(a, b)) != myMap.end();  // BETTER

iterator i = myMap.find(make_pair(a, b);
if (i != myMap.end()) ... else ...;      // MAY BE BEST - SEE BELOW

还有伟大的哈希挑战......哇哦！这可能值得一试，但很大程度上取决于对中的数字是如何分布的以及您的实现的std::hash（通常是传递！）：

    size_t operator()(pair<int, int> x) const throw() {
         size_t hf = std::hash(x.first);
         return (hf << 2) ^ (hf >> 2) ^ std::hash(x.second);
    }

如果您将这对替换为int64_ts，您可能也会发现它更快，因此关键比较绝对是简单的整数比较，而不是级联。

还有，你在生存测试之后在做什么？如果您需要访问/更改与同一键关联的值，则应保存迭代器 find 返回并避免再次搜索。

Answer 3

首先，myMap[make_pair(a, b)] != NULL 并没有按照你的想法去做。如果它不存在，它将插入该对，并将映射的值与 0 进行比较（这是 NULL 扩展的内容）。它根本不检查是否存在。 （请注意，在现代 C++ 中，您永远不应该使用 NULL。使用 0 表示数字，使用 nullptr 表示指针）。

至于主题，您的哈希函数似乎不太好。不要忘记ints 上的算术运算是在ints 中完成的。由于在大多数编译器上int 是 32 位的，它的最大值略高于 2,000,000,000。所以 20,000,000 * 10,000 比这大得多，导致溢出（和未定义的行为）。

鉴于您的数据数量，我假设您使用的是 64 位平台，这意味着 size_t 的长度为 64 位。因此，使用这样的哈希函数可能会得到更好的结果：

size_t operator()(pair<int, int> x) const throw() {
     size_t f = x.first, s = x.second;
     return f << (CHAR_BIT * sizeof(size_t) / 2) | s;
}

与您现在所拥有的相比，这应该会产生明显更少的碰撞（并且已经定义了行为）。

如果这没有帮助，您也可以尝试两步法：

std::unordered_map<int, std::unordered_map<int, int>>

先查找x.first，然后查找x.second。我不知道这是否有帮助；测量和观察。

Answer 4

我建议您使用更好的哈希函数进行测试。如果您在 SO 上搜索此处可以找到示例，但这是一种可能的实现方式。

struct pair_hash {
    template <typename T1, typename T2>
    size_t operator()(const std::pair<T1, T2> &pr) const {
        using std::hash;
        return hash<T1>()(pr.first) ^ hash<T2>()(pr.second);
    }
};

Answer 5

您是否尝试过使用 myMap.find(make_pair(a,b)) != myMap.end() ？ operator[] 如果元素不存在则创建它。我希望find 更快。