Arpakuutiot

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <sstream>
#include <vector>
#include <string>
#include <algorithm>
#include <bits/stdc++.h> 
#define lint long long int
 
using namespace std;
 
int Target_x = 0;
int Target_y = 0;
 
string grid_a[5][5];
 
bool isDuplicate(string compare, vector<string> usedLib)
{
	for(int i = 0; i < (int)usedLib.size(); i++)
	{
		if(usedLib[i].find_first_not_of(compare) == string::npos)
		{
			return true;
		}
	}
	return false;
}
 
string convert_string(int x)
{
	stringstream ss;
    ss << x;
    return ss.str();
}
 
string areaSearch(bool RowWithFour, bool searchTarget, int start_x, int start_y)
{
	//Moves
	int primary_x[] = {-2,2,0,0};
	int primary_y[] = {0,0,-2,2};
	
	int FourRow_x[] = {-1,-1,  1, 1,-2,-2, 2, 2};
	int FourRow_y[] = {-2, 2, -2, 2,-2, 2,-2, 2};
	
	int NoFourRow_x[] = {-2, -2, 2, 2};
	int NoFourRow_y[] = {-1, 1, -1, 1};
	
	int NewTarget_x[] = {-1,1,0,0};
	int NewTarget_y[] = {0,0,-1,1};
	
	bool SearchNew = false;
	//Find a pair for starter node
		while(true)
		{
		int q = (SearchNew && RowWithFour)?8:4;
		for(int o = 0; o < q; o++)
		{	
			int x_ax = start_x + primary_x[o];
			int y_ax = start_y + primary_y[o];
			
			if(SearchNew && RowWithFour)
			{
				x_ax = start_x + FourRow_x[o];
				y_ax = start_y + FourRow_y[o];
			}
			if(SearchNew && !RowWithFour)
			{
				x_ax = start_x + NoFourRow_x[o];
				y_ax = start_y + NoFourRow_y[o];
			}
			if(searchTarget)
			{
				x_ax = start_x + NewTarget_x[o];
				y_ax = start_y + NewTarget_y[o];
			}
			
			//Is node within bounds? No? Then lets skip it cause we aint gon cause no outofbound exception
			if(x_ax < 0 || y_ax < 0 || x_ax >= 5 || y_ax >= 5) {
				continue;
			}
			
			else if(grid_a[x_ax][y_ax] != ".")
			{
				Target_x = x_ax;
				Target_y = y_ax;			
				string s = ""+grid_a[x_ax][y_ax];
				
				return s;
			}
		}
			SearchNew = true;
		}
}
 
 
 
string new_rep(string xy[])
{
	string result = "";
	
	for(int j = 0; j < 25; j++)
	{
		result += xy[j];
	}
	
	string pair1[2];
	string pair2[2];
	string pair3[2];
	
	string grid[5][5];
	
	string inp = result;
	
	int index = 0;
	
	int start_x = -1;
	int start_y = -1;
	
	int RWF = 0;
	bool RowWithFour = false;
 
	for(int y = 0; y < 5; y++)
	{
		RWF = 0;
		for(int x = 0; x < 5; x++)
		{
			grid[x][y] = inp[index];
			grid_a[x][y] = inp[index];
 
			bool isN = inp[index] != '.';
			
			if(isN && start_x == -1)
			{
				start_x = x;
				start_y = y;
			}
			if(isN)
			{
				RWF++;
			}
			index++;
			if(RWF == 4) {
				RowWithFour = true;
			}
		}
	}
	
	//Used for finding last pair
	pair1[0] = grid[start_x][start_y];
	pair1[1] = areaSearch(RowWithFour, false, start_x, start_y);
	
	pair2[0] = areaSearch(RowWithFour, true, start_x, start_y);
	pair2[1] = areaSearch(RowWithFour, false, Target_x, Target_y);
	
	string Used_Numbers = "" + pair1[0] + pair1[1] + pair2[0] + pair2[1];
	for(int i = 1; i <= 6; i++)
	{
		if(Used_Numbers.find(convert_string(i)) == std::string::npos)
		{
			Used_Numbers += convert_string(i);
		}
	}
	
	return Used_Numbers;
 
}
 
bool areSame(string one, string two)
{
	
	string one_sub1 = one.substr(0,2);
	string one_sub2 = one.substr(2,2);
	
	string two_subs[] = {two.substr(0,2),two.substr(2,2),two.substr(4,2)};
	
	bool ContainsOne = false;
	for(int i = 0; i < 3; i++)
	{
		if(two_subs[i].find(one_sub1[0]) != std::string::npos && two_subs[i].find(one_sub1[1]) != std::string::npos)
		{
			ContainsOne = true;
		}
	}
	bool ContainsTwo = false;
	for(int i = 0; i < 3; i++)
	{
		if(two_subs[i].find(one_sub2[0]) != std::string::npos && two_subs[i].find(one_sub2[1]) != std::string::npos)
		{
			ContainsTwo = true;
		}
	}
	return ContainsOne && ContainsTwo;
}
 
int main()
{
	int n;
	cin >> n;
	string dice[25];
	
	string Dice_Collection[n];
 
	for(int dices = 0; dices < n; dices++)
	{
		int n = 0;
		
		for(int i = n; i < 25; i++)
		{
			char c;
			cin >> c;
			string s(1,c);
			dice[i] = s;
		}
		Dice_Collection[dices] = new_rep(dice);
	}
	
	string library[n*n];
	bool Empty = true;
	int s = 0;
	//NOW COMPARE ALL
	for(int i = 0; i < n; i++)
	{
		Empty = true;
		for(int j = 0; j < n; j++)
		{
			if(i == j) {
				continue;
			}
			//Check if two dice are the same
			if(areSame(Dice_Collection[abs(i-(n-1))], Dice_Collection[abs(j-(n-1))]))
			{
				library[s] = convert_string(abs(i-n)) + " " + convert_string(abs(j-n)) + '\n';
				Empty = false;
				s++;
			}
			//If havent been same for whole loop;
		}
		if(Empty)
		{
			library[s] = "-\n";
			s++;
		}
	}
	
	//REVERSE THIS LIBRARY CAUSE WE WANT TO ITERATE IT 0 TO 1
	int begin = 0;
	int ending = s - 1;
 
	while (begin < ending)
    {
        string emp = library[begin]; 
        library[begin] = library[ending];
        library[ending] = emp;
        begin++;
        ending--;
    } 
    
    vector<string> used_lib;
    vector<string> last_library;
	
	//NOW FIND DUPLICATES
	for(int i = 0; i < s; i++)
	{
		if(library[i] == "-\n")
		{
			last_library.push_back(library[i]);
			continue;
		}
		else if(!isDuplicate(library[i], used_lib) || true)
		{
			used_lib.push_back(library[i]);
			last_library.push_back(library[i]);
		}
	}

	for(int i = (int)last_library.size()-1; i >= 0; i--)
	{
		cout << last_library[i];
	}
	return 0;
}

Test 1

Group: 1, 2

Verdict: WRONG ANSWER

Test 2

Group: 1, 2

Verdict: WRONG ANSWER

Test 3

Group: 1, 2

Verdict: WRONG ANSWER

Test 4

Group: 1, 2

Verdict: WRONG ANSWER

Test 5

Group: 1, 2

Verdict: WRONG ANSWER

Test 6

Group: 1, 2

Verdict: WRONG ANSWER

Test 7

Group: 1, 2

Verdict: WRONG ANSWER

Test 8

Group: 1, 2

Verdict: WRONG ANSWER

Test 9

Group: 1, 2

Verdict: WRONG ANSWER

Test 10

Group: 1, 2

Verdict: WRONG ANSWER

Test 11

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 25

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 26

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 27

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 28

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 29

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 30

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 31

Group: 1, 2

Verdict: WRONG ANSWER