基于C++实现A算法的求解八数码问题的程序

已于 2025-03-18 17:47:10 修改
阅读量2.4k 收藏 51
点赞数 6
文章标签： 算法 c++ A算法 八数码问题 课程设计 源码 论文
于 2022-07-26 09:08:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/newlw/article/details/125987477
版权

目录
一、实验概述 3
(1) 实验目的 3
(2) 实验内容 3
二、实验方案设计 3
(1) 总体设计思路与总体架构 3
3. 流程图：（见下页） 3
(2) 核心算法及基本原理 4
(3) 模块设计 5
(4) 其它创新内容或优化算法 8
15 数码问题也能通过简单的修改宏定义来整体适应。 9
三、实验过程 9
(1) 环境说明 9
(2) 源文件代码清单、主要函数清单 9
8Puzzle_UI.h： 9
8Puzzle.h： 10
(3) 实验结果展示 13
(4) 实验结论 16
四、总结 16
(1) 实验中存在的问题及解决方案 16
(2) 心得体会 17
(3) 后续改进方向 17
(4) 总结 18
五、参考文献 18
六、成员分工与自评 18

  1. 成员分工： 18
  2. 成员自评： 18
  3. 总体评价与收获 19
    一、实验概述
    (1)实验目的
    熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用 A算法求解 8 数码难题，理解求解流程和搜索顺序。
    (2)实验内容
    1.采用 C++语言实现 A    算法的求解八数码问题的程序，设计了两种不同的估价函数： 第一种：计算不在位的棋子数；第二种：计算所有棋子到其目标的距离和。
    2.设置相同初始状态和目标状态，针对两种的估价函数，求得问题的解，并比较它们对搜索算法性能的影响，包括扩展节点数、生成节点数和运行时间。画出不同启发函数 h(n)求解 8 数码问题的结果比较表，进行性能分析。
    3.通过 UI 界面显示八数码问题的初始状态，目标状态和中间搜索步骤。
    4.画出搜索生成的树，在每个节点显示对应节点的 f (n)值，以显示搜索过程。以红色标注出最终结果所选用的路线。
    二、实验方案设计
    (1)总体设计思路与总体架构
    1.总体设计思路：程序从设计上分为两个部分：算法实现部分和图形显示部分。两部分相互独立，仅通过函数进行数值传递或者指针传递的方式进行关联。当算法部分运行完成后，会得到关于一个八数码问题的最优路径解、搜索树以及求解过程中产生的例如生成结点数、扩展结点数的信息，将这些信息以数值、指针、字符串等形式传值至图形显示部分。
    2.总体架构：总体架构设计基于上述的设计思路。程序代码具体分为：算法实现部分、八数码九宫格绘制部分、搜索树绘制部分三份代码。每份代码具有独立的数据结构定义及相关功能实现过程，通过 main()函数进行主算法的调用、参数传递，并在主算法中对图形界面绘制函数进行调用和传参。
    本文转载自：http://www.biyezuopin.vip/onews.asp?id=16513
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include<easyx.h>
#include <conio.h>
#include "8Puzzle.h"
using namespace std;

/* 构造函数，将initial和target置0，清空Open表和Close表,搜索树ST置空 */
EightPuzzle::EightPuzzle()
{
	int i, j;

	for (i = 0; i < MatrixSize; i++) {
		for (j = 0; j < MatrixSize; j++) {
			initial.matrix[i][j] = 0;
			target.matrix[i][j] = 0;
		}
	}
	initial.Gn = 0;
	initial.Hn = 0;
	initial.Fn = 0;
	target.Gn = 0;
	target.Hn = 0;
	target.Fn = 0;

	while (!Open.empty())
		Open.pop();
	while (!Close.empty())
		Close.pop();
	while (!Path.empty())
		Path.pop();

	PI.is_solvable = false;
	PI.total_step = "总步数：0";
	PI.total_time = "时间：0s";

	InitSTree(ST);
}

/* 析构函数，清空Open表和Close表，销毁搜索树ST */
EightPuzzle::~EightPuzzle()
{
	while (!Open.empty())
		Open.pop();
	while (!Close.empty())
		Close.pop();
	while (!Path.empty())
		Path.pop();
	DestroySTree(ST);
}

/* 重载< */
bool Matrix::operator<(const Matrix& a) const
{
	return Fn < a.Fn;
}

/* 重载> */
bool Matrix::operator>(const Matrix& a) const
{
	return Fn > a.Fn;
}

/* 重载<= */
bool Matrix::operator<=(const Matrix& a) const
{
	return Fn <= a.Fn;
}

/* 重载>= */
bool Matrix::operator>=(const Matrix& a) const
{
	return Fn >= a.Fn;
}

/* 重载== */
bool Matrix::operator==(const Matrix& a) const
{
	int i, j;

	for (i = 0; i < MatrixSize; i++) {
		for (j = 0; j < MatrixSize; j++) {
			if (matrix[i][j] != a.matrix[i][j])
				return false;
		}
	}

	return true;
}

/* 以随机赋值的方式生成initial和target */
void EightPuzzle::RandomAssignment()
{
	int i, j, k = 1;

	srand((unsigned)time(NULL));
	while (k < ArraySize) {
		i = rand() % MatrixSize;
		j = rand() % MatrixSize;
		if (!initial.matrix[i][j]) {
			initial.matrix[i][j] = k;
			k++;
		}
	}
	k = 1;
	while (k < ArraySize) {
		i = rand() % MatrixSize;
		j = rand() % MatrixSize;
		if (!target.matrix[i][j]) {
			target.matrix[i][j] = k;
			k++;
		}
	}
}

/* 以键盘输入的方式对initial和target赋值 */
void EightPuzzle::TypeIn()
{
	int i, j, flag = 0;
	int check[ArraySize] = { 0 };

	cout << "请输入初始状态，数字0-8，三行三列（空格位置处数字为0）：" << endl;
	while (1) {
		flag = 0;
		for (i = 0; i < ArraySize; i++) {
			check[i] = 0;
		}

		for (i = 0; i < MatrixSize; i++) {
			for (j = 0; j < MatrixSize; j++) {
				cin >> initial.matrix[i][j];
				if (cin.fail()) {
					flag = 1;
					cin.clear();
					cin.ignore();
				}
				else if (initial.matrix[i][j] < 0 || initial.matrix[i][j] > 8)
					flag = 1;
				else
					check[initial.matrix[i][j]]++;
			}
		}

		for (i = 0; i < ArraySize; i++) {
			if (check[i] != 1)
				flag = 1;
		}

		if (flag) {
			cout << "初始状态输入有误，请重新输入：" << endl;
			flag = 0;
			continue;
		}
		else
			break;
	}

	cout << "请输入目标状态，数字0-8，三行三列（空格位置处数字为0）：" << endl;
	while (1) {
		flag = 0;
		for (i = 0; i < ArraySize; i++) {
			check[i] = 0;
		}

		for (i = 0; i < MatrixSize; i++) {
			for (j = 0; j < MatrixSize; j++) {
				cin >> target.matrix[i][j];
				if (cin.fail()) {
					flag = 1;
					cin.clear();
					cin.ignore();
				}
				else if (target.matrix[i][j] < 0 || target.matrix[i][j] > 8)
					flag = 1;
				else
					check[target.matrix[i][j]]++;
			}
		}

		for (i = 0; i < ArraySize; i++) {
			if (check[i] != 1)
				flag = 1;
		}

		if (flag) {
			cout << "目标状态输入有误，请重新输入：" << endl;
			flag = 0;
			continue;
		}
		else
			break;
	}
}

/* 判断初始八数码与目标八数码逆序数的奇偶性，问题是否可解 */
bool EightPuzzle::IsSolvable()
{
	int count_initial = 0, count_target = 0;
	int temp_initial[ArraySize], temp_target[ArraySize];
	int i, j, k;

	for (i = 0, k = 0; i < MatrixSize; i++) {
		for (j = 0; j < MatrixSize; j++) {
			temp_initial[k++] = initial.matrix[i][j];
		}
	}
	for (i = 0, k = 0; i < MatrixSize; i++) {
		for (j = 0; j < MatrixSize; j++) {
			temp_target[k++] = target.matrix[i][j];
		}
	}

	for (i = 1; i < ArraySize; i++) {
		for (j = i - 1; j >= 0; j--) {
			if (temp_initial[j] > temp_initial[i] && temp_initial[i]) {
				count_initial++;
			}
			if (temp_target[j] > temp_target[i] && temp_target[i]) {
				count_target++;
			}
		}
	}

	if (count_initial % 2 == count_target % 2)
		return true;
	else
		return false;
}

/* 判断当前结点是否与target相同 */
bool EightPuzzle::IsOver(Matrix m)
{
	return (m == target);
}

/* A*算法，type为Hn的计算方式，算法完成后更新PI中的信息 */
void EightPuzzle::AStar(int type)
{
	EIGHT_PUZZLE_UI Peight;
	Matrix current;
	STNode* p;//p用于指示当前结点在搜索树中的位置
	STNode* last;//last用于指示目标结点
	clock_t start, end;
	string message[6] = { "按回车开始演示" };//信息栏内容
	int maxdepth;//记录搜索树的最大深度，用于绘图
	int expande_node = 0;//当前结点可扩展结点数
	int next_choose = 0;//选择的扩展结点序号
	//以下分别为初始数组、目标数组、当前数组和当前可扩展数组
	char display_initial[MatrixSize][MatrixSize];
	char display_target[MatrixSize][MatrixSize];
	char display_current[MatrixSize][MatrixSize];
	char display_expandable[MaxExpandableNode][MatrixSize][MatrixSize];

	PI.is_solvable = IsSolvable();

	if (PI.is_solvable) {
		start = clock();
		//将初始结点的信息更新，加入Open表和搜索树ST中
		Update(initial, type);
		AddToOpen(initial);
		CreateSTNode(ST, ST, initial, 0);
		p = ST;

		while (!Open.empty()) {
			current = Open.top();//当前结点取Open表中Fn值最小的结点
			//Show(current);//显示当前结点的信息
			Open.pop();
			PreOrderSearch(ST, p, current);//p指向当前结点在搜索树中的位置
			if (IsOver(current))//当前结点是目标结点，结束循环
				break;
			else {
				Expand(current, p, type);//当前结点不是目标结点，扩展当前结点
				AddToClose(current);//扩展结束，当前结点加入Close表
			}
		}
		PreOrderTraverse(ST, MyVisit);//先序遍历显示整个算法的搜索树

		end = clock();
		PI.total_step = "总步数：" + int_to_char(p->depth - 1);
		PI.total_time = "时间：" + to_string(((double)end - (double)start) / CLOCKS_PER_SEC) + "s";
		last = p;
		CreatePath(p);

		cout << "请按回车继续......" << endl;
		_getch();


		BestPath(last);
		Depth_of_STree(ST, maxdepth);
		//初始化绘图界面并绘制搜索树
		Draw_STree(ST, Width, Height, Origin_X, Origin_Y, maxdepth);



		//初始化UI界面
		Draw_UI(Peight, PI.is_solvable);

		//显示初始数组和目标数组
		Mint_to_Mchar(display_initial, initial.matrix);
		Mint_to_Mchar(display_target, target.matrix);
		display_number(Peight, display_initial, MAIN_FRAME_RIGHT);
		display_number(Peight, display_target, MAIN_FRAME_LEFT);

		//显示初始界面信息
		display_text(Peight, message);

		_getch();

		//用于消除“初始状态“提示
		clearrectangle(MAIN_LEFT_REC_LEFT + MAIN_REC_SIDE_LENGTH + MAIN_REC_GAP_SIZE, MAIN_LEFT_REC_TOP - 20, MAIN_LEFT_REC_LEFT + MAIN_REC_SIDE_LENGTH + MAIN_REC_GAP_SIZE + MAINFRAME_TIP_HEIGHT * 4, MAIN_LEFT_REC_TOP - 2);
		//切换”初始状态“为”当前状态“
		set_mainframe_tip(Peight, false);
		//切换”按回车演示“为”正在演示“
		Peight.top_tip.tip = TOP_TIP_2;
		//用于消除左上角信息重复提示
		clearrectangle(0, 0, TOP_TIP_HEIGHT * 6, TOP_TIP_HEIGHT);
		display_text(Peight, message);

		//演示解决步骤
		while (message[0] != "") {
			//状态更新的时间间隔
			Sleep(2000);
			//_getch();
			//获得Path中当前结点的信息
			GetInfo(message, expande_node, next_choose, display_current, display_expandable);
			//更新当前状态数组显示
			draw_9squares(NINE_SQUARES, Peight.Main_frame.right_square);
			display_number(Peight, display_current, MAIN_FRAME_RIGHT);
			//指定可扩展结点的数目和选择的扩展结点
			set_sub_square_num(Peight, expande_node);
			set_selected_sub_square(Peight, next_choose);
			//更新可扩展结点显示
			draw_frame(Peight, SUB_FRAME);
			for (int i = 0; i < expande_node; i++) {
				display_number(Peight, display_expandable[i], SUB_FRAME, i);
			}
			//更新信息框显示
			print_info_frame_tip(Peight, message);
		}
		//切换”正在演示“为”按回车演示“
		Peight.top_tip.tip = TOP_TIP;
		clearrectangle(0, 0, TOP_TIP_HEIGHT * 6, TOP_TIP_HEIGHT);
		print_graph_frame_tip(Peight);

		_getch();
	}
	else {
		//初始化UI界面并显示无解
		Draw_UI(Peight, PI.is_solvable);
		//显示初始数组和目标数组
		Mint_to_Mchar(display_initial, initial.matrix);
		Mint_to_Mchar(display_target, target.matrix);
		display_number(Peight, display_initial, MAIN_FRAME_RIGHT);
		display_number(Peight, display_target, MAIN_FRAME_LEFT);

		draw_frame(Peight, INFO_FRAME);
		display_text(Peight, message);
		_getch();
	}
}

/* 找到当前结点中空格（0）所在的位置，x、y为位置坐标 */
void EightPuzzle::GetPos(Matrix m, int& x, int& y)
{
	int i, j;

	for (i = 0; i < MatrixSize; i++) {
		for (j = 0; j < MatrixSize; j++) {
			if (m.matrix[i][j] == 0) {
				x = i;
				y = j;
				return;
			}
		}
	}
}

/* 对结点空格进行上、下、左、右方向的移动，移动成功后对结点的Gn值进行更新 */
Status EightPuzzle::Move(Matrix& m, int direction) {
	int x, y;

	GetPos(m, x, y);

	switch (direction) {
		case Up:
			if (x == 0)
				return ERROR;
			else {
				m.matrix[x][y] = m.matrix[x - 1][y];
				m.matrix[x - 1][y] = 0;
				m.Gn++;
				return OK;
			}
			break;
		case Down:
			if (x == MatrixSize - 1)
				return ERROR;
			else {
				m.matrix[x][y] = m.matrix[x + 1][y];
				m.matrix[x + 1][y] = 0;
				m.Gn++;
				return OK;
			}
			break;
		case Left:
			if (y == 0)
				return ERROR;
			else {
				m.matrix[x][y] = m.matrix[x][y - 1];
				m.matrix[x][y - 1] = 0;
				m.Gn++;
				return OK;
			}
			break;
		case Right:
			if (y == MatrixSize - 1)
				return ERROR;
			else {
				m.matrix[x][y] = m.matrix[x][y + 1];
				m.matrix[x][y + 1] = 0;
				m.Gn++;
				return OK;
			}
			break;
		default:
			return ERROR;
			break;
	}
}

/*
	对结点Hn值、Fn值进行更新，添加搜索树ST的结点
	type：Hn的计算方式
	p：搜索树中当前扩展结点的指针
*/
void EightPuzzle::Expand(Matrix& m, STNode* p, int type)
{
	Matrix temp;
	int direction, first = 1;

	//向上、下、左、右四个方向扩展结点
	for (direction = Up; direction <= Right; direction++) {
		temp = m;
		if (Move(temp, direction)) {
			Update(temp, type);//若该方向可扩展结点则更新扩展后的结点信息
			if (AddToOpen(temp)) {//检查可扩展结点是否可以加入Open表，防止重复，可以则加入Open表
				if (first) {//第1个可扩展结点作为指针所指结点的孩子结点
					CreateSTNode(ST, p, temp, FirstChild);
					p = p->firstchild;
					first = 0;
				}
				else {//其余可扩展结点作为第1个可扩展结点的兄弟结点
					CreateSTNode(ST, p, temp, NextSibling);
					p = p->nextsibling;
				}
			}
		}
	}
}

/*
	对当前结点进行上、下、左、右方向的扩展，type为Hn的计算方式
	type=1：不在位的棋子数
	type=2：所有棋子到其目标的距离和
*/
void EightPuzzle::Update(Matrix& m, int type)
{
	int i, j, count = 0;
	int temp[ArraySize][2] = { 0 };

	switch (type) {
		case 1:
			for (i = 0; i < MatrixSize; i++) {
				for (j = 0; j < MatrixSize; j++) {
					if (m.matrix[i][j] != target.matrix[i][j] && m.matrix[i][j]) {
						count++;
					}
				}
			}
			break;
		case 2:
			for (i = 0; i < MatrixSize; i++) {
				for (j = 0; j < MatrixSize; j++) {
					if (m.matrix[i][j]) {
						temp[m.matrix[i][j]][0] = i;
						temp[m.matrix[i][j]][1] = j;
					}
				}
			}
			for (i = 0; i < MatrixSize; i++) {
				for (j = 0; j < MatrixSize; j++) {
					if (target.matrix[i][j]) {
						count += abs(i - temp[target.matrix[i][j]][0]) + abs(j - temp[target.matrix[i][j]][1]);
					}
				}
			}
			break;
		default:
			break;
	}

	m.Hn = count;
	m.Fn = m.Gn + m.Hn;
}

/* 将结点加入Open表，成功返回OK，失败返回ERROR */
Status EightPuzzle::AddToOpen(Matrix m)
{
	if (!FindInClose(m) && FindInOpen(m) == ERROR) {
		Open.push(m);
		return OK;
	}
	else//若Open表或Close表中有该结点则失败
		return ERROR;
}

/* 将结点加入Close表，成功返回OK，失败返回ERROR */
Status EightPuzzle::AddToClose(Matrix m)
{
	if (!FindInClose(m)) {
		Close.push(m);
		return OK;
	}
	else//若Close表中已有该结点则失败
		return ERROR;
}

/* 查找Open表中是否有相同的结点，若有则更新结点信息 */
Status EightPuzzle::FindInClose(Matrix m)
{
	Matrix temp, flag;
	int status = ERROR;

	if (!Close.empty()) {
		flag = Close.front();
		while (1) {
			temp = Close.front();
			Close.pop();
			if (temp == m) {
				status = OK;
			}
			Close.push(temp);
			if (Close.front() == flag)
				break;
		}
		return status;
	}
	else
		return ERROR;
}

/* 查找Close表中是否有相同的结点 */
Status EightPuzzle::FindInOpen(Matrix m)
{
	Matrix* p;
	int i, size, status = ERROR;

	size = Open.size();
	if (!size) {
		p = new(nothrow) Matrix[size];
		if (!p)
			return INFEASIBLE;

		for (i = 0; i < size; i++) {
			p[i] = Open.top();
			Open.pop();
			if (p[i] == m) {
				status = OK;
				if (m.Fn < p[i].Fn) {
					p[i].Fn = m.Fn;
					p[i].Gn = m.Gn;
					p[i].Hn = m.Hn;
				}
			}
		}
		for (i = 0; i < size; i++) {
			Open.push(p[i]);
		}

		delete[] p;
	}

	return status;
}

/* 将最优路径存储至栈Path中，从目标叶子结点回溯到根结点 */
void EightPuzzle::CreatePath(STNode* last_node)
{
	MatrixInfo mi;
	STNode* p = last_node, *q, *pre = NULL;
	int count_en, i, j;

	while (p) {
		for (i = 0; i < MatrixSize; i++) {
			for (j = 0; j < MatrixSize; j++) {
				mi.current_matrix[i][j] = char(p->data.matrix[i][j]) + '0';
			}
		}
		mi.Fn = "F(n)=" + int_to_char(p->data.Fn);
		mi.Hn = "H(n)=" + int_to_char(p->data.Hn);
		mi.Gn = "G(n)=" + int_to_char(p->data.Gn);
		mi.step = "步数：" + int_to_char(p->depth - 1);
		mi.next = -1;

		q = p->firstchild;
		count_en = 0;

		while (q) {
			if (pre) {
				if (q->data.matrix == pre->data.matrix)
					mi.next = count_en;
			}

			for (i = 0; i < MatrixSize; i++) {
				for (j = 0; j < MatrixSize; j++) {
					mi.expandable_matrix[count_en][i][j] = char(q->data.matrix[i][j]) + '0';
				}
			}

			q = q->nextsibling;
			count_en++;
		}
		mi.expandable_node = count_en;
		pre = p;
		p = p->parent;
		Path.push(mi);
	}
}

/* 新增：用于传至画图部分的信息字符串,最多调用总步数+1次 */
void EightPuzzle::GetInfo(string s[6], int& expande, int& next, char Current[MatrixSize][MatrixSize], char Expandable[MaxExpandableNode][MatrixSize][MatrixSize])
{
	if (!Path.empty()) {
		s[0] = PI.total_time; //第1条信息：时间
		s[1] = PI.total_step; //第2条信息：总步数
		s[2] = "已扩展结点数：" + to_string(Close.size()); //第3条信息：已扩展结点数
		s[3] = "生成结点数：" + to_string(Close.size() + Open.size()); //第4条信息：生成结点数
		s[4] = Path.top().step; //第5条信息：当前步数
		s[5] = Path.top().Fn; //第6条信息：Fn值
		expande = Path.top().expandable_node;
		next = Path.top().next;
		//Current = Path.top().current_matrix;
		Matrix_to_Matrix(Current, Path.top().current_matrix);
		//Expandable = Path.top().expandable_matrix;
		for (int i = 0; i < 4; i++) {
			Matrix_to_Matrix(Expandable[i], Path.top().expandable_matrix[i]);
		}
		Path.pop(); //该结点数据读取完毕，弹出Path栈
	}
	else
		s[0] = "";
}

/* 显示当前结点的所有信息 */
void Show(Matrix m)
{
	int i, j;

	cout << endl;
	for (i = 0; i < MatrixSize; i++) {
		for (j = 0; j < MatrixSize; j++) {
			if (m.matrix[i][j] == 0)
				cout << "  ";
			else
				cout << m.matrix[i][j] << ' ';
		}
		cout << endl;
	}
	cout << "F=" << m.Fn << endl;
	cout << "G=" << m.Gn << endl;
	cout << "H=" << m.Hn << endl << endl;
}

/* 初始化搜索树 */
Status InitSTree(STree& ST)
{
	ST = NULL;
	return OK;
}

/* 销毁搜索树 */
Status DestroySTree(STree& ST)
{
	if (ST) {
		if (ST->firstchild)
			DestroySTree(ST->firstchild);
		if ((ST)->nextsibling)
			DestroySTree(ST->nextsibling);
		delete ST;
		ST = NULL;
	}

	return OK;
}

/*
	创建新的搜索树结点，并连接至搜索树，type为新结点类型，Node为新结点需要连接至树的位置的结点指针
	type=FIRSTCHILD：新结点为孩子结点
	type=NEXTSIBLING：新结点为兄弟结点
*/
Status CreateSTNode(STree& ST, STNode* Node, TElemType e, int type)
{
	STNode* p = NULL;

	p = new(nothrow) STNode;
	if (p == NULL)
		return LOVERFLOW;
	else {
		p->data = e;
		p->depth = e.Gn + 1;
		p->target_path = FALSE;
		p->firstchild = NULL;
		p->nextsibling = NULL;
		p->parent = NULL;
	}

	if (ST) {
		switch (type) {
			case FirstChild:
				Node->firstchild = p;
				p->parent = Node;
				break;
			case NextSibling:
				Node->nextsibling = p;
				p->parent = Node->parent;
				break;
			default:
				break;
		}
	}
	else {
		ST = p;
	}

	return OK;
}

/* 先序遍历搜索树 */
Status PreOrderTraverse(STree ST, Status(*visit)(TElemType e))
{
	if (ST) {
		if ((*visit)(ST->data) == OK)
			if (PreOrderTraverse(ST->firstchild, visit) == OK)
				if (PreOrderTraverse(ST->nextsibling, visit) == OK)
					return OK;
		return ERROR;
	}
	else   //空树返回OK
		return OK;
}

/* 先序遍历搜索树查找与e值相同的结点，指针p指向其位置 */
Status PreOrderSearch(STree ST, STNode*& p, TElemType e)
{
	if (ST) {
		if (ST->data == e) {
			p = ST;
			return OK;
		}
		else {
			if (PreOrderSearch(ST->firstchild, p, e) == OK)
				return OK;
			else {
				if (PreOrderSearch(ST->nextsibling, p, e) == OK)
					return OK;
				else
					return ERROR;
			}

		}
	}
	else
		return ERROR;

}

/* 先序遍历搜索树中的显示函数 */
Status MyVisit(TElemType e)
{
	Show(e);
	cout << "深度=" << e.Gn + 1 << endl;

	return OK;
}

/* 非负整数转化为字符串 */
string int_to_char(int n)
{
	string s = "";
	char m;
	int k, l;
	l = n;
	if (n >= 10) {
		k = l / 10;
		s += int_to_char(k);
	}
	m = '0' + l % 10;
	s += m;
	return s;
}

/* 非负整数矩阵转化为字符矩阵 */
void Mint_to_Mchar(char c[MatrixSize][MatrixSize], int s[MatrixSize][MatrixSize])
{
	for (int i = 0; i < MatrixSize; i++) {
		for (int j = 0; j < MatrixSize; j++) {
			c[i][j] = char(s[i][j]) + '0';
		}
	}
}

/* 字符矩阵相互赋值 */
void Matrix_to_Matrix(char a[MatrixSize][MatrixSize], char b[MatrixSize][MatrixSize])
{
	for (int i = 0; i < MatrixSize; i++) {
		for (int j = 0; j < MatrixSize; j++) {
			a[i][j] = b[i][j];
		}
	}
}

/* 初始化绘制窗口并打印搜索树 */
void Draw_STree(STree &ST, const int width, const int height, const int X, const int Y, const int maxdepth)
{
	// 创建绘图窗口，大小由参数传入
	initgraph(width, height);
	// 设置绘图原点，位置由参数传入
	setorigin(X, Y);
	// 设置背景以及填充色为白色
	setbkcolor(WHITE);
	// 用背景色清空屏幕
	cleardevice();
	//设置图形填充色为青色
	setfillcolor(CYAN);
	//设置文字输出底色为透明
	setbkmode(TRANSPARENT);
	// 设置绘图线为青色
	setlinecolor(CYAN);
	// 设置绘图线样式
	setlinestyle(PS_SOLID, 1, PS_ENDCAP_ROUND, PS_JOIN_ROUND);
	// 设置文字输出颜色为黑色
	settextcolor(BLACK);
	PrintSTree(ST, 0, 0, 0, 0, maxdepth);

	outtextxy(-X, -Y, "请按回车继续...");
	_getch();				// 按任意键继续
	closegraph();			// 关闭绘图窗口
}

/* 打印搜索树 */
void PrintSTree(STree ST, int x, int y, int lastx, int lasty, int maxdepth)
{
	if (ST) {
		int depth = ST->depth;
		char str[10];

		if (ST->target_path == TRUE) {//当前结点为目标路径上的结点，用红线连接
			setlinecolor(RED);
		}
		else {//否则用青线连接
			setlinecolor(CYAN);
		}
		line(x, y, lastx, lasty);
		//Sleep(50);
		fillcircle(x, y, 15);
		_itoa_s(ST->data.Fn, str, 10);
		outtextxy(x - 4, y - 8, str);

		PrintSTree(ST->firstchild, x - int(pow(2, (maxdepth - depth)) * Space_of_Tree), y + 4 * Space_of_Tree, x, y, maxdepth);
		PrintSTree(ST->nextsibling, x + 2 * int(pow(2, (maxdepth - depth)) * Space_of_Tree), y, lastx, lasty, maxdepth);

	}
}

/* 记录搜索树的最大深度 */
Status Depth_of_STree(STree ST, int& depth)
{
	if (ST) {
		if (ST->depth > depth) {
			depth = ST->depth;
		}
		if (Depth_of_STree(ST->firstchild, depth) == OK) {
			if (Depth_of_STree(ST->nextsibling, depth) == OK) {
				return OK;
			}
		}
		return ERROR;
	}
	else   //空树返回OK
		return OK;
}

/* 从目标叶子结点回溯到根结点找出最优路径，并在树中做标记 */
void BestPath(STNode* last_node)
{
	STNode*p = last_node;
	while (p) {
		p->target_path = TRUE;
		p = p->parent;
	}
}

/* 初始化UI界面 */
void Draw_UI(EIGHT_PUZZLE_UI &Peight, bool Flag)
{
	setui(Peight, GRAPH);
	setui(Peight, MAIN_FRAME);
	setui(Peight, SUB_FRAME);
	setui(Peight, INFO_FRAME);

	init_graph(Peight);
	draw_frame(Peight, MAIN_FRAME);

	set_sub_square_num(Peight, 4);
	set_selected_sub_square(Peight, FORTH_REC);
	draw_frame(Peight, INFO_FRAME);


	init_tip(Peight, GRAPH);
	init_tip(Peight, MAIN_FRAME);
	init_tip(Peight, SUB_FRAME);
	init_tip(Peight, INFO_FRAME);
	is_solved(Peight, Flag);

	set_mainframe_tip(Peight, true);
	print_graph_frame_tip(Peight);
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

biyezuopinvip
关注
A*算法解决八数码问题的C++实现
小半杯的专栏
07-11 1万+
A*算法解决八数码问题的C++实现。
A*算法解决八数码问题（C++）
12-26
A*算法解决八数码问题（C++），用数组实现的
A算法求解八数码问题（C++实现）
LeopoldZhang2000的博客
02-16 4966
A算法求解八数码问题 （0）判断有无解：根据逆序数直接判断有无解，对于一个八数码，依次排列之后，每次是将空位和相邻位进行调换，研究后会发现，每次调换，逆序数增幅都为偶数，也就是不改变奇偶性，所以初始和目标状态的逆序数的奇偶性相同。 （1） 定义代价函数G(x)和启发函数H(X)，以A算法进行求解。 （2） 输入初始状态和目标状态。 （3） 输出从初始状态到目标状态的路线。
C++实现的基于A算法解答八数码问题
毕业作品网站
07-03 1434
在3×3方格盘上，放有八个数码，剩下一个位置为空，每一空格其上下左右的数码可移至空格。给定初始位置和目标位置，要求通过一系列的数码移动，将初始状态转化为目标状态。状态转换的规则：空格四周的数移向空格，我们可以看作是空格移动，它最多可以有4个方向的移动，即上、下、左、右。九宫重排问题的求解方法，就是从给定的初始状态出发，不断地空格上下左右的数码移至空格，将一个状态转化成其它状态，直到产生目标状态。例如：​ 初始状态 目标状态八数码问题示意图●
A/A*算法解决八数码问题（C++实现）
weixin_44735393的博客
01-17 6925
@A算法解决八数码问题 一、实验原理 1.状态图搜索 1.1搜索树：搜索过程中经过的节点和边按原图的连接关系构成一个树型的有向图，称为搜索树。 1.2搜索方式 树式搜索：记录搜索过程中所经过的所有节点和边 1.3路径的获得 树式搜索：反向求解 2.搜索算法 2.1 CLOSED表和OPEN表 closed表对树式搜索来说存储的是正在成长的搜索树，对线式搜索来说存储的是不断伸长的折线，本身就是所求的...
基于C++实现A算法的求解八数码问题的程序.zip
10-15
资源包含文件：课程论文word+源码...熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用 A*算法求解 8 数码难题，理解求解流程和搜索顺序。详细介绍参考：https://blog.csdn.net/newlw/article/details/125987477
基于C++实现的AStar求解八数码问题.zip
12-12
基于AStar算法求解八数码问题 至少定义3种不同的启发Sta式函数，编程实现求解八数码问题的A*算法； 要求用可视化界面演示算法执行过程，应能选择预定义的启发式函数，能随机初始化初始状态，能单步执行，也能连续...
基于 C++ 语言实现 A算法的求解八数码问题的程序【100010703】
02-07
采用 C++ 语言实现 A*算法的求解八数码问题的程序，设计了两种不同的估价函数：第一种：计算不在位的棋子数；第二种：计算所有棋子到其目标的距离和。 设置相同初始状态和目标状态，针对两种的估价函数，求得问题的...
基于C++ AStar算法求解八数码问题【100013107】
07-27
在该实验中， AStar算法成功求解了八数码问题，找到了最优解，并用 C++进行模拟实现，以文件 I/O 的方式展示了结果。综上所述，实验达到预期目的，加深了对AStar算法的理解，熟悉了算法背后的整个流程，并成功解决了...
基于 C++ 实现爬山法，模拟退火算法，遗传算法 求解N皇后问题.zip
最新发布
07-02
基于 C++ 实现爬山法，模拟退火算法，遗传算法 求解N皇后问题.zip基于 C++ 实现爬山法，模拟退火算法，遗传算法 求解N皇后问题.zip基于 C++ 实现爬山法，模拟退火算法，遗传算法 求解N皇后问题.zip基于 C++ 实现爬山...
人工智能 A*算法 八数码问题 C++ 报告+代码+详细注释
03-29
使用C++语言完整的实现了A星算法解决八数码问题 内容：完整代码和详细注释； 主要函数的功能说明； 评价函数的设计； 运行测试结果
8数码问题的c++代码
07-31
参见我的博文：http://blog.csdn.net/j56754gefge/article/details/47170967 这是8数码问题的一套完整解决方案，包括问题模型、搜索方法、界面表示等。有问题请给我发邮件，代码里面有我mail
八数码问题C++代码
05-26
八数码问题C++代码
八数码游戏程序（人工智能，c++）
11-13
本程序利用c++语言编写了八数码 的 小游戏 ，是人工智能 课必做的一个经典程序，希望能对大家有用
八数码问题C++源代码
11-02
人工智能里经典的八数码问题的c++实现，包括深度优先，广度优先，有界深度，启发式搜索的实现。所有代码均是最最基本的算法实现，没有考虑效率，适合入门研究图搜索的基本原理。
用C++解决八数码问题（包含讲解和代码）
2302_78003776的博客
11-03 2027
将九个数码或一个空格加八个数码放入九宫格内，将顺序打乱后获得一个乱序的九宫格。八数码问题就是指如何通过移动一个格子（下面我将其称为移动元），将乱序的九宫格复原，即通过移动左下图中0的格子，使九宫格恢复成右下图的样子。需要用到搜索求解的方法。
8数码问题（C++）
MISS_XDY的博客
03-31 1124
思路：用数组比较有没有到达最终状态较为繁琐，还需要再创建一个临时数组。 可以将数组转化为一个9位数字，比如左图数组，转化为9位数为207584163，便于比较。使用bfs，从初始态开始搜索，如果某个中间状态可以由上一步走到，且该状态还未出现过（即在移动0时，还没有移动到过当前的位置），则放入队列，继续向下搜索。用map存中间状态。 输入result为终态对应的9位数。（有些偷懒，应...
C++编写解决八数码问题
qq_51648316的博客
01-03 4781
**C++编写解决八数码问题## 一、需求与规则说明 八数码问题又称重排九宫问题，在一个 33 的棋盘上，随机放置 1 到 8 的数 字棋子，剩下一个空位，如图所示。数字可以移动到空位（编程时，空位可用 0 代替，且可以理解为是空位的上、下、左、右移动），经过若干次移动后，棋局 到达指定目标状态。 说明：重排九宫问题，对任意给定初始状态，可达下图所示两个目标之一， 不可互换。 目标一：如下图 G 目标二：如下图 G1 或 G2 要求： ① 编程求解问题； ② 给出中间状态； ③ 给出解序列（函数调用
A*算法解决八数码问题（C++版本）
热门推荐
yums467的专栏
03-09 1万+
八数码问题定义： 八数码问题也称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。 A*算法的通用伪代码 ：A*算法解决八数码问题的关键之处： 关键之处： 要维护两个结构： open表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值