Vijos P1016 钟表问题 BFS+剪枝

vijos P1016
九个钟表分别有4种状态  0点，3点，6点，9点。分别用数字表示为：0，1，2，3.
9个操作分别操控着一些钟表，被操作的钟表每次顺时针旋转90°
求出最小操作集
1 ABDE
2 ABC
3 BCEF
4 ADG
5 BDEFH
6 CFI
7 DEGH
8 GHI
9 EFHI


每个表有4状态，一共9个表。我们可以用9维数组存储所有可能的状态。
用结构体数组的方式方便了回溯时对这几个操作的辨认。
这种算法优点：运用数组偏移量进行遍历，速度较快；不用动态生成结点，减少空间与时间的消耗。（普通节点算法，vijos平台每组数据1000ms左右，而这种九维数组的方法每组数据平均200ms左右）

稍微有点欠缺的地方是算法一半的空间用来记录回溯的路径。。。

#include"stdio.h"
#include"queue"
#include"stack"
#include"memory.h"
using namespace std;
struct node
{
	short data;
	node *link;
};
node set[4][4][4][4][4][4][4][4][4];//1~9个表，每个表都有4钟状态,所以用9维数组表示全部状态 ，link作为回溯时的线索。
int tag[10] = { 262144,65536,16384,4096,1024,256,64,16,4,1 };//1~9各个维度的容量
int move1[9][9] = { //操作1~9
	1,1,0,1,1,0,0,0,0,
	1,1,1,0,0,0,0,0,0,
	0,1,1,0,1,1,0,0,0,
	1,0,0,1,0,0,1,0,0,
	0,1,0,1,1,1,0,1,0,
	0,0,1,0,0,1,0,0,1,
	0,0,0,1,1,0,1,1,0,
	0,0,0,0,0,0,1,1,1,
	0,0,0,0,1,1,0,1,1,
};
int cinf();
node* move(node *p, int i);
int main()
{
	//freopen("in.in", "r", stdin);
	int i;
	node *p, *q;
	queue < node* > que; //BFS队列
	p = q = &set[cinf()][cinf()][cinf()][cinf()][cinf()][cinf()][cinf()][cinf()][cinf()];
	p->data = 1;
	set[0][0][0][0][0][0][0][0][0].data = -1;
	que.push(p); //入队列
	while (1)
	{
		p = que.front(); //出队列
		que.pop();
		if (p->data == -1)
			break;
		for (i = 1; i<10; i++)
		{
			q = move(p, i);
			if (q->data == 0) //剪枝，第一次遍历此状态入队列，第2次跳过。
			{
				q->link = p; //指针指向其前驱
				que.push(q);
				q->data = 1;
			}
			else if (q->data == -1) //遍历到目标跳出循环
			{
				q->link = p;
				break;
			}
		}
		if (q->data == -1) //遍历到目标跳出循环
		{
			break;
		}
	}
	stack < int > stk; //定义一个栈，因为回溯是逆序，栈来存储方便输出
	while (q->link) //反向回溯
	{
		p = q->link;
		for (int j = 1; j < 10; j++)
			if (move(p, j) == q)
			{
				stk.push(j); //寻找到前驱，入栈
			}
		q = q->link;
	}
	while (!stk.empty()) //打印栈内元素
	{
		printf("%d ", stk.top());
		stk.pop();
	}
	printf("\n");
	//fclose(stdin);
	return 0;
}
node* move(node *p, int i) //基地址p,操作i,返回对应操作后的地址，通过指针偏移量的方式比较高效
{
	node *begin = &set[0][0][0][0][0][0][0][0][0];
	node *end = &set[3][3][3][3][3][3][3][3][3];
	for (int j = 1; j<10; j++)
	{
		if (move1[i - 1][j - 1] == 1)
		{
			if (p + tag[j]>end)
			{
				p -= 3 * tag[j];
			}
			else
			{
				if ((p - begin) / tag[j] == 0)
				{
					begin += tag[j];
				}
				if ((p - begin) / tag[j] == 1)
				{
					begin += 2 * tag[j];
				}
				if ((p - begin) / tag[j] == 2)
				{
					begin += 3 * tag[j];
				}
				p += tag[j];
			}
			end = begin + tag[j] - 1;
		}
		else
		{
			if ((p - begin) / tag[j] == 1)
			{
				begin += tag[j];
			}
			if ((p - begin) / tag[j] == 2)
			{
				begin += 2 * tag[j];
			}
			if ((p - begin) / tag[j] == 3)
			{
				begin += 3 * tag[j];
			}
			end = begin + tag[j] - 1;
		}
	}
	return p;
}
int cinf()
{
	int temp;
	scanf("%d", &temp);
	return temp;
}