#include <iostream>
using std::ostream;
using std::cout;
using std::cin;

#include <fstream>
using std::ifstream;

#include <windows.h>

#include "string.h"

#include "Queue.h"

LARGE_INTEGER tick1, tick2, ticksPerSecond;
double time, timeThinking, timeDoing, totalThinking, totalDoing;

class Domain
{
	public:
		Domain();

		void Dump() const;
		unsigned Size() const;
		bool Contains(const unsigned n) const;
		bool Insert(const unsigned n);
		bool Remove(const unsigned n);

	private:
		unsigned domain[9];
		unsigned size;
};

Domain::Domain()
:size(9)
{
	for(unsigned i=0; i<9; i++)
		domain[i] = i+1;
}

void Domain::Dump() const
{
	for(unsigned i=0; i<9; i++)
	{
		if(i == size) cout << "|";
		cout << domain[i];
	}

	cout << "\n";
}

unsigned Domain::Size() const
{ return size; }

bool Domain::Contains(const unsigned n) const
{
	for(unsigned i=0; i<size; i++)
		if(domain[i] == n)
			return true;

	return false;
}

bool Domain::Insert(const unsigned n)
{
	for(unsigned i=size; i<9; i++)
	{
		if(domain[i] == n)
		{
			domain[i] = domain[size];
			domain[size] = n;
			size++;
			return true;
		}
	}

	return false;
}

bool Domain::Remove(const unsigned n)
{
	for(unsigned i=0; i<size; i++)
	{
		if(domain[i] == n)
		{
			size--;
			domain[i] = domain[size];
			domain[size] = n;
			return true;
		}
	}

	return false;
}

////////////////////////////////////////////////////////////

class Square
{
	public:
		Square();

		bool AddToDomain(const unsigned n);
		bool RemoveFromDomain(const unsigned n);
		bool DomainContains(const unsigned n);
		unsigned DomainSize();

		bool IsPermanent() const;

		void SetValue(const unsigned n, bool perm = false);
		unsigned GetValue() const;

	private:
		unsigned val;
		bool permanent;
		Domain dom;
};

Square::Square()
:permanent(false), val(0)
{}

bool Square::AddToDomain(const unsigned n)
{ return dom.Insert(n); }

bool Square::RemoveFromDomain(const unsigned n)
{ return dom.Remove(n); }

bool Square::DomainContains(const unsigned n)
{ return dom.Contains(n); }

unsigned Square::DomainSize()
{ return dom.Size(); }

bool Square::IsPermanent() const
{ return permanent; }

void Square::SetValue(const unsigned n, bool perm)
{
	val = n;
	permanent = perm;
}

unsigned Square::GetValue() const
{ return val; }

////////////////////////////////////////////////////////////

struct SuDoKu
{
	SuDoKu();
	SuDoKu(const SuDoKu& S);
	SuDoKu& operator=(const SuDoKu& S);
	bool Filled() const;
	void Set(unsigned r, unsigned c, unsigned val, bool permanent = false);
	Square** grid;
};

SuDoKu::SuDoKu()
{
	grid = new Square*[9];
	for(unsigned i=0; i<9; i++)
		grid[i] = new Square[9];
}

SuDoKu::SuDoKu(const SuDoKu& S)
{
	unsigned i;

	grid = new Square*[9];
	for(i=0; i<9; i++)
		grid[i] = new Square[9];

	for(i=0; i<81; i++)
		grid[i/9][i%9] = S.grid[i/9][i%9];
}

SuDoKu& SuDoKu::operator=(const SuDoKu& S)
{
	if(&S == this)
		return *this;

	unsigned i;

	for(i=0; i<81; i++)
		grid[i/9][i%9] = S.grid[i/9][i%9];

	return *this;
}

bool SuDoKu::Filled() const
{
	for(unsigned i=0; i<81; i++)
		if(grid[i/9][i%9].GetValue() == 0)
			return false;

	return true;
}

void SuDoKu::Set(unsigned r, unsigned c, unsigned val, bool permanent)
{
	grid[r][c].SetValue(val, permanent);

	if(permanent && val != 0)
	{
		for(unsigned x=0; x<9; x++)
		{
			if(x != r)
				grid[x][c].RemoveFromDomain(val);
			if(x != c)
				grid[r][x].RemoveFromDomain(val);
		}

		for(unsigned row = r - r%3; row < r - r%3 + 3; row++)
			for(unsigned col = c - c%3; col < c - c%3 + 3; col++)
				if(r != row && c != col)
					grid[row][col].RemoveFromDomain(val);
	}
}

ostream& operator<<(ostream& out, SuDoKu& S)
{
	for(unsigned r=0; r<9; r++)
	{
		if(r%3 == 0)
			out << "+-----+-----+-----+\n|";
		else
			out << "|     |     |     |\n|";

		for(unsigned c=0; c<9; c++)
		{
			if(S.grid[r][c].GetValue() != 0)
				out << S.grid[r][c].GetValue();
			else
				out << " ";

			if(c%3 == 2)
				out << "|";
			else
				out << " ";
		}

		out << "\n";
	}

	out << "+-----+-----+-----+\n";

	return out;
}

////////////////////////////////////////////////////////////

struct MyArc
{
	MyArc(unsigned a, unsigned b, unsigned c, unsigned d);
	unsigned r1, c1, r2, c2;
};

MyArc::MyArc(unsigned a, unsigned b, unsigned c, unsigned d)
:r1(a), c1(b), r2(c), c2(d)
{}

////////////////////////////////////////////////////////////

bool RemoveInconsistencies(SuDoKu& S, MyArc& a)
{
	if(S.grid[a.r2][a.c2].DomainSize() == 1)
	{
		unsigned n;
		for(n=1; n<=9; n++)
			if(S.grid[a.r2][a.c2].DomainContains(n) && S.grid[a.r1][a.c1].DomainContains(n))
			{
				S.grid[a.r1][a.c1].RemoveFromDomain(n);
				return true;
			}
	}

	return false;
}

bool MAC3(SuDoKu& S, const unsigned r, const unsigned c)
{
	Queue<MyArc> q;

	for(unsigned x=0; x<81; x++)
		for(unsigned y=x; y<81; y++)
			if(y != x && S.grid[x/9][x%9].GetValue() == 0 && S.grid[y/9][y%9].GetValue() == 0 && (y/9 == x/9 || y%9 == x%9 || ( (y%9)/3 == (x%9)/3 && (y/9)/3 == (x/9)/3 )) && !S.grid[x/9][x%9].IsPermanent() && !S.grid[y/9][y%9].IsPermanent() )
			{
				q.Enqueue(MyArc(x/9, x%9, y/9, y%9));
				q.Enqueue(MyArc(y/9, y%9, x/9, x%9));
			}

	while(!q.Empty())
	{
		MyArc a = q.Dequeue();
		if(RemoveInconsistencies(S, a))
		{
			if(S.grid[a.r1][a.c1].DomainSize() == 0)
			{
				QueryPerformanceCounter(&tick2);
				time = tick2.QuadPart - tick1.QuadPart;
				timeThinking += time / ticksPerSecond.QuadPart;
				QueryPerformanceCounter(&tick1);

				return false;
			}
			for(unsigned x=0; x<9; x++)
			{
				if(x != r && !S.grid[x][c].IsPermanent())
					q.Enqueue(MyArc(x, c, r, c));
				if(x != c && !S.grid[r][x].IsPermanent())
					q.Enqueue(MyArc(r, x, r, c));
			}

			for(unsigned row = r - r%3; row < r - r%3 + 3; row++)
				for(unsigned col = c - c%3; col < c - c%3 + 3; col++)
					if(r != row && c != col && !S.grid[row][col].IsPermanent())
						q.Enqueue(MyArc(row, col, r, c));
		}
	}

	QueryPerformanceCounter(&tick2);
	time = tick2.QuadPart - tick1.QuadPart;
	timeThinking += time / ticksPerSecond.QuadPart;
	QueryPerformanceCounter(&tick1);

	return true;
}

char asdf[10];

SuDoKu RecursiveArcConsistencySearch(SuDoKu& S, const unsigned r, const unsigned c)
{
	if(S.grid[r][c].IsPermanent())
		return RecursiveArcConsistencySearch(S, r + 1*(c == 8), (c + 1) % 9);

	for(unsigned n=1; n<=9; n++)
	{
		if(S.grid[r][c].DomainContains(n))
		{
			SuDoKu Su(S);
			Su.grid[r][c].SetValue(n);

			if(Su.Filled())
				return Su;

			QueryPerformanceCounter(&tick2);
			time = tick2.QuadPart - tick1.QuadPart;
			timeDoing += time / ticksPerSecond.QuadPart;
			QueryPerformanceCounter(&tick1);

			for(unsigned x=0; x<9; x++)
			{
				if(x != r)
					Su.grid[x][c].RemoveFromDomain(n);
				if(x != c)
					Su.grid[r][x].RemoveFromDomain(n);
			}

			for(unsigned row = r - r%3; row < r - r%3 + 3; row++)
				for(unsigned col = c - c%3; col < c - c%3 + 3; col++)
					if(r != row && c != col && Su.grid[row][col].GetValue() == 0)
						Su.grid[row][col].RemoveFromDomain(n);
			
			if(MAC3(Su, r, c))
			{
				Su = RecursiveArcConsistencySearch(Su, r + 1*(c == 8), (c + 1) % 9);

				if(Su.Filled())
					return Su;
			}
		}
	}

	return S;
}

int main()
{
	SuDoKu *S1;
	unsigned x;

	ifstream in;
	in.open("SuDoKu.txt");
	if(in.fail())
		exit(0);

	QueryPerformanceFrequency(&ticksPerSecond);

	totalThinking = totalDoing = 0;

	while(in >> x)
	{
		S1 = new SuDoKu;
		S1->Set(0, 0, x, x != 0);

		for(unsigned i=1; i < 81; i++)
		{
			in >> x;
			S1->Set(i/9, i%9, x, x != 0);
		}

		cout << *S1;
		timeDoing = 0;
		timeThinking = 0;
		QueryPerformanceCounter(&tick1);
		SuDoKu S2 = RecursiveArcConsistencySearch(*S1, 0, 0);
		QueryPerformanceCounter(&tick2);
		time = tick2.QuadPart - tick1.QuadPart;
		timeDoing += time / ticksPerSecond.QuadPart;

		if(S2.Filled())
			cout << S2;
		else
			cout << "No Solution\n";

		cout << "Doing: " << timeDoing << " seconds\n";
		cout << "Thinking: " << timeThinking << " seconds\n\n";

		totalDoing+= timeDoing;
		totalThinking += timeThinking;
	}

	cout << "Total Time Doing: " << totalDoing << " seconds\n";
	cout << "Total Time Thinking: " << totalThinking << " seconds\n\n";

	return 0;
}