Using custom hash functions allows you to modify unordered_set hashing so that it's less likely to be hacked.

Here's my template:

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
struct custom_hash {
  	static uint64_t splitmix64(uint64_t x) {
   	 	x += 0x9e3779b97f4a7c15;
    	x = (x^(x>>30))*0xbf58476d1ce4e5b9;
    	x = (x^(x>>27))*0x94d049bb133111eb;
    	return x^(x>>31);
  	}	

  	size_t operator()(uint64_t x) const {
    	static const uint64_t FIXED_RANDOM = rng();
    	return splitmix64(x+FIXED_RANDOM);
  	}
};

template<typename T> using safe_set = unordered_set<T, custom_hash>;

Please note that not everything is able to be given a hash, so only stick to basic data types such as int, string etc.

If you're using unordered_map or unordered_set you MUST have them anyway. I've already gave a link to the blog that gives comprehensive information about which exactly function you should use, so I won't duplicate it.

About what orz said: I completely agree with him in terms of competitive programming. When you have the prewritten protection code then it's much better to use unordered_map or unordered_set if you only don't need the sorted elements in these structures. Also, most of the time, you really don't need anti-anti-hack protection, because it's very rare now that someone will try to fetch the random and write the test based on it, because it's enormously time consuming and it doesn't cost it.

If you look in my solutions, then you will see that it's very rare when I'm using such structures, and I have an explanation for this as well. Actually, I've a couple of reasons:

1. You can't use random hashing in real programming, and I'm trying to write my code as clear as possible and as similar to what you would write in reality (without including the principles of OOP, this is unnecessary in conditions of contests), so these structures are bad for me and I use them only when I really can't think of something else.
2. If I can't solve the problem without them then either I can't solve problem efficiently at all or problem was designed to be solved in only one way, which is enough to consider (for me) most of the time the problem annoying and boring, and I really don't like such problems.