八数码(未优化版本,跑的时间很长很长)

#include <iostream>
#include <cmath>
#include <stack>
using namespace std;
/*
*八数码,未优化版
*总结
*如果用vector来保存的话,路径回溯有问题
*用map实现链表的随机访问或者直接在map上做
*用hash计算后在数组上做.
*都可以以logn的时间减小.这个只是自己玩玩.所以没弄那么多.
*以前看书的时候,说给链表加个头结点会很方便操作,一直没放在心上,我觉得自己也能写的很好.
*结果悲剧了...没有了头结点后的升序插入,相当麻烦.还是要尊重课本啊,都是牛人的总结
*/

struct Board{
	int tile[3][3];
	int r,c;
	
	friend bool operator==(const Board &b1, const Board &b2)
	{
		for(int r = 0; r < 3; r++)
			for(int c = 0; c < 3; c++)
				if(b1.tile[r][c] != b2.tile[r][c])
					return false;
				return true;
	}
	void Print()
	{
		cout<<"0在: "<<r + 1 << "   "<<c + 1<<"位置"<<endl;
		for(int r = 0; r < 3; r++)
		{
			for(int c = 0; c < 3; c++)
				cout<<tile[r][c]<<"\t";
			cout<<endl;
		}
	}
};

//0放在22的位置
const int finalPos[9][2] = {{2, 2}, {0, 0}, {0, 1}, {0,2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}};
const Board finalboard = {{1, 2, 3, 4, 5, 6, 7, 8, 0}, 2, 2}; 
//逆时针,右上左下
const int dir[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
Board initboard;//初始布局

//搜索结点
struct Node
{
	Node(){Dir = 100;}
	Node(const Board &board);
	void Print();
	
	Board board;
	int f,g,h;//启发搜索信息
	int Dir;//父亲节点移动的方向,产生该结点
	Node *next;
	Node *father;//父节点
};

Node::Node(const Board &board)
{
	this->board = board;
	Dir = 100;
	f = g = h = 0;
	next = father = NULL;
}

void Node::Print()
{
	cout<<"将0";
	switch(Dir)
	{
	case 0:
		cout<<"向右";
		break;
	case 1:
		cout<<"向上";
		break;
	case 2:
		cout<<"向左";
		break;
	case 3:
		cout<<"向下";
		break;
	}
	cout<<"移动后"<<endl;
	board.Print();
}

//模拟优先队列的链表
class List{
private:
	Node *head;
	int len;	
public:
	List()
	{
		head = new Node(finalboard);
		head->next = NULL;
		len = 0;
	}
	~List()
	{
		Node *p;
		while(head)//非空
		{
			p = head->next;
			free(head);
			head = p;
		}
		len = 0;
	}
	//如果找到布局一样的结点,放回他前一个结点的指针
	bool Find(const Board &board, Node* &pPrev);
	/*模拟的是优先队列,所以push也是按照<插入,并且只能在队列里面不存在s的时候才能插入
	我考虑的这个状态里面是包含f,g,h的,所以虽然布局一样(h一样),但是他们的状态是不一样的.
	两个布局一样的状态,是不同深度的两个结点,深度大的那个结点g大,于是那个结点的f也大
	插入的时候,在这里要考虑两种种情况,(1)如果那个节点还不存在在open表中,那么直接按照f插入.
	(2)如果是已经在open里面的,因为布局是一样的,所以h是一样的,那么如果f小的话,g也是小的.
	所以还是按照f来判断.
	第二种情况,不需要插入,通过Find函数找到位置来修改(g,f都变小)就可以,
	然后再重新排序,排序的时候因为整个链表已经是有序的,所以只要往前找到适当的位置就好
	这个Push是用来插入的*/
	Node* Push(const Node &n);//返回插入位置
	//重新排序这个操作只在open表中进行,prev指向要重新安排位置的结点的前一个结点
	void Refresh(Node* prev);
	//判断队列是否为空
	bool IsEmpty(){return !head->next;}
	Node Top();
	void Pop();
	//插入到链表的开头,不排序
	void Push_Head(const Node &n);
	Node* Get_FirstPointer();
};

Node List::Top()
	{
		if(!IsEmpty())
		{
			return *(head->next);
		}
	}
void List::Pop()
	{
		if(!IsEmpty())
		{
			Node *p = head->next->next;
			delete head->next;
			head->next = p;
			len--;
		}
	}

//如果找到,返回前一个结点的指针
bool List::Find(const Board &board, Node* &pPrev)
{
	Node *p = head;
	while(p->next)
	{
		//找到,只要布局一样就可以
		if(p->next->board == board)
		{
			pPrev = p;
			return true;
		}
		p = p->next;
	}
	return false;
}

Node* List::Push(const Node &n)//返回插入位置
{
	Node *p, *q, *r;
	r = new Node(n);
	r->next = NULL;//构造函数会拷贝next指针,先赋值为NULL
	if(!head->next)//空链表
	{
		head->next = r;
	}
	else
	{
		p = head; q = p->next;
		while(q->next && q->f < n.f)//查找插入位置
		{
			p = q;
			q = q->next;
		}
		//这样写的优点是只有一个元素的时候这个判断也成立
		if(q->f >= n.f)//pq之间
		{
			p->next = r;
			r->next = q;
		}
		else
		{
			q->next = r;
		}
	}
	len++;
	return r;
}

void List::Refresh(Node* prev)
{
	//先取出,再插入
	Node *inserter = prev->next;
	prev->next = inserter->next;
	Push(*inserter);
}

void List::Push_Head(const Node &n)
{
	Node *p = new Node(n);
	p->next = head->next;
	head->next = p;
}

Node* List::Get_FirstPointer()
{
	return head->next;
}
/*
八数码问题的一个状态实际上是0~9的一个排列,
排列有奇排列和偶排列两类，从奇排列不能转化成偶排列或相反。
如果一个数字0~8的随机排列871526340，用F(X)表示数字X前面比它小的数的个数，全部数字的F(X)之和为Y=∑(F(X))，
如果Y为奇数则称原数字的排列是奇排列，如果Y为偶数则称原数字的排列是偶排列。
目标状态是f(123456780) = 28
*/
bool Solveable()
{
	int i, j, array[9], k = 0, sum = 0;
	for(i = 0; i < 3; i++)
		for(j = 0; j < 3; j++)
			array[k++] = initboard.tile[i][j];
	for(i = 8; i >= 0; i--)
		for(j = i - 1; j >= 0; j--)
			if(array[j] < array[i])
				sum++;
	if(sum % 2)
		return true;
	else
		return false;
}

//启发函数h不计算0的曼哈顿距离
int hFun(Board &board)
{
	int r, c, tile, sum = 0;
	for(r = 0; r < 3; r++)
		for(c = 0; c < 3; c++)
		{
			tile = board.tile[r][c];
			if(tile != 0)
				sum += abs(r - finalPos[tile][0]) + abs(c - finalPos[tile][1]);
		}
		return sum;
}

List open_table, closed_table, save_table;
Node finalNode;


bool Astar()
{
	Node node, nnode, *pn;
	node = initboard;
	node.h = hFun(node.board); node.f = node.g + node.h;
	open_table.Push(node);
	while(!open_table.IsEmpty())
	{
		node = open_table.Top();
		open_table.Pop();
		save_table.Push_Head(node);//保存被访问过的结点,打印路径用
		if(finalboard == node.board)//到达目标布局
		{
			finalNode = node;
			return true;
		}
		int r, c, nr, nc;
		for(int d = 0; d < 4; d++)
		{	
			if(abs(d - node.Dir) == 2)//会回到父亲结点的棋盘布局
				continue;
			r = node.board.r; c = node.board.c;
			nr = r + dir[d][0]; nc = c + dir[d][1];
			if(nr < 0 || nr > 3 || nc < 0 || nc > 3)
				continue;
			
			nnode = node;
			nnode.Dir = d;//该状态下的移动方向
			int temp = node.board.tile[nr][nc];//移动
			nnode.board.tile[r][c] = temp;
			nnode.board.tile[nr][nc] = 0;
			nnode.board.r = nr; nnode.board.c = nc;
			nnode.g++;//深度+1
			nnode.h = hFun(nnode.board);//计算新的h
			nnode.f = nnode.g + nnode.h;
			
			if(open_table.Find(nnode.board, pn))
			{
				if(nnode.f < pn->next->f)//新结点的估价值小于OPEN表中的估价值
				{
					pn->next->father = save_table.Get_FirstPointer();//重新设置父节点
					pn->next->g = nnode.g; pn->next->f = nnode.f;//不需要更新h,更新g,f就好
					open_table.Refresh(pn);
				}
			}
			else if(closed_table.Find(nnode.board, pn))
			{
				if(nnode.f < pn->f)//X的估价值小于CLOSE表的估价值
				{
					nnode.father = pn->next->father = save_table.Get_FirstPointer();
					pn->next->g = nnode.g; pn->next->f = nnode.f;//更新CLOSE表中的估价值;因为下次可能还会遇到同样布局
					open_table.Push(nnode);
				}
			}
			else
			{
				nnode.father = save_table.Get_FirstPointer();
				open_table.Push(nnode);
			}
			closed_table.Push(node);
		}
	}
	return false;
}

void Trace()
{
	stack<Node*> s;
	Node *p = &finalNode;
	int i = 0;
	while(p)
	{
		i++;
		s.push(p);
		p = p->father;
	}
	cout<<"共"<<i<<"步移动."<<endl;
	i = 0;
	while(!s.empty())
	{
		i++;
		p = s.top();
		s.pop();
		cout<<"第"<<i<<"步移动方案: "<<endl;
		p->Print();
		cout<<endl;
	}
}

void Init()
{
	int tile;
	for(int r = 0; r < 3; r++)
		for(int c = 0; c < 3; c++)
		{
			cin>>tile;
			if(!tile)
			{
				initboard.r = r;
				initboard.c = c;
			}
			initboard.tile[r][c] = tile;
		}
}

int main()
{
	freopen("in.txt", "r", stdin);
	
	Init();
	if(Solveable())
	{
		if(Astar())
		{
			cout<<"ok"<<endl;
			Trace();
		}
	}
	else
		cout<<"unresolveable"<<endl;
	return 0;
}

/*
数据输入格式:
1	4	6
0	2	3
7	5	8
这个要跑很久...得要去优化优化.
*/