110902 Playing with Wheels

#include <iostream>
#include <string>
#include <set>
#include <vector>

using namespace std;

static void GetDigitsFromNumber(int number, int& thousands, int& hundreds, int& tens, int& ones)
{
	ones = number % 10;
	number /= 10;
	tens = number % 10;
	number /= 10;
	hundreds = number % 10;
	thousands = number / 10;
}

static void GetDigitsFromNumber(int number, int* digits)
{
	GetDigitsFromNumber(number, digits[0], digits[1], digits[2], digits[3]);
}

static int FromDigitsToNumber(int thousands, int hundreds, int tens, int ones)
{
	return thousands * 1000 + hundreds * 100 + tens * 10 + ones;
}

static int FromDigitsToNumber(int* digits)
{
	return digits[0] * 1000 + digits[1] * 100 + digits[2] * 10 + digits[3];
}

static int GetNumber()
{
	int a, b, c, d;
	cin >> a >> b >> c >> d;

	return FromDigitsToNumber(a, b, c, d);
}

static int Inc(int number)
{
	if (number == 9)
		return 0;
	return number + 1;
}

static int Dec(int number)
{
	if (number == 0)
		return 9;
	return number - 1;
}

static void AddCandidate(
	int candidate, 
	const set<int>& forbidden, 
	const set<int>& processed,
	set<int>& candidates)
{
	if ((forbidden.find(candidate) == forbidden.end()) &&
		(processed.find(candidate) == processed.end()))
		candidates.insert(candidate);
}

static void GetPossibleChanges(
	int number, 
	const set<int>& forbidden, 
	const set<int>& processed,
	set<int>& candidates)
{
	int digits[4];
	GetDigitsFromNumber(number, digits[0], digits[1], digits[2], digits[3]);

	for (int i = 0; i < 4; ++i)
	{
		int original = digits[i];
		digits[i] = Inc(original);
		int candidate = FromDigitsToNumber(digits);
		AddCandidate(candidate, forbidden, processed, candidates);
		digits[i] = Dec(original);
		candidate = FromDigitsToNumber(digits);
		AddCandidate(candidate, forbidden, processed, candidates);
		digits[i] = original;
	}
}

struct NumberInfo
{
	NumberInfo(int value, int prev) : m_value(value), m_prevIndex(prev) {}
	int m_value;
	int m_prevIndex;
};

static int GetMinTimes(int start, int target, const set<int> forbidden)
{
	if (start == target)
		return 0;

	set<int> visited;
	visited.insert(start);

	vector<NumberInfo> toProcess;
	toProcess.push_back(NumberInfo(start, 0));

	size_t processed = 0;
	int targetIndex = -1;
	while(processed < toProcess.size())
	{
		int current = toProcess[processed].m_value;
		set<int> candidates;
		GetPossibleChanges(current, forbidden, visited, candidates);
		set<int>::iterator iter = candidates.begin();
		while (iter != candidates.end())
		{
			toProcess.push_back(NumberInfo(*iter, processed));

			if (*iter == target)
			{
				targetIndex = toProcess.size() - 1;
				break;
			}

			visited.insert(*iter);
			++iter;
		}

		if (targetIndex >= 0)
			break;

		++processed;
	}

	if (targetIndex < 0)
		return -1;
	else
	{
		int times = 0;
		while(targetIndex != 0)
		{
			targetIndex = toProcess[targetIndex].m_prevIndex;
			++times;
		}
		return times;
	}
}

static void DoTest()
{
	int start = GetNumber(), target = GetNumber(), cnt;
	set<int> forbidden;
	cin >> cnt;
	for (int i = 0; i < cnt; ++i)
		forbidden.insert(GetNumber());

	cout << GetMinTimes(start, target, forbidden) << endl;
}

static void Test()
{
	int cnt;
	cin >> cnt;
	for (int i = 0; i < cnt; ++i)
		DoTest();
}

int main(int argc, char* argv[])
{
	Test();
	return 0;
}