Kortit II

input/code.cpp:1:25: warning: extra tokens at end of #include directive
    1 | #include "bits/stdc++.h";
      |                         ^
input/code.cpp: In function 'std::string Hash(int, std::vector<int>, std::vector<int>, int, int, int)':
input/code.cpp:26:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   26 |         for (int i = 0; i < aHand.size(); i++)
      |                         ~~^~~~~~~~~~~~~~
input/code.cpp:21:16: warning: unused variable 'returnHash' [-Wunused-variable]
   21 |         size_t returnHash = cards;
      |                ^~~~~~~~~~
input/code.cpp:36:22: warning: unused variable 'hasher' [-Wunused-variable]
   36 |         hash<string> hasher;
      |                      ^~~~~~
input/code.cpp: In function 'int EvaluateBranch(int, std::vector<int>, std::vector<int>, int, int, int)':
input/code.cpp:84:27: warning: comparison of integer expressions of...

#include "bits/stdc++.h";
#include <unordered_set>

using namespace std;

// Yhteisiä yhdelle testille.
int cardCount = 0;
int aTarget = 0;
int bTarget = 0;
int maxZeros = 0;

// Ei enään oikeasti hashejä
unordered_map<string, int> seenHashes;
string correctHash;

//Debug
int CALLS = 0;

string Hash(int cards, vector<int> aHand, vector<int> bHand, int aPoints, int bPoints, int zeros)
{
	size_t returnHash = cards;

	string hashString = to_string(cards);
	
	
	for (int i = 0; i < aHand.size(); i++)
	{
		hashString += to_string(aHand[i]);
		hashString += to_string(bHand[i]);
	}

	hashString += to_string(aPoints);
	hashString += to_string(bPoints);
	hashString += to_string(zeros);

	hash<string> hasher;

	//return hasher(hashString);
	return hashString;
}

// Ei lisää oikeaa hashiä
void AddHash(string hash, int count)
{
	if (hash != correctHash)
	{
		seenHashes.insert(pair<string, int>(hash, count));
	}
}

// Cards kuvaa montako korttia pelaajilla on jäljellä.
int EvaluateBranch(int cards, vector<int> aHand, vector<int> bHand, int aPoints, int bPoints, int zeros)
{
	CALLS++;
	// Ei kortteja jäljellä
	if (!(cards > 0))
	{
		if (aPoints == aTarget && bPoints == bTarget && zeros == maxZeros)
		{
			// Päivitetään oikea hash
			if (correctHash == "e")
			{
				correctHash = Hash(cards, aHand, bHand, aPoints, bPoints, zeros);
				seenHashes.erase(correctHash);
			}
			return 1;
		}
		else
		{
			return 0;
		}
	}
	// Onko joku maksimi ylitetty?
	if (aPoints > aTarget || bPoints > bTarget || zeros > maxZeros)
	{
		return 0;
	}

	int answer = 0;

	vector<vector<int>> newBHands;
	newBHands.reserve(bHand.size());

	for (int j = 0; j < bHand.size(); j++)
	{
		vector<int> newBHand = bHand;
		swap(newBHand[j], newBHand.back());
		newBHand.pop_back();

		newBHands.push_back(newBHand);
	}

	for (int i = 0; i < aHand.size(); i++)
	{
		vector<int> newAHand = aHand;
		swap(newAHand[i], newAHand.back());
		newAHand.pop_back();

		for (int j = 0; j < bHand.size(); j++)
		{
			int aPoint = 0;
			int bPoint = 0;
			int zero = 0;

			if (aHand[i] != bHand[j])
			{
				if (aHand[i] > bHand[j])
				{
					aPoint++;
				}
				else
				{
					bPoint++;
				}
			}
			else
			{
				zero++;
			}

			string currentHash = Hash(cards - 1, newAHand, newBHands[j], aPoints + aPoint, bPoints + bPoint, zeros + zero);

			if (!seenHashes.contains(currentHash))
			{
				int branchValue = EvaluateBranch(cards - 1, newAHand, newBHands[j], aPoints + aPoint, bPoints + bPoint, zeros + zero);
				answer += branchValue;
				
				AddHash(currentHash, branchValue);
			}
			else
			{
				answer += seenHashes.at(currentHash);

			}
			answer %= 1000000007;
		}
	}
	return answer;
}

void Evaluate(int n, int a, int b)
{
	cardCount = n;
	aTarget = a;
	bTarget = b;
	maxZeros = n - a - b;
	CALLS = 0;
	seenHashes.clear();
	// Ei voi olla koskaan e.
	correctHash = "e";

	if (a + b > n)
	{
		cout << "0\n";
		return;
	}

	vector<int> baseHand;

	for (int i = 0; i < n; i++)
	{
		baseHand.push_back(i + 1);
	}

	cout << EvaluateBranch(n, baseHand, baseHand, 0, 0, 0) << "\n";
	//cout << "Made " << CALLS << " evaluation calls\n";
}

int main()
{
	int testCount = 0;
	cin >> testCount;

	for (int i = 0; i < testCount; i++)
	{
		int n, a, b;
		cin >> n >> a >> b;

		Evaluate(n, a, b);
	}

}

Test 1

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 2

Group: 2, 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 3

Group: 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 5

Group: 5

Verdict: RUNTIME ERROR

Test 6

Group: 5

Verdict: RUNTIME ERROR