devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

八数码问题-c语言_八数码问题代码

作者：煮酒与君饮 | 2024-07-04 11:59:44

赞

踩

八数码问题代码

八数码问题

每个局面是三行三列的数字方阵，每个位置为0-8的一个数码且互不相同，求从初始局面（自己设定）如何“最快”移动到终止局面（自己设定）。

移动规则：每次只能0与其上下左右四个方向相邻的某个数字交换！可能有解，可能无解。

如下例子：

  1. 起始矩阵                  目标矩阵
  2. 0	1	2		?		1	2	3
  3. 3	4	5		=》		4	5	6
  4. 6	7	8				7	8	0
  5.

如上所示例子，从起始矩阵 到 目标矩阵，如果可达的话，其中的路径有很多条；当然也有不可达的情况。要求的程序就是要识别这两种情况，可达就求出最短路径；不可达就给出提示。

程序当中使用的结构体：

  1. typedef struct QDatatype
  2. {
  3. 	int* arr; // 存储状态矩阵
  4. 	struct QueueNode* father; // 该结点的上一个路径的结点下标
  5. 	int deap; // 当前结点所在路径的深度
  6. }QDatatype;
  7.  
  8. // 队列的链式结构实现
  9. typedef struct QueueNode
  10. {
  11. 	struct QueueNode* next;
  12. 	QDatatype data;
  13. }QueueNode;
  14.  
  15. typedef struct Queue
  16. {
  17. 	QueueNode* head;
  18. 	QueueNode* head_tail;
  19. 	QueueNode* tail;
  20. 	int size;
  21. }Queue;

如上:Queue为队列的指针域，QueueNode为队列当中每一个结点当中存储的指针和数据域，QDatatype为队列当中每一个结点的数据域。

 判断两个矩阵是否可达

 

首先我们可以确定的是，给定的 起始状态 和 目标状态是用 3 x 3 矩阵来进行存储的。那么我们可以先来了解一个概念：

一个矩阵的逆置值，通常也称为矩阵的行列式（determinant），是一个与矩阵中元素顺序相关的标量值。当我们交换矩阵中的两个元素时，会导致矩阵中元素的顺序发生改变，这可能会导致矩阵的逆置值发生变化。

更具体地说，让我们考虑一个2x2的矩阵，设其元素为a、b、c和d，其逆置值为det。根据矩阵行列式的定义，det的值为ad-bc。

当我们交换矩阵中第一行和第二行的元素时，得到的新矩阵为：

c d

a b

它的行列式为：cb-da。 显然，此时行列式的值与原矩阵的行列式ad-bc不同。

因此，交换矩阵中任意两个元素的位置，都可能会导致矩阵的逆置值发生变化。这也是为什么在计算行列式时，需要根据矩阵中元素的位置来计算逆置值。

那么对于矩阵当中的元素进行交换的时候，这个矩阵的逆置值可能会发生改变，由上所述：
为了确定这两个矩阵的可达性，可以使用起始矩阵的奇偶性以及目标矩阵的奇偶性来进行判断。这是因为八数码问题中，每一次合法操作都会改变矩阵奇偶性的值，因此，起始矩阵和目标矩阵的奇偶性不同，则它们之间不存在可达路径。

因为合法操作通常包括将空格上、下、左、右四个方向之一的数字移动到空格的位置上，这会导致逆序对的数量发生变化。如果原序列中的逆序对数量为奇数，那么根据定义，操作后的逆序对数量一定为偶数；如果原序列中的逆序对数量为偶数，那么操作后的逆序对数量一定为奇数。因此，每一次合法操作都会改变矩阵的奇偶性。

而使用逆序对来计算一个矩阵的逆置值（行列式），这是一种标准的计算方法。

所以，我们可以 起始矩阵和 目标矩阵 所对应的 逆序对数（逆置值）的奇偶性是否相同，相同表示 两个矩阵可达；如果奇偶性不相等那就说明，两个矩阵之间不相等。

接下来，问题就好解决了，只用求解一个矩阵当中有多少对逆序对就行了，关于逆序对的定义就是在一个序列中，如果存在两个元素a[i]和a[j]，其中i<j且a[i]>a[j]，那么我们称这两个元素构成一个逆序对。

对于一个矩阵，我们可以将其按行或者按列展开成一个一维数组（序列），然后计算这个一维数组中的逆序对数量。

求矩阵逆置的流程图：

 

求两个矩阵逆置值的奇偶性是否相等的流程图：
 

 完整代码：

  1. bool matrix_is_arrive(int* arr1, int* arr2, int row, int wide)
  2. {
  3. 	int InverseNum1 = 0;
  4. 	for (int i = 0; i < row * wide - 1; i++)
  5. 	{
  6. 	
  7. 		if (arr1[i] == 0)
  8. 			continue;
  9.  
  10. 		for (int j = i + 1; j < row * wide; j++)
  11. 		{
  12. 		
  13. 			if (arr1[j] == 0)
  14. 				continue;
  15.  
  16. 			if (arr1[i] > arr1[j])
  17. 				InverseNum1++;
  18. 		}
  19. 	}
  20.  
  21. 	int InverseNum2 = 0;
  22. 	for (int i = 0; i < row * wide - 1; i++)
  23. 	{
  24. 	
  25. 		if (arr2[i] == 0)
  26. 			continue;
  27.  
  28. 		for (int j = i + 1; j < row * wide; j++)
  29. 		{
  30. 		
  31. 			if (arr2[j] == 0)
  32. 				continue;
  33.  
  34. 			if (arr2[i] > arr2[j])
  35. 				InverseNum2++;
  36. 		}
  37. 	}
  38.  
  39.  
  40. 	if ((InverseNum2 + InverseNum1) % 2 == 0)
  41. 		return true;
  42. 	else
  43. 		return false;
  44. }

解决重复值问题

 对于数阵问题，根本上就是深度和广度的搜索，虽然以深度和广度都可以搜索出来，但是深度的广度的效率低下，因为在依次找最短路径的过程当中就会找到很多的重复的或者是不需要的“没用的”的结点，那么这个结点的个数是远超出我们想象的。可能最短路径为20步的路径，假设使用广度的话需要多遍历好几十倍甚至更多的结点，而且这只是保守估计。

广度优先搜索算法当中使用的是队列来实现，那么对于广度优先搜索算法，简单来说就是把搜索过的结点入队，那么我们可以在队列当中来进行全局遍历，也就是从一个父亲结点找出一个孩子结点（从一个结点找出这个结点在 3 x 3 的地图上可以走的位置）之后，那么就查看这个走之后的生成的状态矩阵是否在 队列当中 存在，如果存在，说明当前搜索出的结点，是之前已经搜索过的重复结点，那么就直接跳过这个结点不把这个结点入队。如果当前搜索出的结点没有在 队列 当中出现过的话，说明这个结点没有被搜索过，可以入队。以上就解决了 在搜索过程当中 搜索出重复值之后 如果进行判断，判断当前搜索出的结点是否是 已经搜索过的重复值。

因为程序当中使用的是链式队列，所以遍历这个队列只需要依次访问当前结点的 next 指针即可，就像单链表的遍历一样。

流程图：

 

  1. bool is_same(QueueNode* Node1, int* arr)
  2. {
  3. 	for (int j = 0; j < 9; j++)
  4. 	{
  5. 		if (Node1->data.arr[j] != arr[j])
  6. 		{
  7. 			return false;
  8. 		}
  9. 	}
  10.  
  11. 	return true;
  12. }
  13.  
  14. // A* 当中判断是否搜索过的函数
  15.  
  16. bool is_in_close(Queue* open, int* arr)
  17. {
  18. 	QueueNode* tmp = open->head;
  19. 	while (tmp != open->head_tail)
  20. 	{
  21. 		if (is_same(tmp, arr))
  22. 		{
  23. 			return true;
  24. 		}
  25. 		tmp = tmp->next;
  26. 	}
  27.  
  28. 	return false;
  29. }
  30.  
  31.  
  32. QueueNode* is_in_open(Queue* open, int* arr)
  33. {
  34. 	QueueNode* tmp = open->head_tail;
  35. 	while (tmp)
  36. 	{
  37. 		if (is_same(tmp, arr))
  38. 		{
  39. 			return tmp;
  40. 		}
  41. 		tmp = tmp->next;
  42. 	}
  43.  
  44. 	return NULL;
  45. }
  46.  
  47. // 广度当中使用的判断是否搜索过的函数
  48.  
  49. // 判断在 close 队列当中是否有状态和当前状态是否相同
  50. bool is_in_st(Queue* close, int* arr)
  51. {
  52. 	QueueNode* tmp = close->head;
  53. 	while(tmp)
  54. 	{
  55. 		if (is_same(tmp , arr))
  56. 		{
  57. 			return true;
  58. 		}
  59. 		tmp = tmp->next; 
  60. 	}

 上述的open 和 close 是可以看做是两个队列，对于这两个队列，会在下述详细描述 广度优先搜索和 A* 基于广度优先搜索的启发式算法当中进行详细说明。

  1. 和路径输出问题

程序当中的广度优先搜索是从一个父亲结点来找出这个父亲结点的满足条件的，可以走的结点，那么从父亲结点到孩子结点就是一条路径。因为广度优先搜索是一层一层往下搜索路径的，所以，只要广度优先搜索找到了目标，那么这目标对应的路径就是最短路径。这是广度优先搜索的好处。所以，我们只需要在每一次从某一个父亲结点搜索其孩子结点的时候，如果这个孩子入队了，说明这个路径是可以走的，那么就把这个孩子结点当中 指向父亲结点的 father 指针指向 当前的父亲结点就可以完成路径的链接了。

在上述当中判断当前结点在队列当中是否有搜索过这个问题当中给出了队列的结构体的实现，其中的数据就有一个 father 指针，这个指针就是用于存储这个 结点 父亲结点，那么到最后，依次链接。最后，只需要在 队列当中找到 目标结点，这个结点一定只有一个，然后根据这个结点的 father 指针就可以找到最短路径了。

  1. 广度优先搜索算法

上述也说了一些广度优先的实现，主要思想就是利用队列“先进先出”的特性，首先，把起始结点入队，从这个起始结点开始找这个结点的孩子结点。把这个父亲结点的所有可以走的路径走过之后，因为出队。然后下一次就从队头取结点，从这个结点再去找出这个结点可以走的子节点，找完之后再把这个父亲结点出队，这是广度查找的基本思想。

当这个结点所有可以走的孩子结点都入队之后，说明这个父亲结点的所有可以走的路径都已经搜索完了，那么按照一般的广度优先搜索算法来说，应该把这个父亲结点出队，因为这个结点已经搜索过了，但是，因为在八数码当中有，有非常多的重复结点的情况，这个父亲结点就算已经被搜索过了，应该出队，但是出队之后，如果在之后搜索当中，搜索出了和这个父亲结点的状态矩阵相同的状态矩阵，这是不允许的。

因为就算是这个父亲结点在八数码问题当中，是属于在搜索过程当中查找过的结点，这个结点搜索出的矩阵，之后再搜索过程当中就不能再出现了。

所以，以上的矛盾，解决办法就是在创建一个队列close，这个队列用于存储从原本队列（open）当中出队的结点，这样我们就不会丢失从open队列当中出队的状态矩阵了。

但是如果向上实现的话，就会有一个问题：我们之前说过的，我们从搜索过的路径当中找到最短路径，是从最后开始，通过最短路径当中的每一个结点的 father 指针来依次往前来寻找，打印出路径，那么我们在出队的时候一般是会释放掉这个结点对应的空间的，然后，当我们在close 当中入队的时候，只是和新的结点当中存储的是一起从open 当中出队的结点当中的数据，所以当我们释放掉这个结点空间，也就意味着，这个结点的孩子结点的father原本存储的是这个结点的地址，但是这个结点空间已经释放了，也就是说此时孩子结点的 father 指针存储空间地址已经失效了，所以综上所述，就会出现链接问题。

当然处理办法有很多，首先最暴力的就是不释放open原本要出队的结点空间，因为本程序的使用的队列是链式队列，可以直接修改链接关系，达到在不释放当前结点的空间的前提下，从open队列当中出队，从close 队列当中入队。

本程序实现的把open队列和close队列合并为一个队列，使用三个指针分别是 指向close队列队头的 head指针，指向open队列队头的指针 head_tail 指针和 执行open队列队尾的tail 指针来进行维护。具体关系如下所示：

使用如上所示的好处就是，我不需要改链接关系，每一次进行上述的出队入队的操作，只需要把 head_tail 指针往后移动就可以实现，

本程序实现的广度优先主要分为两大块，首先是外层的大循环，外层循环当中实现的是：每一次从某一个父亲结点搜索完所有的孩子结点之后，判断搜索出的并且入队的状态矩阵当中有没有出现目标结点的情况，如果出现了，就跳出循环；如果没有出现，就会执行第二块：把当前队头结点作为父亲结点，寻找这个父亲结点所以可以走的 孩子结点，入队，然后把父亲结点从open当中出队，入队到close当中，和上述差不多。

在第二块当中会以 上下左右 四个方向依次寻找，先判断移动的坐标是否合法，然后判断在close队列和open队列当中是否出现，没出现就入队，修改father指针链接关系，出现就跳过这个孩子结点的搜索，进行下一个孩子搜索，当搜索完之后，head_tail 指针往后移动，实现出队和入队操作。

当然在，在执行广度优先搜索之前，要先判断这个例子是否可达，不可达直接结束，可达在进行求解。

 广度优先搜索板块的代码(其中某些函数将会在完整代码当中给出)：

  1. // 广度优先算法 函数
  2. void BFS(QueueNode* node , Queue* open)
  3. {
  4.  
  5. 	int blake = 0;
  6. 		// 找到空格的下标
  7. 		for (int i = 0; i < 9; i++)
  8. 		{
  9. 			if (node->data.arr[i] == 0)
  10. 			{
  11. 				blake = i;
  12. 				break;
  13. 			}
  14. 		}
  15. 		int dx = INT_MAX;
  16. 		// 向上走
  17. 		dx = blake - 3;
  18. 		if (dx >= 0)
  19. 		{
  20. 			for (int i = 0; i < 9; i++)
  21. 			{
  22. 				tmpArr[i] = node->data.arr[i];
  23. 			}
  24. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  25. 	
  26. 			// 判断交换之后的 矩阵是否重复
  27. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  28. 			// 如果没有就把这个状态矩阵入队
  29. 			if (!is_in_st(open, tmpArr))
  30. 			{
  31. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  32. 				QueuePush(open, tmp);
  33.  
  34. 				open->tail->data.father = node;
  35. 			}
  36. 		}
  37. 	
  38. 		//向下走
  39. 		dx = blake + 3;
  40. 		if (dx < 9)
  41. 		{
  42. 			for (int i = 0; i < 9; i++)
  43. 			{
  44. 				tmpArr[i] = node->data.arr[i];
  45. 			}
  46. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  47.  
  48. 			// 判断交换之后的 矩阵是否重复
  49. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  50. 			// 如果没有就把这个状态矩阵入队
  51. 			if (!is_in_st(open, tmpArr))
  52. 			{
  53. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  54. 				QueuePush(open, tmp);
  55.  
  56. 				open->tail->data.father = node;
  57. 			}
  58. 		}
  59.  
  60. 	
  61. 		//向左走
  62. 		dx = blake - 1;
  63. 		if (dx >= (3 * (blake / 3)))
  64. 		{
  65. 			for (int i = 0; i < 9; i++)
  66. 			{
  67. 				tmpArr[i] = node->data.arr[i];
  68. 			}
  69. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  70.  
  71. 			// 判断交换之后的 矩阵是否重复
  72. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  73. 			// 如果没有就把这个状态矩阵入队
  74. 			if (!is_in_st(open, tmpArr))
  75. 			{
  76. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  77. 				QueuePush(open, tmp);
  78.  
  79. 				open->tail->data.father = node;
  80. 			}
  81. 		}
  82. 	
  83. 		//向右走
  84. 		dx = blake + 1;
  85. 		if (dx < (3 * (blake / 3 + 1)))
  86. 		{
  87. 			for (int i = 0; i < 9; i++)
  88. 			{
  89. 				tmpArr[i] = node->data.arr[i];
  90. 			}
  91. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  92.  
  93. 			// 判断交换之后的 矩阵是否重复
  94. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  95. 			// 如果没有就把这个状态矩阵入队
  96. 			if (!is_in_st(open, tmpArr))
  97. 			{
  98. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  99. 				QueuePush(open, tmp);
  100.  
  101. 				open->tail->data.father = node;
  102. 			}
  103. 		}
  104.  
  105. 		// open 表当中存储的路径，把不是路径的结点 出open
  106. 		// 入队到 close 当中，表示这个结点已经被搜索过了
  107.  
  108. 		open->head_tail = open->head_tail->next;
  109.  
  110. }
  111.  
  112. int main()
  113. {
  114. 		int numStart[] = {1,0,2,6,7,5,4,8,3};
  115.  
  116. 		int numEnd[] = { 1,2,3,4,5,0,6,7,8};
  117.  
  118. 	//	int numStart[] = { 2, 8, 3,
  119. 	//		1, 6, 4,
  120. 	//		7, 0, 5 };
  121. 	//int numEnd[] = { 1, 2, 3,
  122. 	//	7, 8, 4,
  123. 	//	0, 6, 5 };
  124.  
  125. 	Queue open;
  126. 	QueueInit(&open);
  127.  
  128. 	// 判断起始矩阵 和 最终矩阵是否可达
  129. 	printf("矩阵是否可达（0 / 1）:%d", matrix_is_arrive(numStart, numEnd, 3, 3));
  130.  
  131. 	QDatatype* tmp = creat_Node(numStart, NULL , 0);
  132. 	QueueNode* tmpNode = QueuePush(&open, tmp);
  133.  
  134. 	open.head_tail = open.head;
  135.  
  136. 	//Queue close; 
  137. 	//QueueInit(&close);
  138.  
  139. 	// 首先计算 初始矩阵和 目标矩阵是否可达
  140. 	if (matrix_is_arrive(numStart, numEnd, 3, 3))
  141. 	{
  142. 		// open 队列不为空就继续 在 open 队列当中加入这个 结点能走的子节点
  143. 		while (!QueueEmpty(&open))
  144. 		{
  145. 			if (is_in_st(&open, numEnd))
  146. 				break;
  147. 			// 广度优先遍历算法函数
  148. 			BFS(open.head_tail , &open); // 求解八数码问题
  149. 		}
  150. 	}
  151. 	else
  152. 	{
  153. 		printf("不可达!!!");
  154. 	}
  155.  
  156.  
  157. 	return 0;
  158. }

  1. A*算法实现

 

A* 算法和之前的广度优先算法本质上没有多大区别，只是在每一次BFS 函数选取结点的时候，并不是盲目的从open的头结点来取，而且选取open队列当中全部结点当中，选出一个权值最小的结点，来作为BFS 搜索的父亲结点，这样就大大减少了BFS 函数在搜索过程当中所多搜索出来的重复的，无意义的结点。

而这个权值是什么我们先不谈，我们先谈BFS函数当中如何对这个搜索的父亲结点的各个孩子结点 赋上权值。

在单纯的广度优先搜索当中，只是单纯的在 open表和close表当中寻找是否有重复的状态矩阵存在；而在 A* 当中，不是单纯的判断了，要把open队列和close队列分开判断，首先，如果在close当中出现，那么就直接跳过这个方向的搜索，如果没有在close当中出现过，也没有在open当中出现，那么就直接入队（open和close 的合并队列）；如果close当中没有出现，open当中出现了，那么也就是说，我们可能需要修改open当中这个重复的结点的存储的数据和连接信息，如果当前新搜索的孩子结点的权值计算出来，比open当中重复结点的权值小，说明当前搜索出来的是更好的路径结点，那么就把这个结点替换掉open队列当中的重复结点。

以上就是A*主要过程。

接下来是如何计算权值，上述也说过了，当我们需要把一个孩子结点入队的时候，我需要计算这个孩子结点的权值，这样才能实现后面用权值来选择我要搜索的父亲结点。那么本程序当中的权值有两部分组成：h(n) 表示当前状态矩阵和 起始矩阵的之间路径的深度；g(n) 表示的是当前状态矩阵当中的每一个元素到达目标元素位置所差的横纵标距离之和，也就是把每一个元素的所差的横纵坐标距离之和加起来，作为这个状态矩阵的 g(n) 权值。那么，最终这个状态矩阵的权值表示为 p(n) = h(n) + g(n) 。其中p(n) 就是我所使用的权值，这个权值就是 h(n) 和 g(n) 的和。本程序当中的权值计算使用的是嵌套循环来求权值。

接下来是处理，open 队列 和 close 队列的问题，在A* 当中因为搜索的父亲结点不再是盲目的选取 open 队列的头结点，而且从open 队列当中找权值最小的，那么这也就意味着，我每一次找完一个父亲结点的所以可以走的孩子之后，需要把这个父亲结点从open队列当中取出来，入队到 close 队列当中，但是这个父亲结点不一定是open的队头结点，所以，如果这个父亲结点是open队列的中间结点，那么从open队列当中取出这个元素我需要修改这个父亲结点在 open 当中的链接关系。因为这里使用的链式栈，单项链表不在适用，所以这适用双向链表的形式来实现。

修改之后的结构体如下：

  1. typedef struct QDatatype
  2. {
  3. 	int* arr; // 存储状态矩阵
  4. 	struct QueueNode* father; // 该结点的上一个路径的结点下标
  5. 	int deap; // 当前结点所在路径的深度
  6. }QDatatype;
  7.  
  8. // 队列的链式结构实现
  9.  
  10. typedef struct QueueNode
  11. {
  12. 	int end_distance; // 当前结点的到目标结点的 估计权值
  13. 	struct QueueNode* next; // 下一个结点的指针
  14. 	struct QueueNode* above; // 上一个结点的指针
  15. 	QDatatype data;
  16. }QueueNode;
  17.  
  18. typedef struct Queue
  19. {
  20. 	QueueNode* head;
  21. 	QueueNode* head_tail;
  22. 	QueueNode* tail;
  23. 	int size_open;  // 维护 open 表的元素个数
  24. 	int size_close; // 维护 close 表的元素个数
  25. }Queue;

上述也说过了，队列当中的 head_tail 指针是指向open 队列的第一个结点，那么这个head_tail 指向结点的上一个结点就是 close 队列的最后一个结点，所以我们可以以此来向close当中尾插数据。

A*算法当中和广度一样，分为两大块，首先是外层的大循环，和广度为底层的搜索函数。

 A* 启发函数计算权值代码：
 

  1. int Manhattan_distance( int* Arr, int* numArr)
  2. {
  3. 	int distance = 0;
  4. 	int flag = 0;
  5.  
  6. 	for (int i = 0; i < 3; i++)
  7. 	{
  8. 		for (int j = 0; j < 3; j++)
  9. 		{
  10. 			flag = 0;
  11. 			for (int k = 0; k < 3; k++)
  12. 			{
  13. 				for (int m = 0; m < 3; m++)
  14. 				{
  15. 					if (Arr[i * 3 + j] == numArr[k * 3 + m])
  16. 					{
  17. 						distance += abs(i - k) + abs(j - m);
  18. 						flag = 1;
  19. 						break;
  20. 					}
  21. 				}
  22. 				if (flag == 1)
  23. 					break;
  24. 			}
  25. 		}
  26. 	}
  27. 	return distance;
  28. }

从存储搜索过的矩阵的队列当中取出权值最小的结点（状态矩阵）的代码：

  1. QueueNode* GetMin_distance_Node(QueueNode* pq)
  2. {
  3. 	int distance = INT_MAX;
  4. 	QueueNode* tmp = pq, *returnNode = NULL;
  5. 	while (tmp != NULL)
  6. 	{
  7. 		// 除去已经 搜索过的结果
  8. 		if (tmp->end_distance == INT_MAX)
  9. 			continue;
  10.  
  11. 		if ((tmp->data.deap + tmp->end_distance) < distance)
  12. 		{
  13. 			returnNode = tmp;
  14. 			distance = tmp->data.deap + tmp->end_distance;
  15. 		}
  16.  
  17. 		tmp = tmp->next;
  18. 	}
  19.  
  20. 	return returnNode;
  21. }

程序的输入输出

 

本程序当中主要使用A*算法来实现数阵问题，在A*计算最短路径算法的基础之上，写了一些面向对象的菜单，和输出格式；还有随机生成 起始矩阵和 目标矩阵进行求解和 在文件当中输入一个或者多个例子 ，然后再屏幕上统一输出的两个方式进行和用户的交互。

首先是程序的菜单流程图如下所示（如图9所示）：

框架流程图-图9

菜单在屏幕上的打印如下图所示（如图10所示）：

程序菜单-图10

输入1，随机生成数阵问题的例子，然后求解打印在屏幕上，下述当中给了随机生成的可以走和不可走的例子（如下图11和图12 和图13 所示）：

不可达的例子图-图11

可达的例子图1-图12

可达的例子图2-图13

上述当中的中间路径过多，不在截图展示，只展示开头和结尾。

如上就是随机生成例子，然后求解这个例子，再打印在屏幕上的过程。

文件输入。可以输入一个或者多个例子，每一个矩阵为一行，第一个起始矩阵，第二个是目标矩阵，依此类推。多个例子不需要用什么符号分割，只需要在之前例子之后令其一行按照上述所属的输入即可。具体在文件当中的输入格式如下图所示（如图14所示）：

单个例子输入：

单个例子输入示意图-图14

如上所示，矩阵当中的元素和元素之间用 空格进行分割；矩阵和矩阵之间用 行进行分割

单个例子在屏幕上的输出（如图15和图16一样）：

单个例子输出示意图1-图15

单个例子输出示意图2-图16

同样，上述只给出了开头和结尾的示意图。

多个例子的输入（如图17所示）：

多个例子的输入格式如上所示-图17

输出和单个例子如出一致，只是不同的例子的路径用下图所示的方式进行分割（如图18所示）：

多个例子输出部分示意图-图18

 程序完整代码

 广度优先搜索代码

 

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include<stdio.h>
  4. #include<stdbool.h>
  5. #include<stdlib.h>
  6. #include<string.h>
  7. #include<assert.h>
  8.  
  9. typedef struct QDatatype
  10. {
  11. 	int* arr; // 存储状态矩阵
  12. 	struct QueueNode* father; // 该结点的上一个路径的结点下标
  13. 	int deap; // 当前结点所在路径的深度
  14. }QDatatype;
  15.  
  16. // 队列的链式结构实现
  17.  
  18. typedef struct QueueNode
  19. {
  20. 	struct QueueNode* next;
  21. 	QDatatype data;
  22. }QueueNode;
  23.  
  24. typedef struct Queue
  25. {
  26. 	QueueNode* head;
  27. 	QueueNode* head_tail;
  28. 	QueueNode* tail;
  29. 	int size;
  30. }Queue;
  31.  
  32. // 队列的初始化
  33. void QueueInit(Queue* pq);
  34. // 队列的销毁
  35. void QueueDestroy(Queue* pq);
  36. // 队列的插入
  37. QueueNode* QueuePush(Queue* pq, QDatatype* x);
  38. // 队列删除缘元素
  39. void QueuePop(Queue* pq);
  40. // 判断队列是否为空
  41. bool QueueEmpty(Queue* pq);
  42. // 拿到队头的数据
  43. QDatatype QueueFront(Queue* pq);
  44.  
  45. // 队列的初始化
  46. void QueueInit(Queue* pq)
  47. {
  48. 	assert(pq);
  49.  
  50. 	pq->head = pq->tail = NULL;
  51. 	pq->size = 0;
  52. }
  53.  
  54. // 队列的销毁
  55. void QueueDestroy(Queue* pq)
  56. {
  57. 	assert(pq);
  58.  
  59. 	QueueNode* cur = pq->head;
  60. 	while (cur)
  61. 	{
  62. 		QueueNode* next = cur->next;
  63. 		free(cur);
  64. 		cur->next;
  65. 	}
  66.  
  67. 	pq->head = pq->tail = NULL;
  68. 	pq->size = 0;
  69. }
  70.  
  71.  
  72. // 队列的插入
  73. QueueNode* QueuePush(Queue* pq, QDatatype* x)
  74. {
  75. 	assert(pq);
  76.  
  77. 	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
  78. 	newNode->data.arr = (int*)malloc(sizeof(int) * 9);
  79. 	if (newNode == NULL)
  80. 	{
  81. 		perror("malloc fail");
  82. 		return NULL;
  83. 	}
  84.  
  85. 	newNode->next = NULL;
  86. 	for (int i = 0; i < 9; i++)
  87. 	{
  88. 		newNode->data.arr[i] = x->arr[i];
  89. 	}
  90. 	newNode->data.deap = x->deap;
  91. 	newNode->data.father = x->father;
  92.  
  93.  
  94. 	if (pq->head == NULL)
  95. 	{
  96. 		assert(pq->tail == NULL);
  97.  
  98. 		pq->head = pq->tail = newNode;
  99. 	}
  100. 	else
  101. 	{
  102. 		pq->tail->next = newNode;
  103. 		pq->tail = newNode;
  104. 	}
  105.  
  106. 	pq->size++;
  107. 	return newNode;
  108. }
  109.  
  110. // 队列删除缘元素
  111. void QueuePop(Queue* pq)
  112. {
  113. 	assert(pq);
  114. 	assert(pq->head);
  115.  
  116. 	if (pq->head->next == NULL)
  117. 	{
  118. 		free(pq->head);
  119. 		pq->head = pq->tail = NULL;
  120. 	}
  121. 	else
  122. 	{
  123. 		QueueNode* next = pq->head->next;
  124. 		free(pq->head);
  125. 		pq->head = next;
  126. 	}
  127. 	pq->size--;
  128. }
  129.  
  130. // 判断队列是否为空
  131. bool QueueEmpty(Queue* pq)
  132. {
  133. 	assert(pq);
  134.  
  135. 	return pq->size == 0;
  136. }
  137.  
  138. // 拿到队头的数据
  139. QDatatype QueueFront(Queue* pq)
  140. {
  141. 	assert(pq);
  142.  
  143. 	return pq->head->data;
  144. }
  145.  
  146.  
  147.  
  148. // 判断两个状态是否相同
  149. bool is_same(QueueNode* Node1, int* arr)
  150. {
  151. 		for (int j = 0; j < 9; j++)
  152. 		{
  153. 			if (Node1->data.arr[j] != arr[j])
  154. 			{
  155. 				return false;
  156. 			}
  157. 		}
  158.  
  159. 		return true;
  160. }
  161.  
  162. bool is_same1(int* arr2, int* arr)
  163. {
  164. 	for (int j = 0; j < 9; j++)
  165. 	{
  166. 		if (arr2[j] != arr[j])
  167. 		{
  168. 			return false;
  169. 		}
  170. 	}
  171.  
  172. 	return true;
  173. }
  174.  
  175. // 判断在 close 队列当中是否有状态和当前状态是否相同
  176. bool is_in_st(Queue* close, int* arr)
  177. {
  178. 	QueueNode* tmp = close->head;
  179. 	while(tmp)
  180. 	{
  181. 		if (is_same(tmp , arr))
  182. 		{
  183. 			return true;
  184. 		}
  185. 		tmp = tmp->next; 
  186. 	}
  187.  
  188. 	return false;
  189. }
  190.  
  191. // 交换两个结点的函数
  192. void Swap(int* x, int* y)
  193. {
  194. 	int tmp = *x;
  195. 	*x = *y;
  196. 	*y = tmp;
  197. }
  198.  
  199. QDatatype* creat_Node(int* a , struct QueueNode* father ,int deap)
  200. {
  201. 	QDatatype* tmp = (QDatatype*)malloc(sizeof(QDatatype));
  202. 	tmp->arr = (int*)malloc(sizeof(int) * 9);
  203. 	for (int i = 0; i < 9; i++)
  204. 	{
  205. 		tmp->arr[i] = a[i];
  206. 	}
  207. 	tmp->father = father;
  208. 	tmp->deap = deap;
  209.  
  210. 	return tmp;
  211. }
  212.  
  213. int tmpArr[9];
  214.  
  215. // 广度优先算法 函数
  216. void BFS(QueueNode* node , Queue* open)
  217. {
  218.  
  219. 	int blake = 0;
  220. 		// 找到空格的下标
  221. 		for (int i = 0; i < 9; i++)
  222. 		{
  223. 			if (node->data.arr[i] == 0)
  224. 			{
  225. 				blake = i;
  226. 				break;
  227. 			}
  228. 		}
  229. 		int dx = INT_MAX;
  230. 		// 向上走
  231. 		dx = blake - 3;
  232. 		if (dx >= 0)
  233. 		{
  234. 			for (int i = 0; i < 9; i++)
  235. 			{
  236. 				tmpArr[i] = node->data.arr[i];
  237. 			}
  238. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  239. 	
  240. 			// 判断交换之后的 矩阵是否重复
  241. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  242. 			// 如果没有就把这个状态矩阵入队
  243. 			if (!is_in_st(open, tmpArr))
  244. 			{
  245. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  246. 				QueuePush(open, tmp);
  247.  
  248. 				open->tail->data.father = node;
  249. 			}
  250. 		}
  251. 	
  252. 		//向下走
  253. 		dx = blake + 3;
  254. 		if (dx < 9)
  255. 		{
  256. 			for (int i = 0; i < 9; i++)
  257. 			{
  258. 				tmpArr[i] = node->data.arr[i];
  259. 			}
  260. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  261.  
  262. 			// 判断交换之后的 矩阵是否重复
  263. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  264. 			// 如果没有就把这个状态矩阵入队
  265. 			if (!is_in_st(open, tmpArr))
  266. 			{
  267. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  268. 				QueuePush(open, tmp);
  269.  
  270. 				open->tail->data.father = node;
  271. 			}
  272. 		}
  273.  
  274. 	
  275. 		//向左走
  276. 		dx = blake - 1;
  277. 		if (dx >= (3 * (blake / 3)))
  278. 		{
  279. 			for (int i = 0; i < 9; i++)
  280. 			{
  281. 				tmpArr[i] = node->data.arr[i];
  282. 			}
  283. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  284.  
  285. 			// 判断交换之后的 矩阵是否重复
  286. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  287. 			// 如果没有就把这个状态矩阵入队
  288. 			if (!is_in_st(open, tmpArr))
  289. 			{
  290. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  291. 				QueuePush(open, tmp);
  292.  
  293. 				open->tail->data.father = node;
  294. 			}
  295. 		}
  296. 	
  297. 		//向右走
  298. 		dx = blake + 1;
  299. 		if (dx < (3 * (blake / 3 + 1)))
  300. 		{
  301. 			for (int i = 0; i < 9; i++)
  302. 			{
  303. 				tmpArr[i] = node->data.arr[i];
  304. 			}
  305. 			Swap(&tmpArr[blake], &tmpArr[dx]);
  306.  
  307. 			// 判断交换之后的 矩阵是否重复
  308. 			// 判断 open 队列 和 close 队列当中是否有当前状态矩阵
  309. 			// 如果没有就把这个状态矩阵入队
  310. 			if (!is_in_st(open, tmpArr))
  311. 			{
  312. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  313. 				QueuePush(open, tmp);
  314.  
  315. 				open->tail->data.father = node;
  316. 			}
  317. 		}
  318.  
  319. 		// open 表当中存储的路径，把不是路径的结点 出open
  320. 		// 入队到 close 当中，表示这个结点已经被搜索过了
  321.  
  322. 		open->head_tail = open->head_tail->next;
  323.  
  324. }
  325.  
  326.  
  327.  
  328.  
  329. // 判断起始矩阵和 最终矩阵是否可达，
  330. // 参数：              起始矩阵  最终矩阵    矩阵长    矩阵宽
  331. bool matrix_is_arrive(int* arr1, int* arr2 , int row , int wide)
  332. {
  333. 	int InverseNum1 = 0;
  334. 	for (int i = 0; i < row * wide - 1; i++)
  335. 	{
  336. 		// 跳过0
  337. 		if (arr1[i] == 0)
  338. 			continue;
  339.  
  340. 		for (int j = i + 1; j < row * wide; j++)
  341. 		{
  342. 			// 跳过0 
  343. 			if (arr1[j] == 0)
  344. 				continue;
  345.  
  346. 			if (arr1[i] > arr1[j])
  347. 				InverseNum1++;
  348. 		}
  349. 	}
  350.  
  351. 	int InverseNum2 = 0;
  352. 	for (int i = 0; i < row * wide - 1; i++)
  353. 	{
  354. 		// 跳过0
  355. 		if (arr2[i] == 0)
  356. 			continue;
  357.  
  358. 		for (int j = i + 1; j < row * wide; j++)
  359. 		{
  360. 			// 跳过0
  361. 			if (arr2[j] == 0)
  362. 				continue;
  363.  
  364. 			if (arr2[i] > arr2[j])
  365. 				InverseNum2++;
  366. 		}
  367. 	}
  368.  
  369. 	// 判断奇偶性是否相同
  370. 	if ((InverseNum2 + InverseNum1) % 2 == 0)
  371. 		return true;
  372. 	else
  373. 		return false;
  374. }
  375.  
  376. QueueNode* EndNode(Queue* Qe, int* numEnd)
  377. {
  378. 	QueueNode* tmp = Qe->head;
  379. 	while (tmp)
  380. 	{
  381. 		if (is_same(tmp, numEnd))
  382. 		{
  383. 			return tmp;
  384. 		}
  385. 		tmp = tmp->next;
  386. 	}
  387.  
  388. 	return NULL;
  389. }
  390.  
  391. // 输出路径
  392. void Print(QueueNode* node)
  393. {
  394. 	QueueNode* tmp = node;
  395. 	int num = 1;
  396. 	while (tmp != NULL)
  397. 	{
  398. 		printf("step: %d\n",num++);
  399. 		for (int i = 0; i < 9; i++)
  400. 		{
  401. 			printf("%d", tmp->data.arr[i]);
  402. 			if ((i + 1) % 3 == 0)
  403. 			{
  404. 				printf("\n");
  405. 			}
  406. 		}
  407. 		//printf("\n");
  408. 		tmp = tmp->data.father;
  409. 	}
  410. }
  411.  
  412.  
  413. int main()
  414. {
  415. 		int numStart[] = {1,0,2,6,7,5,4,8,3};
  416.  
  417. 		int numEnd[] = { 1,2,3,4,5,0,6,7,8};
  418.  
  419. 	//	int numStart[] = { 2, 8, 3,
  420. 	//		1, 6, 4,
  421. 	//		7, 0, 5 };
  422. 	//int numEnd[] = { 1, 2, 3,
  423. 	//	7, 8, 4,
  424. 	//	0, 6, 5 };
  425.  
  426. 	Queue open;
  427. 	QueueInit(&open);
  428.  
  429. 	// 判断起始矩阵 和 最终矩阵是否可达
  430. 	printf("矩阵是否可达（0 / 1）:%d", matrix_is_arrive(numStart, numEnd, 3, 3));
  431.  
  432. 	QDatatype* tmp = creat_Node(numStart, NULL , 0);
  433. 	QueueNode* tmpNode = QueuePush(&open, tmp);
  434.  
  435. 	open.head_tail = open.head;
  436.  
  437. 	//Queue close; 
  438. 	//QueueInit(&close);
  439.  
  440. 	// 首先计算 初始矩阵和 目标矩阵是否可达
  441. 	if (matrix_is_arrive(numStart, numEnd, 3, 3))
  442. 	{
  443. 		// open 队列不为空就继续 在 open 队列当中加入这个 结点能走的子节点
  444. 		while (!QueueEmpty(&open))
  445. 		{
  446. 			if (is_in_st(&open, numEnd))
  447. 				break;
  448. 			// 广度优先遍历算法函数
  449. 			BFS(open.head_tail , &open); // 求解八数码问题
  450. 		}
  451.  
  452. 		// 在open 队列当中找到目标结点的位置
  453. 		QueueNode* EndNumNode = EndNode(&open, numEnd);
  454.  
  455. 		printf("\n最短路径：\n");
  456. 		// 输出路径函数
  457. 		Print(EndNumNode);
  458. 	}
  459. 	else
  460. 	{
  461. 		printf("不可达!!!");
  462. 	}
  463.  
  464.  
  465. 	return 0;
  466. }

A*算法代码

 

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include<stdio.h>
  4. #include<stdbool.h>
  5. #include<stdlib.h>
  6. #include<string.h>
  7. #include<assert.h>
  8. #include<time.h>
  9.  
  10. typedef struct QDatatype
  11. {
  12. 	int* arr; 
  13. 	struct QueueNode* father; 
  14. 	int deap;
  15. }QDatatype;
  16.  
  17. // 队列的链式结构实现
  18.  
  19. typedef struct QueueNode
  20. {
  21. 	int end_distance; 
  22. 	struct QueueNode* next; 
  23. 	struct QueueNode* above; 
  24. 	QDatatype data;
  25. }QueueNode;
  26.  
  27. typedef struct Queue
  28. {
  29. 	QueueNode* head;
  30. 	QueueNode* head_tail;
  31. 	QueueNode* tail;
  32. 	int size_open;  
  33. 	int size_close;
  34. }Queue;
  35.  
  36.  
  37. QueueNode* GetMin_distance_Node(QueueNode* pq)
  38. {
  39. 	int distance = INT_MAX;
  40. 	QueueNode* tmp = pq, *returnNode = NULL;
  41. 	while (tmp != NULL)
  42. 	{
  43. 		// 除去已经 搜索过的结果
  44. 		if (tmp->end_distance == INT_MAX)
  45. 			continue;
  46.  
  47. 		if ((tmp->data.deap + tmp->end_distance) < distance)
  48. 		{
  49. 			returnNode = tmp;
  50. 			distance = tmp->data.deap + tmp->end_distance;
  51. 		}
  52.  
  53. 		tmp = tmp->next;
  54. 	}
  55.  
  56. 	return returnNode;
  57. }
  58.  
  59. int Manhattan_distance( int* Arr, int* numArr)
  60. {
  61. 	int distance = 0;
  62. 	int flag = 0;
  63.  
  64. 	for (int i = 0; i < 3; i++)
  65. 	{
  66. 		for (int j = 0; j < 3; j++)
  67. 		{
  68. 			flag = 0;
  69. 			for (int k = 0; k < 3; k++)
  70. 			{
  71. 				for (int m = 0; m < 3; m++)
  72. 				{
  73. 					if (Arr[i * 3 + j] == numArr[k * 3 + m])
  74. 					{
  75. 						distance += abs(i - k) + abs(j - m);
  76. 						flag = 1;
  77. 						break;
  78. 					}
  79. 				}
  80. 				if (flag == 1)
  81. 					break;
  82. 			}
  83. 		}
  84. 	}
  85. 	return distance;
  86. }
  87.  
  88.  
  89. QueueNode* QueuePush(Queue* pq, QDatatype* x)
  90. {
  91. 	assert(pq);
  92.  
  93. 	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
  94. 	newNode->data.arr = (int*)malloc(sizeof(int) * 9);
  95. 	if (newNode == NULL)
  96. 	{
  97. 		perror("malloc fail");
  98. 		return NULL;
  99. 	}
  100.  
  101. 	newNode->next = NULL;
  102. 	newNode->above = NULL;
  103. 	for (int i = 0; i < 9; i++)
  104. 	{
  105. 		newNode->data.arr[i] = x->arr[i];
  106. 	}
  107. 	newNode->data.deap = x->deap;
  108. 	newNode->data.father = x->father;
  109.  
  110. 	if (pq->head == NULL)
  111. 	{
  112. 		assert(pq->tail == NULL);
  113.  
  114. 		pq->head = pq->head_tail = pq->tail = newNode;
  115. 	}
  116. 	else
  117. 	{
  118. 		pq->tail->next = newNode;
  119. 		newNode->above = pq->tail;
  120. 		pq->tail = newNode;
  121. 	}
  122.  
  123. 	pq->size_open++;
  124. 	return newNode;
  125. }
  126.  
  127. void QueueOpenPop(Queue* pq , QueueNode* node)
  128. {
  129. 	assert(pq);
  130. 	assert(pq->head);
  131. 	assert(pq->head_tail);
  132.  
  133. 	if (node == pq->head_tail)
  134. 	{
  135. 		pq->head_tail = pq->head_tail->next;
  136. 	}
  137. 	else
  138. 	{
  139. 		if (pq->tail == node)
  140. 			pq->tail = pq->tail->above;
  141.  
  142. 		QueueNode* next = node->next;
  143. 		QueueNode* above = node->above;
  144. 		above->next = next;
  145. 		if(next)
  146. 			next->above = above;
  147.  
  148. 		pq->head_tail->above->next = node;
  149. 		node->next = pq->head_tail;
  150. 		node->above = pq->head_tail->above;
  151. 		pq->head_tail->above = node;
  152. 	}
  153.  
  154. 	pq->size_open--;
  155. 	pq->size_close++;
  156. }
  157.  
  158.  
  159. bool QueueEmpty(Queue* pq)
  160. {
  161. 	assert(pq);
  162.  
  163. 	return pq->size_open == 0;
  164. }
  165.  
  166. void QueueInit(Queue* pq)
  167. {
  168. 	assert(pq);
  169.  
  170. 	pq->head = pq->head_tail = pq->tail = NULL;
  171. 	pq->size_open = 0;
  172. 	pq->size_close = 0;
  173. }
  174.  
  175. int count = 0;
  176.  
  177. bool is_same(QueueNode* Node1, int* arr)
  178. {
  179. 	for (int j = 0; j < 9; j++)
  180. 	{
  181. 		if (Node1->data.arr[j] != arr[j])
  182. 		{
  183. 			return false;
  184. 		}
  185. 	}
  186.  
  187. 	return true;
  188. }
  189.  
  190.  
  191. bool is_in_close(Queue* open, int* arr)
  192. {
  193. 	QueueNode* tmp = open->head;
  194. 	while (tmp != open->head_tail)
  195. 	{
  196. 		if (is_same(tmp, arr))
  197. 		{
  198. 			return true;
  199. 		}
  200. 		tmp = tmp->next;
  201. 	}
  202.  
  203. 	return false;
  204. }
  205.  
  206.  
  207. QueueNode* is_in_open(Queue* open, int* arr)
  208. {
  209. 	QueueNode* tmp = open->head_tail;
  210. 	while (tmp)
  211. 	{
  212. 		if (is_same(tmp, arr))
  213. 		{
  214. 			return tmp;
  215. 		}
  216. 		tmp = tmp->next;
  217. 	}
  218.  
  219. 	return NULL;
  220. }
  221.  
  222. void Swap(int* x, int* y)
  223. {
  224. 	int tmp = *x;
  225. 	*x = *y;
  226. 	*y = tmp;
  227. }
  228.  
  229.  
  230. QDatatype* creat_Node(int* a, struct QueueNode* father, int deap)
  231. {
  232. 	QDatatype* tmp = (QDatatype*)malloc(sizeof(QDatatype));
  233. 	tmp->arr = (int*)malloc(sizeof(int) * 9);
  234. 	for (int i = 0; i < 9; i++)
  235. 	{
  236. 		tmp->arr[i] = a[i];
  237. 	}
  238. 	tmp->father = father;
  239. 	tmp->deap = deap;
  240.  
  241. 	return tmp;
  242. }
  243.  
  244. int tmpArr[9];
  245.  
  246.  
  247. void BFS(QueueNode* node, Queue* open , int* numEnd)
  248. {
  249.  
  250. 	int blake = 0;
  251.  
  252. 	for (int i = 0; i < 9; i++)
  253. 	{
  254. 		if (node->data.arr[i] == 0)
  255. 		{
  256. 			blake = i;
  257. 			break;
  258. 		}
  259. 	}
  260. 	int dx = INT_MAX;
  261.  
  262. 	dx = blake - 3;
  263. 	if (dx >= 0)
  264. 	{
  265. 		for (int i = 0; i < 9; i++)
  266. 		{
  267. 			tmpArr[i] = node->data.arr[i];
  268. 		}
  269. 		Swap(&tmpArr[blake], &tmpArr[dx]);
  270.  
  271.  
  272. 		int distance = Manhattan_distance(tmpArr, numEnd);
  273.  
  274. 		if (!is_in_close(open, tmpArr))
  275. 		{
  276. 			QueueNode* tmpNode = is_in_open(open, tmpArr);
  277. 			if (!tmpNode)
  278. 			{
  279. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  280. 				QueuePush(open, tmp);
  281.  
  282. 				open->tail->end_distance = distance;
  283. 			}
  284. 			else
  285. 			{
  286. 	
  287. 				if (tmpNode->end_distance + tmpNode->data.deap > distance + node->data.deap + 1)
  288. 				{
  289. 					tmpNode->data.deap = node->data.deap + 1;
  290. 					tmpNode->data.father = node;
  291. 					tmpNode->end_distance = distance;
  292. 				}
  293. 			}
  294. 		}
  295. 	}
  296.  
  297. 	
  298. 	dx = blake + 3;
  299. 	if (dx < 9)
  300. 	{
  301. 		for (int i = 0; i < 9; i++)
  302. 		{
  303. 			tmpArr[i] = node->data.arr[i];
  304. 		}
  305. 		Swap(&tmpArr[blake], &tmpArr[dx]);
  306.  
  307. 	
  308. 		int distance = Manhattan_distance(tmpArr, numEnd);
  309.  
  310. 		if (!is_in_close(open, tmpArr))
  311. 		{
  312. 			QueueNode* tmpNode = is_in_open(open, tmpArr);
  313. 			if (!tmpNode)
  314. 			{
  315. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  316. 				QueuePush(open, tmp);
  317.  
  318. 				open->tail->end_distance = distance;
  319. 			}
  320. 			else
  321. 			{
  322. 			
  323. 				if (tmpNode->end_distance + tmpNode->data.deap > distance + node->data.deap + 1)
  324. 				{
  325. 					tmpNode->data.deap = node->data.deap + 1;
  326. 					tmpNode->data.father = node;
  327. 					tmpNode->end_distance = distance;
  328. 				}
  329. 			}
  330. 		}
  331. 	}
  332.  
  333.  
  334.  
  335. 	dx = blake - 1;
  336. 	if (dx >= (3 * (blake / 3)))
  337. 	{
  338. 		for (int i = 0; i < 9; i++)
  339. 		{
  340. 			tmpArr[i] = node->data.arr[i];
  341. 		}
  342. 		Swap(&tmpArr[blake], &tmpArr[dx]);
  343.  
  344.  
  345. 		int distance = Manhattan_distance(tmpArr, numEnd);
  346.  
  347. 		if (!is_in_close(open, tmpArr))
  348. 		{
  349. 			QueueNode* tmpNode = is_in_open(open, tmpArr);
  350. 			if (!tmpNode)
  351. 			{
  352. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  353. 				QueuePush(open, tmp);
  354.  
  355. 				open->tail->end_distance = distance;
  356. 			}
  357. 			else
  358. 			{
  359. 		
  360. 				if (tmpNode->end_distance + tmpNode->data.deap > distance + node->data.deap + 1)
  361. 				{
  362. 					tmpNode->data.deap = node->data.deap + 1;
  363. 					tmpNode->data.father = node;
  364. 					tmpNode->end_distance = distance;
  365. 				}
  366. 			}
  367. 		}
  368. 	}
  369.  
  370.  
  371. 	dx = blake + 1;
  372. 	if (dx < (3 * (blake / 3 + 1)))
  373. 	{
  374. 		for (int i = 0; i < 9; i++)
  375. 		{
  376. 			tmpArr[i] = node->data.arr[i];
  377. 		}
  378. 		Swap(&tmpArr[blake], &tmpArr[dx]);
  379.  
  380.  
  381. 		int distance = Manhattan_distance(tmpArr, numEnd);
  382.  
  383. 		if (!is_in_close(open, tmpArr))
  384. 		{
  385. 			QueueNode* tmpNode = is_in_open(open, tmpArr);
  386. 			if (!tmpNode)
  387. 			{
  388. 				QDatatype* tmp = creat_Node(tmpArr, node, node->data.deap + 1);
  389. 				QueuePush(open, tmp);
  390.  
  391. 				open->tail->end_distance = distance;
  392. 			}
  393. 			else
  394. 			{
  395.  
  396. 				if (tmpNode->end_distance + tmpNode->data.deap > distance + node->data.deap + 1)
  397. 				{
  398. 					tmpNode->data.deap = node->data.deap + 1;
  399. 					tmpNode->data.father = node;
  400. 					tmpNode->end_distance = distance;
  401. 				}
  402. 			}
  403. 		}
  404. 	}
  405.  
  406.  
  407.  
  408. 	QueueOpenPop(open, node);
  409.  
  410. }
  411.  
  412.  
  413. bool matrix_is_arrive(int* arr1, int* arr2, int row, int wide)
  414. {
  415. 	int InverseNum1 = 0;
  416. 	for (int i = 0; i < row * wide - 1; i++)
  417. 	{
  418. 	
  419. 		if (arr1[i] == 0)
  420. 			continue;
  421.  
  422. 		for (int j = i + 1; j < row * wide; j++)
  423. 		{
  424. 		
  425. 			if (arr1[j] == 0)
  426. 				continue;
  427.  
  428. 			if (arr1[i] > arr1[j])
  429. 				InverseNum1++;
  430. 		}
  431. 	}
  432.  
  433. 	int InverseNum2 = 0;
  434. 	for (int i = 0; i < row * wide - 1; i++)
  435. 	{
  436. 	
  437. 		if (arr2[i] == 0)
  438. 			continue;
  439.  
  440. 		for (int j = i + 1; j < row * wide; j++)
  441. 		{
  442. 		
  443. 			if (arr2[j] == 0)
  444. 				continue;
  445.  
  446. 			if (arr2[i] > arr2[j])
  447. 				InverseNum2++;
  448. 		}
  449. 	}
  450.  
  451.  
  452. 	if ((InverseNum2 + InverseNum1) % 2 == 0)
  453. 		return true;
  454. 	else
  455. 		return false;
  456. }
  457.  
  458.  
  459. QueueNode* EndNode(Queue* Qe, int* numEnd)
  460. {
  461. 	QueueNode* tmp = Qe->head;
  462. 	while (tmp)
  463. 	{
  464. 		if (is_same(tmp, numEnd))
  465. 		{
  466. 			return tmp;
  467. 		}
  468. 		tmp = tmp->next;
  469. 	}
  470.  
  471. 	return NULL;
  472. }
  473.  
  474.  
  475. void Print(QueueNode* node)
  476. {
  477. 	QueueNode* tmp = node;
  478. 	int num = 1;
  479. 	while (tmp != NULL)
  480. 	{
  481. 		printf("\nstep: %d\n\n-------\n", num++);
  482. 		for (int i = 0; i < 9; i++)
  483. 		{
  484. 			printf("|%d", tmp->data.arr[i]);
  485. 			if ((i + 1) % 3 == 0)
  486. 			{
  487. 				printf("|\n-------\n");
  488. 			}
  489. 		}
  490.  
  491. 		tmp = tmp->data.father;
  492. 	}
  493. }
  494.  
  495.  
  496. void Eight_difital_A(int* numStart, int* numEnd)
  497. {
  498. 	Queue open;
  499. 	QueueInit(&open);
  500.  
  501. 	QDatatype* tmp = creat_Node(numStart, NULL, 0);
  502. 	QueueNode* tmpNode = QueuePush(&open, tmp);
  503.  
  504. 	if (matrix_is_arrive(numStart, numEnd, 3, 3))
  505. 	{
  506.  
  507. 		while (!QueueEmpty(&open))
  508. 		{
  509. 			if (is_in_open(&open, numEnd))
  510. 				break;
  511.  
  512.  
  513. 			QueueNode* node = GetMin_distance_Node(open.head_tail);
  514.  
  515. 			BFS(node, &open, numEnd);
  516. 		}
  517.  
  518. 	
  519. 		QueueNode* EndNumNode = EndNode(&open, numEnd);
  520.  
  521. 		printf("\n最短路径：\n");
  522. 	
  523. 		Print(EndNumNode);
  524. 	}
  525. 	else
  526. 	{
  527. 		printf("\n\n不可达!!!\n\n");
  528. 	}
  529. }
  530.  
  531. void menu()
  532. {
  533. 	printf("/**************************************\\\n");
  534. 	printf("|  1.随机创建数码问题例子              |\n");
  535. 	printf("|  2.手动在文件当中输入一个或多个例子  |\n");
  536. 	printf("|  0.退出程序                          |\n");
  537. 	printf("\\**************************************/\n\n请输入:\n");
  538. }
  539.  
  540. bool digital_is_same_rand(int pos, int num ,int* arr)
  541. {
  542. 	for (int i = 0; i < pos; i++)
  543. 	{
  544. 		if (num == arr[i])
  545. 			return true;
  546. 	}
  547.  
  548. 	return false;
  549. }
  550.  
  551. int main()
  552. {
  553. 	int numStart[9];
  554. 	int numEnd[9];
  555. 	FILE* f1 = fopen("xxxx.txt", "r");
  556. 	int returnnum = 1, size = 0;
  557.  
  558. 	int num = 1;
  559. 	while (num)
  560. 	{
  561. 		menu();
  562. 		scanf("%d", &num);
  563. 		switch (num)
  564. 		{
  565. 			case 1:
  566. 				printf("\n*************************************\n起始矩阵->");
  567. 				srand((unsigned)time(NULL));
  568. 				for (int i = 0; i < 9; i++)
  569. 				{
  570. 					numStart[i] = rand() % 9;
  571. 					while (digital_is_same_rand(i, numStart[i], numStart))
  572. 					{
  573. 						numStart[i] = rand() % 9;
  574. 					}
  575. 					if (i % 3 == 0 && i != 0)
  576. 						printf("|");
  577. 					if (i % 3 == 0)
  578. 						printf("\n-------\n");
  579. 					printf("|%d", numStart[i]);
  580. 				}
  581. 				printf("|\n-------\n\n目标矩阵->");
  582. 				for (int i = 0; i < 9; i++)
  583. 				{
  584. 					numEnd[i] = rand() % 9;
  585. 					while (digital_is_same_rand(i, numEnd[i], numEnd))
  586. 					{
  587. 						numEnd[i] = rand() % 9;
  588. 					}
  589. 					if (i % 3 == 0 && i != 0)
  590. 						printf("|");
  591. 					if (i % 3 == 0)
  592. 						printf("\n-------\n");
  593. 					printf("|%d", numEnd[i]);
  594. 				}
  595. 				printf("|\n-------\n");
  596.  
  597. 				Eight_difital_A(numStart, numEnd);
  598. 				break;
  599. 			case 2:
  600. 				while (returnnum != EOF)
  601. 				{
  602. 					size++;
  603. 					printf("\n*************************************\n起始矩阵->");
  604. 					for (int i = 0; i < 9; i++)
  605. 					{
  606. 						returnnum = fscanf(f1, "%d ", &numStart[i]);
  607.  
  608. 						if (returnnum == EOF)
  609. 							break;
  610.  
  611. 						if (i % 3 == 0 && i != 0)
  612. 							printf("|");
  613. 						if (i % 3 == 0)
  614. 							printf("\n-------\n");
  615. 						printf("|%d", numStart[i]);
  616. 					}
  617. 					if (returnnum == EOF)
  618. 					{
  619. 						printf("目标矩阵，对应文件输入的各个最短路径如上所示\n*******************************************************\n");
  620. 						break;
  621. 					}
  622. 					printf("|\n-------\n\n目标矩阵->");
  623. 					for (int i = 0; i < 9; i++)
  624. 					{
  625. 						fscanf(f1, "%d ", &numEnd[i]);
  626. 						if (i % 3 == 0 && i != 0)
  627. 							printf("|");
  628. 						if (i % 3 == 0)
  629. 							printf("\n-------\n");
  630. 						printf("|%d", numEnd[i]);
  631. 					}
  632. 					printf("|\n-------\n上述是输入的数码问题->%d\n", size);
  633.  
  634. 					Eight_difital_A(numStart, numEnd);
  635. 				}
  636. 				break;
  637. 			default :
  638. 				break;
  639. 		}
  640. 	}
  641. 	fclose(f1);
  642.  
  643. 	return 0;
  644. }
  645.  
  646.  
  647.

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号