Hi! Thank you so much for replying to me post. I am sorry it took me so long to get back with you. I couldn't find the time 2 days ago to reply and apparently the site was down yesterday.

I apologize that my code was difficult to parse. I thank you for your suggestions on improving readability and coherent code is something I really strive to create. Though, about your suggestion. Wouldn't using "using Paii = pair<int,int>" on top of "using namespace std" cause name clash? Or are you implying that I should use "using Paii = pair<int, int>" over "using namespace std"? Couldn't I achieve the same affect of "using Paii = pair<int, int>" with a "#define" instead?

Also, fixed the method signature like you suggested (thank you) which actually worked for another test case; however, you solution still didn't work for the test case in question. I still can't understand why though.

I'm especially confused about how the iterator it value changed from (-842150451, -842150451) to (-572662307, -572662307) and why the while loop condition is even being checked between recursive calls: the while loop condition should not have to be checked to apply the returned value from the previous recursive call. Yet it does. I do not understand this also.

Although the error that you pointed out definitely contributed to the problem, perhaps there is something else going on too. The conditions that caused error are still the same as I initially specified. Thanks a bunch. My code is updated as follows:

Code:
#include "stdafx.h"
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
#include <fstream>
#include <stack>
#include <unordered_set>




using namespace std;

vector<string> split_string(string);

template <>
struct hash<pair<int, int> > {
	size_t operator()(const pair<int, int>& x) const noexcept
	{
		return (size_t)x.first * x.second + x.first + x.second;
	}
};

struct custom_set : unordered_set<int>
{
	void pair_insert(pair<int, int> pair)
	{
		insert(pair.first);
		insert(pair.second);
	}

	void pairs_insert(std::initializer_list <pair<int, int>> pairs)
	{
		for (pair<int, int> pair : pairs)
		{
			insert(pair.first);
			insert(pair.second);
		}
	}
};


pair<int, int> journeyToMoon(pair<int, int> id_pair1, unordered_set<pair<int, int>, hash<pair<int, int>>> * astronaut,
	custom_set * temp_set, unordered_set<pair<int, int>, hash<pair<int, int>>>::iterator it);



// Complete the journeyToMoon function below.

int journeyToMoon(int n, unordered_set<pair<int, int>, hash<pair<int, int>>> * astronaut)
//astronaut ids numbered : [0, n-1]
{
	//vector<bool> bIsBoundAstronaut(n); //list of all astronauts; true corresponds to bounded
	//vector<int> set_of_free_astronauts;

	
	vector<unordered_set<int>> sets_of_bounded_astronauts;
	vector<int> num_bounded_astronauts_each_set;
	int num_bounded_astronauts_total = 0, num_free_astronauts = 0, result = 0;
	
	while (!astronaut->empty())
	{
		//*astronaut->begin()++
		
		pair<int, int> id_pair = *astronaut->begin();
		custom_set * temp_set = new custom_set;
		journeyToMoon(id_pair, astronaut, temp_set, ++astronaut->begin());
		sets_of_bounded_astronauts.push_back(*temp_set);
		num_bounded_astronauts_each_set.push_back(sets_of_bounded_astronauts.back().size()); //why doesn't this work???? won't return size
		num_bounded_astronauts_total += sets_of_bounded_astronauts.back().size(); //why won't this work???? won't return size
		delete temp_set;
	}

	num_free_astronauts = n - num_bounded_astronauts_total;

	for (int i = 0; i < num_bounded_astronauts_each_set.size() - 1; i++)
	{
		for (int j = i + 1; j < num_bounded_astronauts_each_set.size(); j++)
			result += num_bounded_astronauts_each_set[i] * num_bounded_astronauts_each_set[j];
		result += num_free_astronauts * num_bounded_astronauts_each_set[i];
	}

	result += num_free_astronauts * num_bounded_astronauts_each_set.back() + (num_free_astronauts * (num_free_astronauts - 1))/2;

	return result;
}

pair<int, int> journeyToMoon(pair<int, int> id_pair1, unordered_set<pair<int, int> , hash<pair<int, int>>> * astronaut,
	custom_set * temp_set, unordered_set<pair<int, int>, hash<pair<int, int>>>::iterator it)
{
	
	while (it != astronaut->end()) {
		// copy the current iterator then increment it
		astronaut->erase(id_pair1);
		pair<int, int> id_pair2 = *it++;
	
		if (id_pair2.first == id_pair1.first || id_pair2.first == id_pair1.second || id_pair2.second == id_pair1.first
			|| id_pair2.second == id_pair1.second)
		{			
			temp_set->pairs_insert({ id_pair1, journeyToMoon(id_pair2, astronaut, temp_set, 
				id_pair2 != *astronaut->begin() ? astronaut->begin() : ++astronaut->begin()) });
		}
	}
	astronaut->erase(id_pair1);
	temp_set->pair_insert(id_pair1); //the case where id_pair1 is not matched with any other pairs in the list and also the case
	//where astronaut.size() == 1; if it so happens that id_pair1 was already inserted then the functionality of sets prevents duplicates

	return id_pair1;

}

int main()
{
	
	//ofstream fout(getenv("OUTPUT_PATH"));

	string np_temp;
	std::getline(std::cin, np_temp);

	vector<string> np = split_string(np_temp);

	int n = stoi(np[0]);

	int p = stoi(np[1]);

	unordered_set<pair<int, int>, hash<pair<int, int>>> * astronaut = new unordered_set<pair<int, int>, hash<pair<int, int>>>(p);
	for (int i = 0; i < p; i++) {
		int a, b;
		std::cin >> a >> b;
		astronaut->insert(pair<int, int>(a, b));
		}

	std::cin.ignore(numeric_limits<streamsize>::max(), '\n');

	int result = journeyToMoon(n, astronaut);

	//fout << result << "\n";
	std::cout << result << "\n";
	//fout.close();
	delete astronaut;

	return 0;
}

vector<string> split_string(string input_string)
{
	string::iterator new_end = unique(input_string.begin(), input_string.end(), [](const char &x, const char &y) {
		return x == y && x == ' ';
	});

	input_string.erase(new_end, input_string.end());

	while (input_string[input_string.length() - 1] == ' ') {
		input_string.pop_back();
	}

	vector<string> splits;
	char delimiter = ' ';

	size_t i = 0;
	size_t pos = input_string.find(delimiter);

	while (pos != string::npos) {
		splits.push_back(input_string.substr(i, pos - i));

		i = pos + 1;
		pos = input_string.find(delimiter, i);
	}

	splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

	return splits;
}