Kortit I

input/code.cpp:1:22: warning: extra tokens at end of #include directive
    1 | #include "bits/stdc++.h";
      |                      ^
input/code.cpp:2:25: warning: extra tokens at end of #include directive
    2 | #include <unordered_set>;
      |                         ^

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

using namespace std;

struct gameState
{
	set<int> aHand = set<int>();
	int aScore = 0;

	set<int> bHand = set<int>();
	int bScore = 0;

	bool operator==(const gameState& other) const
	{
		return this->aHand == other.aHand && this->bHand == other.bHand && this->aScore == other.aScore && this->bScore == other.bScore;
	}

	
};
class HashFunction
{
public:
	size_t operator()(const gameState& state) const
	{
		string returnValue = to_string(state.aScore);
		returnValue.append(to_string(state.bScore));

		for (int a : state.aHand)
		{
			returnValue.append(to_string(a));
		}
		for (int b : state.bHand)
		{
			returnValue.append(to_string(b));
		}

		hash<string> hasher;
		return hasher(returnValue);
	}
};

struct gameResult
{
	bool success = false;

	vector<int> aMoves = vector<int>();
	vector<int> bMoves = vector<int>();
};

struct searchable
{
	searchable(gameState newState, int newA, int newB, gameResult result)
	{
		state = newState; currentResult = result;
	}

	gameState state;
	gameResult currentResult;
};

// Etsitään ratkaisu rekursiivisesti.
gameResult Search(gameState state, int a, int b)
{
	vector<searchable> queue = vector<searchable>();
	queue.push_back(searchable(state, a, b, gameResult()));
	unordered_set<gameState, HashFunction> searchedStates = unordered_set<gameState, HashFunction>();

	while (!queue.empty())
	{
		searchable currentSearch = queue[queue.size() - 1];
		queue.pop_back();

		// Ei enään pelattavia kortteja
		if (currentSearch.state.aHand.size() == 0)
		{
			if (currentSearch.state.aScore == a && currentSearch.state.bScore == b)
			{
				currentSearch.currentResult.success = true;

				return currentSearch.currentResult;
			}
			continue;
		}

		// On kortteja
		for (int moveA : currentSearch.state.aHand)
		{
			for (int moveB : currentSearch.state.bHand)
			{
				searchable newSeachable = currentSearch;

				if (moveA != moveB)
				{
					if (moveA > moveB)
					{
						newSeachable.state.aScore++;
					}
					else
					{
						newSeachable.state.bScore++;
					}
				}

				newSeachable.state.aHand.erase(moveA);
				newSeachable.state.bHand.erase(moveB);

				if (!searchedStates.contains(newSeachable.state))
				{
					newSeachable.currentResult.aMoves.push_back(moveA);
					newSeachable.currentResult.bMoves.push_back(moveB);

					queue.push_back(newSeachable);
					searchedStates.insert(newSeachable.state);
				}
			}
		}
	}
	return gameResult();
}

void EvaluateTest(int n, int a, int b)
{
	// Tarkistetaan onko pisteitä enemmän kuin kortteja
	if (a + b > n)
	{
		cout << "NO";
		return;
	}

	// Luodaan molempien pakat
	set<int> playerADeck = set<int>();
	set<int> playerBDeck = set<int>();
	for (int i = 0; i < n; i++)
	{
		playerADeck.insert(i + 1);
		playerBDeck.insert(i + 1);
	}

	gameState originalState;
	originalState.aHand = playerADeck;
	originalState.bHand = playerBDeck;

	gameResult originalResult;

	gameResult gameResult = Search(originalState, a, b);

	if (!gameResult.success)
	{
		cout << "NO";
		return;
	}

	cout << "YES\n";

	for (int i = 0; i < n; i++)
	{
		cout << gameResult.aMoves[i];
		if (i != n - 1)
		{
			cout << " ";
		}
	}
	cout << "\n";
	for (int i = 0; i < n; i++)
	{
		cout << gameResult.bMoves[i];
		if (i != n - 1)
		{
			cout << " ";
		}
	}

	/*
	// Kortit jotka ollaan pelattu.
	vector<int> playerAPlayed = vector<int>();
	vector<int> playerBPlayed = vector<int>();

	int played = 0;

	// Montako samaa korttia pelattiin?
	int zeros = n - (a + b);

	for (int i = 0; i < zeros; i++)
	{
		// Esim n=5, jolloin n-played-1 = 4 jos ei yht��n pelattu, joka on viimeinen elementti
		playerAPlayed.push_back(playerADeck[n - played - 1]);
		playerADeck.pop_back();
		playerBPlayed.push_back(playerBDeck[n - played - 1]);
		playerBDeck.pop_back();

		played++;
	}

	// A:n voitot
	for (int i = 0; i < a; i++)
	{
		// A pelaa isoimman
		int aMax = playerADeck[n - played - 1];
		int bCard = playerBDeck[0];

		//cout << "aMax: " << aMax << " bCard: " << bCard << "\n";

		// Onko a:n kortti isompi kuin b:n?
		if (!(aMax > bCard))
		{
			//cout << "A not greater\n";
			cout << "NO";
			return;
		}

		playerAPlayed.push_back(aMax);
		playerADeck.pop_back();
		playerBPlayed.push_back(bCard);
		playerBDeck.erase(playerBDeck.begin());

		played++;
	}*/
	/*
	cout << "Decks\n";
	for (int tt : playerADeck)
	{
		cout << tt << " ";
	}
	cout << "\n";
	for (int tt : playerBDeck)
	{
		cout << tt << " ";
	}
	cout << "\n";*/

	/*
	//B:n voitot
	for (int i = 0; i < b; i++)
	{
		int aMax = playerADeck[n - played - 1];
		int bMax = playerBDeck[n - played - 1];

		//cout << "aMax: " << aMax << " bMax: " << bMax << "\n";

		if (!(bMax > aMax))
		{
			//cout << "B not greater\n";
			cout << "NO";
			return;
		}

		playerAPlayed.push_back(aMax);
		playerADeck.pop_back();
		playerBPlayed.push_back(bMax);
		playerBDeck.pop_back();

		played++;
	}

	cout << "YES\n";

	for (int i = 0; i < n; i++)
	{
		cout << playerAPlayed[i];
		if (i != n - 1)
		{
			cout << " ";
		}
	}
	cout << "\n";
	for (int i = 0; i < n; i++)
	{
		cout << playerBPlayed[i];
		if (i != n - 1)
		{
			cout << " ";
		}
	}*/
}

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

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

		EvaluateTest(n, a, b);

		if (i < testCount - 1)
		{
			cout << "\n";
		}
	}
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 3

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 5

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 7

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 11

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 3

Verdict: TIME LIMIT EXCEEDED