144 lines
3.9 KiB
C++
144 lines
3.9 KiB
C++
#include <iostream>
|
|
#include <unordered_set>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
#include <list>
|
|
|
|
// Compute the sum of the squares of a number's digits.
|
|
int sumOfSquaresOfDigits(int x) {
|
|
int sum = 0;
|
|
while (x > 0) {
|
|
int digit = x % 10;
|
|
sum += digit * digit;
|
|
x /= 10;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
// std::unordered_set
|
|
bool isGood_unordered_set(int n) {
|
|
std::unordered_set<int> visited;
|
|
while (n != 1 && visited.find(n) == visited.end()) {
|
|
visited.insert(n);
|
|
n = sumOfSquaresOfDigits(n);
|
|
}
|
|
return (n == 1);
|
|
}
|
|
|
|
// std::unordered_map
|
|
bool isGood_unordered_map(int n) {
|
|
// We only need to mark that we have "seen" a number.
|
|
// The bool value is arbitrary; storing true is enough.
|
|
std::unordered_map<int, bool> visited;
|
|
while (n != 1 && visited.find(n) == visited.end()) {
|
|
visited[n] = true; // Mark n as visited
|
|
n = sumOfSquaresOfDigits(n);
|
|
}
|
|
return (n == 1);
|
|
}
|
|
|
|
class MyHashSet {
|
|
private:
|
|
// store integers in a vector of lists
|
|
std::vector< std::list<int> > table;
|
|
int num_elements;
|
|
static const int DEFAULT_SIZE = 16;
|
|
static const double LOAD_FACTOR_THRESHOLD;
|
|
|
|
// A simple hash function for int
|
|
int hashFunction(int key) const {
|
|
// take abs value
|
|
int h = key < 0 ? -key : key;
|
|
return h % (int)table.size();
|
|
}
|
|
|
|
void rehash() {
|
|
int newSize = (int)table.size() * 2; // doubling
|
|
std::vector< std::list<int> > newTable(newSize);
|
|
|
|
// re-insert all existing elements into newTable
|
|
for (auto &chain : table) {
|
|
for (int val : chain) {
|
|
int h = (val < 0 ? -val : val) % newSize;
|
|
newTable[h].push_back(val);
|
|
}
|
|
}
|
|
table.swap(newTable);
|
|
}
|
|
|
|
void rehashIfNeeded() {
|
|
// If load factor = num_elements / table.size() is too big, rehash
|
|
double load_factor = (double)num_elements / (double)table.size();
|
|
if (load_factor > LOAD_FACTOR_THRESHOLD) {
|
|
rehash();
|
|
}
|
|
}
|
|
|
|
public:
|
|
// Constructor
|
|
MyHashSet(int initialSize = DEFAULT_SIZE)
|
|
: table(initialSize), num_elements(0) {}
|
|
|
|
// Return true if key is found
|
|
bool find(int key) const {
|
|
int h = hashFunction(key);
|
|
// Search the list in bin h
|
|
for (int val : table[h]) {
|
|
if (val == key) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Insert key if not already in the hash set
|
|
void insert(int key) {
|
|
if (!find(key)) {
|
|
int h = hashFunction(key);
|
|
table[h].push_back(key);
|
|
num_elements++;
|
|
rehashIfNeeded();
|
|
}
|
|
}
|
|
};
|
|
|
|
const double MyHashSet::LOAD_FACTOR_THRESHOLD = 1.0;
|
|
|
|
// The "isGood" function that uses MyHashSet
|
|
bool isGood_custom_hash(int n) {
|
|
MyHashSet visited;
|
|
while (n != 1 && !visited.find(n)) {
|
|
visited.insert(n);
|
|
n = sumOfSquaresOfDigits(n);
|
|
}
|
|
return (n == 1);
|
|
}
|
|
|
|
int main() {
|
|
int testCases[] = {2,4,5,6,17,18,20,1,7,10,13,19,23,28,68};
|
|
|
|
std::cout << "=== Using std::unordered_set ===" << std::endl;
|
|
for (int n : testCases) {
|
|
if (isGood_unordered_set(n))
|
|
std::cout << n << " is a good number." << std::endl;
|
|
else
|
|
std::cout << n << " is not a good number." << std::endl;
|
|
}
|
|
|
|
std::cout << "\n=== Using std::unordered_map ===" << std::endl;
|
|
for (int n : testCases) {
|
|
if (isGood_unordered_map(n))
|
|
std::cout << n << " is a good number." << std::endl;
|
|
else
|
|
std::cout << n << " is not a good number." << std::endl;
|
|
}
|
|
|
|
std::cout << "\n=== Using custom separate-chaining HashSet ===" << std::endl;
|
|
for (int n : testCases) {
|
|
if (isGood_custom_hash(n))
|
|
std::cout << n << " is a good number." << std::endl;
|
|
else
|
|
std::cout << n << " is not a good number." << std::endl;
|
|
}
|
|
|
|
return 0;
|
|
}
|