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 'size_t Hash(int, std::vector<int>, std::vector<int>, int, int, int)':
input/code.cpp:27:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   27 |         for (int i = 0; i < aHand.size(); i++)
      |                         ~~^~~~~~~~~~~~~~
input/code.cpp: In function 'int EvaluateBranch(int, std::vector<int>, std::vector<int>, int, int, int)':
input/code.cpp:87:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   87 |         for (int j = 0; j < bHand.size(); j++)
      |                         ~~^~~~~~~~~~~~~~
input/code.cpp:98:27: warning: comparison of integer expressions of different signedness: 'int' and '...

#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<size_t, int> seenHashes;
size_t correctHash;
bool correctHashSet = false;

//Debug
int CALLS = 0;
int TOTALCALLS = 0;

size_t Hash(int cards, vector<int> aHand, vector<int> bHand, int aPoints, int bPoints, int zeros)
{
	string hashString;
	hashString += cards;
	// Kertaa 4 koska numeroiden maks pituus on 4, 100 on ekstra tilaa.
	hashString.reserve(hashString.size() + 4 * aHand.size() + 4 * bHand.size() + 100);
	for (int i = 0; i < aHand.size(); i++)
	{
		hashString += aHand[i];
		hashString += bHand[i];
	}

	hashString += aPoints;
	hashString += bPoints;
	hashString += zeros;

	hash<string> hasher;

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

// Ei lisää oikeaa hashiä
void AddHash(size_t hash, int count)
{
	if (hash != correctHash)
	{
		seenHashes.insert(pair<size_t, 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++;
	TOTALCALLS++;
	// Ei kortteja jäljellä
	if (!(cards > 0))
	{
		if (aPoints == aTarget && bPoints == bTarget && zeros == maxZeros)
		{
			// Päivitetään oikea hash
			if (!correctHashSet)
			{
				correctHash = Hash(cards, aHand, bHand, aPoints, bPoints, zeros);
				seenHashes.erase(correctHash);
				correctHashSet = true;
			}
			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();

		newBHand.erase(newBHand.begin() + j);
		
		newBHands.push_back(move(newBHand));
	}

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

		newAHand.erase(newAHand.begin() + i);

		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++;
			}

			size_t 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.
	hash<string> hasher;
	correctHash = hasher("e");
	correctHashSet = false;

	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