good_or_bad_hash

#include <unordered_map>
#include <string>
#include <cassert>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

struct GoodHasher {
    size_t operator() (std::pair<size_t, size_t> from_to) const {
        return from_to.first * 37 + from_to.second * 37 * 37 + (from_to.first + from_to.second) * 37 * 37 * 37;
    }
};
struct BadHasher {
    size_t operator() (std::pair<size_t, size_t> from_to) const {
        return from_to.first * 37 + from_to.second * 37 * 37;
    }
};

int main() {
    GoodHasher good;
    BadHasher bad;

    vector<pair<size_t, size_t>> vec_pair_sizet;

    size_t n, limit;
    cin >> n >> limit;

    for (size_t i = 0; i < n; ++i) {
        for (size_t j = i + 1; j <= n; ++j) {
            vec_pair_sizet.push_back({i, j});
            vec_pair_sizet.push_back({j, i});
        }
    }

    cout << vec_pair_sizet.size() << endl;

    sort(vec_pair_sizet.begin(), vec_pair_sizet.end());

    cout << limit << endl;

    unordered_map<size_t, size_t> for_good_hasher;
    unordered_map<size_t, size_t> for_bad_hasher;

    for (const auto& p : vec_pair_sizet) {
        auto ghash = good(p);
        if (for_good_hasher.count(ghash) == 0) {
            for_good_hasher[ghash] = 0;
        }
        ++for_good_hasher.at(ghash);

        auto bhash = bad(p);
        if (for_bad_hasher.count(bhash) == 0) {
            for_bad_hasher[bhash] = 0;
        }
        ++for_bad_hasher.at(bhash);
    }

    size_t good_hashes = 0;

    for (const auto& [k, v] : for_good_hasher) {
        if (v >= limit) {
            ++good_hashes;
        }
    }

    size_t bad_hashes = 0;
    for (const auto& [k, v] : for_bad_hasher) {
        if (v >= limit) {
            ++bad_hashes;
        }
    }

    cout << "for good hasher buckets with "s << limit << " and more collisions = "s << good_hashes << endl;
    cout << "for bad hasher buckets with "s << limit << " and more collisions = "s << bad_hashes << endl;
}