Есть ли лучшая реализация для подсчета уникальных пар целых чисел?

Прежде всего, я думаю, что вы пришли с неправильным предположением. Для std::unordered_map и std::unordered_set хэш не обязательно должен быть уникальным (и в принципе не может быть таким для таких типов данных, как, например, std::string), должна быть низкая вероятность того, что 2 разных ключа будут генерировать одно и то же значение хеш-функции. Но если произойдет столкновение, это не будет концом света, просто доступ будет медленнее. Я бы сгенерировал 32-битный хеш из 2 чисел, и если у вас есть представление о типичных значениях, просто проверьте вероятность столкновения хэшей и соответственно выберите хеш-функцию.

Чтобы это работало, вы должны использовать пару 32-битных чисел в качестве ключа в std::unordered_map и предоставить правильную хеш-функцию. Вычисление уникального 64-битного ключа и его использование с хэш-картой вызывает споры, поскольку hash_map затем вычисляет другой хэш этого ключа, поэтому, возможно, вы делаете его медленнее.

Что касается 36-битного ключа, это не очень хорошая идея, если у вас нет специального процессора, который обрабатывает 36-битные данные. Ваши данные либо будут выровнены по 64-битной границе, и у вас не будет никаких преимуществ экономии памяти, либо в противном случае вы получите штраф за невыровненный доступ к данным. В первом случае у вас будет просто дополнительный код для получения 36 бит из 64-битных данных (если процессор поддерживает это). Во втором ваш код будет медленнее, чем 32-битный хэш, даже если есть некоторые коллизии.

Если этот hash_map является узким местом, вы можете рассмотреть другую реализацию хеш-карты, например goog-sparsehash.sourceforge.net.

Мои два цента, функции сопряжения, описанные в статье, НАМНОГО сложнее, чем вам на самом деле нужно. Сопоставить 2 32-битных значения UNISIGNED с 64 однозначно легко. Следующее делает это и даже обрабатывает непарные состояния, не слишком сильно ударяя по математическому периферийному устройству (если вообще).

uint64_t map(uint32_t a, uint32_t b)
{
    uint64_t x = a+b;
    uint64_t y = abs((int32_t)(a-b));

    uint64_t ans = (x<<32)|(y);
    return ans;
}

void unwind(uint64_t map, uint32_t* a, uint32_t* b)
{
  uint64_t x = map>>32;
  uint64_t y = map&0xFFFFFFFFL;

  *a = (x+y)>>1;
  *b = (x-*a);
}

Другая альтернатива:

uint64_t map(uint32_t a, uint32_t b)
{
  bool bb = a>b;
    uint64_t x = ((uint64_t)a)<<(32*(bb));
    uint64_t y = ((uint64_t)b)<<(32*!(bb));

    uint64_t ans = x|y;
    return ans;
}

void unwind(uint64_t map, uint32_t* a, uint32_t* b)
{

  *a = map>>32;
  *b = map&0xFFFFFFFF;
}

Это работает как уникальный ключ. Вы можете легко изменить его, чтобы он был поставщиком хэш-функции для неупорядоченной карты, хотя будет ли это быстрее, чем std::map, зависит от количества полученных вами значений.

ПРИМЕЧАНИЕ: это не удастся, если значения a+b > 32 бит.