八数码（A*+路径输出+逆序数+康托展开式hash）

最新推荐文章于 2022-06-27 20:17:56 发布
最新推荐文章于 2022-06-27 20:17:56 发布
阅读量604 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq3434569/article/details/78604519
版权

九宫重排

问题描述

给定九宫格的初始状态，要求在有限步的操作内，使其转化为目标状态，且所得到的解是代价最小解(即移动的步数最少)。如：


基本要求

输入：九宫格的初始状态和目标状态

输出：重排的过程，即途径的状态

空格用0来表示

BFS 做法，状态数为9！，可以用set存，就是效率很慢

#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
#include<set>
using namespace std;


struct Dig
{
	int p[9];//当前的状态
	int len;//步数
	int pos;//空格所在的位置
	int ans[32][9];//存取路径 因为最长的路径不可能大于2的32次方
};

set<int>s;
int dir[4] = { 1,-1,3,-3 };


Dig start;
//2 8 3
//1 0 4
//7 6 5

void bfs()
{
	queue<Dig>q;
	q.push(start);
	while (!q.empty())
	{
		Dig tmp1 = q.front();
		if (tmp1.p[0] == 1 && tmp1.p[1] == 2 && tmp1.p[2] == 3 && tmp1.p[3] == 8 && tmp1.p[4] == 0 && tmp1.p[5] == 4 && tmp1.p[6] == 7 && tmp1.p[7] == 6 && tmp1.p[8] == 5)
		{
			printf("You must move it at least %d times\n", tmp1.len);
			for (int i = 0; i <= tmp1.len; i++)
			{
				printf("The %d times move:\n", i);
				for (int j = 0; j < 9; j++)
				{
					if (j % 3 == 0)puts("");
					printf("%5d", tmp1.ans[i][j]);
				}
				puts("");
			}

			return;
		}
		tmp1.len++;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			Dig tmp2 = tmp1;
			tmp2.pos = tmp2.pos + dir[i];
			if (dir[i] == 1 && (tmp2.pos == 3 || tmp2.pos == 6))continue;//空格在最左边不能-1
			if (dir[i] == -1 && (tmp2.pos == 2 || tmp2.pos == 5))continue;//同理
			if (tmp2.pos >= 0 && tmp2.pos < 9)//必须在范围内
			{
				swap(tmp2.p[tmp2.pos], tmp2.p[tmp2.pos - dir[i]]);//移动
				int status = 0;
				for (int i = 0; i < 9; i++)
					status = status * 10 + tmp2.p[i] + 1;

				if (s.count(status)==0) { //没有重复出现
					for (int i = 0; i < 9; i++)
						tmp2.ans[tmp2.len][i] = tmp2.p[i];
					s.insert(status);
					q.push(tmp2); }
			}
		}

	}
	puts("找不到解");
}
int main()
{
	while (1)
	{
		puts("Input the inital status:");
		for (int i = 0; i < 9; i++)
		{
			scanf("%d", &start.p[i]);
			if (start.p[i] == 0)start.pos = i;
			start.ans[0][i] = start.p[i];
		}
		start.len = 0;
		s.clear();
		int value=0;
		for (int i = 0; i < 9; i++)//0 1 2 3 4 5 6 7 8 -->123456789
			value = value * 10 + (start.p[i] + 1);
		s.insert(value);
		bfs();
	}
	
}
BFS+康托hash判重就快了很多了 


#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;


struct Dig
{
	int p[9];
	int len;
	int pos;
	int ans[32][9];
};

int  fac[] = { 1,1,2,6,24,120,720,5040,40320 };
bool vis[555555];
int dir[4] = { 1,-1,3,-3 };


Dig start;
//2 8 3
//1 0 4
//7 6 5

int KT(Dig s)//康托展开式hash
{
	int i, j, t, sum;
	sum = 0;
	for (i = 0; i<9; i++)
	{
		t = 0;
		for (j = i + 1; j<9; j++)
			if (s.p[j] < s.p[i])
				t++;
		sum += t*fac[9 - i - 1];
	}
	return sum + 1;
}

void bfs()
{
	queue<Dig>q;
	q.push(start);
	while (!q.empty())
	{
		Dig tmp1 = q.front();
		if (tmp1.p[0] == 1 && tmp1.p[1] == 2 && tmp1.p[2] == 3 && tmp1.p[3] == 8 && tmp1.p[4] == 0 && tmp1.p[5] == 4 && tmp1.p[6] == 7 && tmp1.p[7] == 6 && tmp1.p[8] == 5)
		{
			printf("You must move it at least %d times\n", tmp1.len);
			for (int i = 0; i <= tmp1.len; i++)
			{
				printf("The %d times move:\n", i);
				for (int j = 0; j < 9; j++)
				{
					if (j % 3 == 0)puts("");
					printf("%5d", tmp1.ans[i][j]);
				}
				puts("");
			}

			return;
		}
		tmp1.len++;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			Dig tmp2 = tmp1;
			tmp2.pos = tmp2.pos + dir[i];
			if (dir[i] == 1 && (tmp2.pos == 3 || tmp2.pos == 6))continue;
			if (dir[i] == -1 && (tmp2.pos == 2 || tmp2.pos == 5))continue;
			if (tmp2.pos >= 0 && tmp2.pos < 9)
			{
				swap(tmp2.p[tmp2.pos], tmp2.p[tmp2.pos - dir[i]]);
				int status = KT(tmp2);
				if (!vis[status]) { 
					for (int i = 0; i < 9; i++)
						tmp2.ans[tmp2.len][i] = tmp2.p[i];
					vis[status] = true;
					q.push(tmp2); }
			}
		}

	}
	puts("找不到解");
}
int main()
{
	while (1)
	{
		puts("Input the inital status:");
		for (int i = 0; i < 9; i++)
		{
			scanf("%d", &start.p[i]);
			if (start.p[i] == 0)start.pos = i;
			start.ans[0][i] = start.p[i];
		}
		start.len = 0;
		memset(vis, false, sizeof(vis));
		vis[KT(start)] = true;
		bfs();
	}
	
}

用A*的话，如果八数码无解还是和BFS的效率一样，所以加个逆序数判断有无解

这个A*的函数是  f(n)=g(n)+h(n)     

g(n)代表步数

h(n)代表当前八数码不在位的个数

剪枝原理：

       逆序数：对于n个不同的元素，先规定各元素之间有一个标准次序（例如n个 不同的自然数，可规定从小到大为标准次序），于是在这n个元素的任一排列中，当某两个元素的先后次序与标准次序不同时，就说有1个逆序。逆序对的总数称为逆序数

       只要终止状态和起始状态的逆序数(空的位置不算)奇偶性不同，就一定不能达到目标状态。

       分析：向左或者向右移动，逆序数的奇偶行不变....0,xt,xt+1...,将.0和xt交换，奇偶性是不变的

       对 x1  x2  x3

           x4   x5  x6

           x7   0    x8

      将0和x5交换，x1  x2  x3  x4   x5  x6 x7   0    x8，下面分三种情况

     a)若 x5>x6 && x5> x7，则逆序数+2

     a)若 x5 <x6 && x5<x7，则逆序数-2

     a)若 x5 在6 和x7之间，则逆序数不变

通过以上分析可知：只有起始状态可终止状态逆序数奇偶性相同才能转换


#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;


struct Dig
{
	int p[9];
	int len;
	int pos;
	int ans[32][9];
	int cost;
	bool operator < (const Dig &a) const {
		return cost>a.cost;//最小值优先
	}
};

int  fac[] = { 1,1,2,6,24,120,720,5040,40320 };
bool vis[555555];
int dir[4] = { 1,-1,3,-3 };


Dig start;
//2 8 3
//1 0 4
//7 6 5

bool inverse(Dig s)
{
	int t = 0, x, y;
	for (int i = 1; i<9; i++)
		for (int j = 0; j<i; j++)
		{
			if (s.p[j] == 0)continue;
			else x = s.p[j];
			if (s.p[i] == 0)continue;
			else y = s.p[i];
			if (x>y)
				t++;
		}
	if (t & 1)
		return true;
	return false;
}
int KT(Dig s)//康托展开式hash
{
	int i, j, t, sum;
	sum = 0;
	for (i = 0; i<9; i++)
	{
		t = 0;
		for (j = i + 1; j<9; j++)
			if (s.p[j] < s.p[i])
				t++;
		sum += t*fac[9 - i - 1];
	}
	return sum + 1;
}

int fcost(Dig tmp1)
{
	int cnt = 9;
	if (tmp1.p[0] == 1)cnt--;
	if (tmp1.p[1] == 2)cnt--; 
	if (tmp1.p[2] == 3)cnt--;
	if (tmp1.p[3] == 8)cnt--;
	if (tmp1.p[4] == 0)cnt--;
	if (tmp1.p[5] == 4)cnt--;
	if (tmp1.p[6] == 7)cnt--;
	if (tmp1.p[7] == 6)cnt--;
	if (tmp1.p[8] == 5)cnt--;
	return cnt;
}

void Astar()
{
	priority_queue<Dig>q;
	q.push(start);
	while (!q.empty())
	{
		Dig tmp1 = q.top();
		if (tmp1.p[0] == 1 && tmp1.p[1] == 2 && tmp1.p[2] == 3 && tmp1.p[3] == 8 && tmp1.p[4] == 0 && tmp1.p[5] == 4 && tmp1.p[6] == 7 && tmp1.p[7] == 6 && tmp1.p[8] == 5)
		{
			printf("You must move it at least %d times\n", tmp1.len);
			for (int i = 0; i <= tmp1.len; i++)
			{
				printf("The %d times move:\n", i);
				for (int j = 0; j < 9; j++)
				{
					if (j % 3 == 0)puts("");
					printf("%5d", tmp1.ans[i][j]);
				}
				puts("");
			}

			return;
		}
		tmp1.len++;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			Dig tmp2 = tmp1;
			tmp2.pos = tmp2.pos + dir[i];
			if (dir[i] == 1 && (tmp2.pos == 3 || tmp2.pos == 6))continue;
			if (dir[i] == -1 && (tmp2.pos == 2 || tmp2.pos == 5))continue;
			if (tmp2.pos >= 0 && tmp2.pos < 9)
			{
				swap(tmp2.p[tmp2.pos], tmp2.p[tmp2.pos - dir[i]]);
				int status = KT(tmp2);
				if (!vis[status]) { 
					for (int i = 0; i < 9; i++)
						tmp2.ans[tmp2.len][i] = tmp2.p[i];
					tmp2.cost = tmp2.len + fcost(tmp2);
					vis[status] = true;
					q.push(tmp2); }
			}
		}

	}
}
int main()
{
	while (1)
	{
		puts("Input the inital status:");
		for (int i = 0; i < 9; i++)
		{
			scanf("%d", &start.p[i]);
			if (start.p[i] == 0)start.pos = i;
			start.ans[0][i] = start.p[i];
		}
		if (!inverse(start))
		{
			printf("unsolvable\n");
			continue;
		}
		start.len = 0;
		start.cost = start.len + fcost(start);
		memset(vis, false, sizeof(vis));
		vis[KT(start)] = true;
		Astar();
	}
	
}

输入目标状态 

#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;


struct Dig
{
	int p[9];
	int len;
	int pos;
	int ans[32][9];
	int cost;
	bool operator < (const Dig &a) const {
		return cost>a.cost;//最小值优先
	}
};

int  fac[] = { 1,1,2,6,24,120,720,5040,40320 };
bool vis[555555];
int dir[4] = { 1,-1,3,-3 };


Dig start;
//2 8 3
//1 0 4
//7 6 5
Dig last;

bool inverse(Dig s)
{
	int t = 0, x, y;
	for (int i = 1; i<9; i++)
		for (int j = 0; j<i; j++)
		{
			if (s.p[j] == 0)continue;
			else x = s.p[j];
			if (s.p[i] == 0)continue;
			else y = s.p[i];
			if (x>y)
				t++;
		}
	if (t & 1)return true;
	return false;
}

void input()
{
	puts("Input the inital status:");
	for (int i = 0; i < 9; i++)
	{
		scanf("%d", &start.p[i]);
		if (start.p[i] == 0)start.pos = i;
		start.ans[0][i] = start.p[i];
	}
	puts("Input the last status:");
	for (int i = 0; i < 9; i++)
	{

		scanf("%d",&last.p[i]);
	}
}

int KT(Dig s)//康托展开式hash
{
	int i, j, t, sum;
	sum = 0;
	for (i = 0; i<9; i++)
	{
		t = 0;
		for (j = i + 1; j<9; j++)
			if (s.p[j] < s.p[i])
				t++;
		sum += t*fac[9 - i - 1];
	}
	return sum + 1;
}

int fcost(Dig s)
{
	int cnt = 0;
	for (int i = 0; i <9 ; i++)
	{
		if (s.p[i] != last.p[i])cnt++;
	}
	return cnt;
}

void Astar()
{
	priority_queue<Dig>q;
	bool OK ;
	q.push(start);
	while (!q.empty())
	{
		Dig tmp1 = q.top();
		OK = true;
		for (int i = 0; i < 9; i++)
		{
			if (tmp1.p[i] != last.p[i]) { OK = false; break; }
		}
		if (OK)
		{
			printf("You must move it at least %d times\n", tmp1.len);
			for (int i = 0; i <= tmp1.len; i++)
			{
				printf("The %d times move:\n", i);
				for (int j = 0; j < 9; j++)
				{
					if (j % 3 == 0)puts("");
					printf("%5d", tmp1.ans[i][j]);
				}
				puts("");
			}

			return;
		}
		tmp1.len++;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			Dig tmp2 = tmp1;
			tmp2.pos = tmp2.pos + dir[i];
			if (dir[i] == 1 && (tmp2.pos == 3 || tmp2.pos == 6))continue;
			if (dir[i] == -1 && (tmp2.pos == 2 || tmp2.pos == 5))continue;
			if (tmp2.pos >= 0 && tmp2.pos < 9)
			{
				swap(tmp2.p[tmp2.pos], tmp2.p[tmp2.pos - dir[i]]);
				int status = KT(tmp2);
				if (!vis[status]) { 
					for (int i = 0; i < 9; i++)
						tmp2.ans[tmp2.len][i] = tmp2.p[i];
					tmp2.cost = tmp2.len + fcost(tmp2);
					vis[status] = true;
					q.push(tmp2); }
			}
		}

	}
}
int main()
{
	while (1)
	{
		input();
		bool invs = inverse(start);
		bool invl= inverse(last);
		if (invs!=invl)
		{
			printf("unsolvable\n");
			continue;
		}
		start.len = 0;
		start.cost = start.len + fcost(start);
		memset(vis, false, sizeof(vis));
		vis[KT(start)] = true;
		Astar();
	}
	
}

A* +曼哈顿距离 


#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;


struct Dig
{
	int p[9];
	int len;
	int pos;
	int ans[32][9];
	int cost;
	bool operator < (const Dig &a) const {
		return cost>a.cost;//最小值优先
	}
};
int dir[4] = { 1,-1,3,-3 };
int  fac[] = { 1,1,2,6,24,120,720,5040,40320 };
bool vis[555555];
bool first;
int lpos[9];



Dig start;
//2 8 3 1 0 4 7 6 5
//1 2 3 8 0 4 7 6 5
//2 1 6 4 0 8 7 5 3->18steps
Dig last;

bool inverse(Dig s)
{
	int t = 0, x, y;
	for (int i = 1; i<9; i++)
		for (int j = 0; j<i; j++)
		{
			if (s.p[j] == 0)continue;
			else x = s.p[j];
			if (s.p[i] == 0)continue;
			else y = s.p[i];
			if (x>y)
				t++;
		}
	if (t & 1)return true;
	return false;
}

void input()
{
	puts("Input the inital status:");
	for (int i = 0; i < 9; i++)
	{
		scanf("%d", &start.p[i]);
		if (start.p[i] == 0)start.pos = i;
		start.ans[0][i] = start.p[i];
	}
	puts("Input the last status:");
	for (int i = 0; i < 9; i++)
	{

		scanf("%d",&last.p[i]);
	}
}

int KT(Dig s)//康托展开式hash
{
	int i, j, t, sum;
	sum = 0;
	for (i = 0; i<9; i++)
	{
		t = 0;
		for (j = i + 1; j<9; j++)
			if (s.p[j] < s.p[i])
				t++;
		sum += t*fac[9 - i - 1];
	}
	return sum + 1;
}

int fcost(Dig s)//manhattan距离
{
	int mlen = 0,x,y;
	if (first)
	{
		for (int i = 0; i < 9; i++)
		{
			lpos[last.p[i]] = i;
		}
		first = false;
	}
	for (int i = 0; i < 9; i++)
	{
		x = i % 3;
		y = i / 3;
		mlen += abs(lpos[s.p[i]]%3-x)+abs(lpos[s.p[i]]/3-y);
	}
	return mlen;
}

void Astar()
{
	priority_queue<Dig>q;
	bool OK ;
	q.push(start);
	while (!q.empty())
	{
		Dig tmp1 = q.top();
		OK = true;
		for (int i = 0; i < 9; i++)
		{
			if (tmp1.p[i] != last.p[i]) { OK = false; break; }
		}
		if (OK)
		{
			printf("You must move it at least %d times\n", tmp1.len);
			for (int i = 0; i <= tmp1.len; i++)
			{
				printf("The %d times move:\n", i);
				for (int j = 0; j < 9; j++)
				{
					if (j % 3 == 0)puts("");
					printf("%5d", tmp1.ans[i][j]);
				}
				puts("");
			}

			return;
		}
		tmp1.len++;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			Dig tmp2 = tmp1;
			tmp2.pos = tmp2.pos + dir[i];
			if (dir[i] == 1 && (tmp2.pos == 3 || tmp2.pos == 6))continue;
			if (dir[i] == -1 && (tmp2.pos == 2 || tmp2.pos == 5))continue;
			if (tmp2.pos >= 0 && tmp2.pos < 9)
			{
				swap(tmp2.p[tmp2.pos], tmp2.p[tmp2.pos - dir[i]]);
				int status = KT(tmp2);
				if (!vis[status]) { 
					for (int i = 0; i < 9; i++)
						tmp2.ans[tmp2.len][i] = tmp2.p[i];
					tmp2.cost = tmp2.len + fcost(tmp2);
					vis[status] = true;
					q.push(tmp2); }
			}
		}

	}
}
int main()
{
	while (1)
	{
		input();
		bool invs = inverse(start);
		bool invl= inverse(last);
		if (invs!=invl)
		{
			printf("unsolvable\n");
			continue;
		}
		first = true;
		start.len = 0;
		start.cost = start.len + fcost(start);
		memset(vis, false, sizeof(vis));
		vis[KT(start)] = true;
		Astar();
	}
	
}


南极亚拉
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
人工智能-BFS-8数码问题-路径打印
11-09
人工智能大作业：c++代码bfs解决8数码问题
HDU 1043 Eight 【经典八数码输出路径/BFS/A*/康托展开】
weixin_33963189的博客
07-14 177
本题有写法好几个写法，但主要思路是BFS： No。1 采用双向宽搜，分别从起始态和结束态进行宽搜，暴力判重。如果只进行单向会超时。 No。2 采用hash进行判重，宽搜采用单向就可以AC。 No。3 运用康拓展开进行判重，即使采用单向宽搜时间效率也很高。 哈希是想到了，但是我们应该选择什么哈希函数呢，看了网上一些神牛利用的是"康托展开",也就是利用全排列都有一个对应的整数，利用哈希函数把状态压缩成...
八数码问题的可解性
随缘，随心
10-13 2752
对于给定八数码棋局的初始状态，我们的目标是通过交换空格与其相邻棋子使棋盘达到目标状态。 其中，游戏规则是只能交换空格与其上下左右四个方向的相邻棋子。 假设棋局目标状态为如下形式：（A、B、C、D、E、F、G、H表示棋子） A  B  C D  E  F G  H
八数码输出转换路径---bfs
ZZU_LGY
01-08 295
#include <iostream> #include <cstring> #include <algorithm> #include <queue> #include <unordered_map> using namespace std; unordered_map<string,int>d; unordered_map<string,pair<string,char>>path; queue&lt...
八数码问题，bfs,hash,康托
Coder Calvin at Work
03-11 2055
<br />#include<iostream> #include<cstdio> #include<string> using namespace std; //关键点： //1.康托展开作为hash函数 //2.用字符数组作为移动，其他用等价的integer，因为可能将0 // 移到首位而造成错误 // struct node{ char str[10]; node *next; node *last; }; int dir[9][5]={{2,2,4,0
字符串逆序+c语言字符串逆序输出+c语言字符串逆序逐行解释
12-14
字符串逆序+c语言字符串逆序输出+c语言字符串逆序逐行解释字符串逆序+c语言字符串逆序输出+c语言字符串逆序逐行解释字符串逆序+c语言字符串逆序输出+c语言字符串逆序逐行解释字符串逆序+c语言字符串逆序输出+c语言...
A*算法求解八数码问题_C#语言
11-20
A*算法求解八数码问题 1、A*算法基本思想： 1）建立一个队列，计算初始结点的估价函数f，并将初始结点入队，设置队列头和尾指针。 2）取出队列头（队列头指针所指）的结点，如果该结点是目标结点，则输出路径，程序...
字符串逆序-使用C语言+递归实现字符串逆序.zip
最新发布
03-21
在编程领域，字符串逆序是一种常见的操作，尤其是在处理文本数据时。C语言作为一种基础且强大的编程语言，提供了灵活的方式来处理字符串。本主题将深入探讨如何使用C语言和递归方法来实现字符串逆序。 首先，我们...
C++ 给出一个多位数，使其逆序输出
11-19
逆序输出多位数，首先要考虑是否溢出，int，longlong，由于要输出一个多位数的逆序，传统的除10取余显然不行，这里可以用循环，即先判断多位数是几位，用到#include头文件，即位数len=（int）log10（n）+1。...
Python实现按照指定要求逆序输出一个数字的方法
09-20
在Python编程中，有时我们需要根据特定要求逆序输出一个数字，比如保留负号、去除前导零等。本文将详细讲解如何实现这个功能，并提供一个实际的Python代码示例。 首先，我们要理解问题的核心需求： 1. 如果数字是...
HDU1043 Eight(八数码，BFS，康托展开，hash)
riba2534的博客
04-17 322
Problem Description The 15-puzzle has been around for over 100 years; even if you don’t know it by that name, you’ve seen it. It is constructed with 15 sliding tiles, each with a number from...
八数码第八境界——IDA*+逆序数判无解
qq_36523667的博客
12-14 743
（请先看前面7大境界） IDA*是什么？ 它已经不再像A*一样通过bfs+优先队列+曼哈顿距离3者结合来做。 它是通过曼哈顿距离，求出最大搜索深度，还是和上篇文章的例子一样来说。 我们这里使用的是曼哈顿距离。 我们希望的路径假设是 4 8 7 1 2 x 5 6 3 我们的结束路径是 1 2 3 4 5 6 7 8 x
深入理解逆序数+八数码原理
qq_36523667的博客
12-14 6313
什么是逆序数？ 比如2 4 3 1。 依次看下去，2比1大，4比3大，4比1大，3比1大。所以逆序数就是4。 所以我们得知了逆序数就是体现在一个逆字上。相比于在正常序列下1234。有多少前面的数比后面的数大的这种情况，就是逆序数了。 逆序数为什么可以判八数码的无解？ （八数码：    1 2 3    4 5 6    7 8 x）  因为如果起始状态和目标状态，如果把目
计算逆序对数
u013517182的博客
01-02 1040
计算逆序对数的程序描述：一个长度为N的整数序列A，满足i<ji<j，Ai>AjA_{i}>A_{j}，的对数（i，j）称为整数序列A的一个逆序对，求出整数序列A的所有的逆序对数输入：输入包含多组测试数据，每组测试数据包含两行，第一行为整数N（1<=N<=20000），当输入0时结束，第二行为N个整数，表示长度为N的整数序列输出：每组数据对应一行，输出逆序对的个数样例输入5 1 2 3 4 5 5 5
A星(A*、A Star)路径规划算法详解（附MATLAB代码）
晨少的博客
06-27 3万+
一、A* 算法原理 二、A* 算法实现步骤 三、A* 算法MATLAB代码举个例子来说，A*算法通常要将地图网格化，如下图所示： 假设有一只乌龟在追小白兔，乌龟此时的位置是（2,2），小白兔的位置是（6,6），假设小白兔静止不动。 根据A *算法的原理，乌龟只能向左、向右、向上、向下走，那么（1,2）、（2,1）、（3,2）、（2,3）是乌龟下一轮可以到达的点，这些点叫做 待探索的点步骤一 寻找下一步可以到达的节点，将这些待探索的点加入待探索数组 frontier 中，也叫边界数组。 计算出新加入点的代价
八数码——路径寻找问题
Switch的博客
05-25 1578
#include <cstdio> #include <cstring> #include <set>using namespace std;// 状态类型，每一个状态都对应9个数 typedef int State[9]; const int maxState = 1000000; // 状态数组 State st[maxState], goal; // 距离数组 int dist[maxStat
八数码问题
dengm155的专栏
11-08 1461
八数码问题 这是课程中的一个实验，问题比较有趣，所有代码都是本人自行设计编写，所以特意写出来供大家学习和参考，做到这个实验的同学千万不要完整复制我写的代码哦，参考学习一下，你可以自己写出更好的代码。   问题描述： 给定九宫格的初始状态，要求在有限步的操作内，使其转化为目标状态，且所得到的解是代价最小解(即移动的步数最少)。例如： 2   3
HDU 1043 八数码问题 A*搜索+康拓展开+逆序对判断+路径输出
Little_boy_z的博客
11-03 343
康托展开：和其他一样，为了方便表示各个状态，让每个状态都变成一个数来表示 逆序对判断：如果图八数码，那个这个图所有的逆序对之和一定是偶数的，如果是奇数，则不是八数码 路径输出： pre数组记录前置点，vis数组同时表示是否访问过，也记录着方向。到达这个点是都得什么方向。 A*搜索：建立一个queue，按照g排序，优先访问g小的，g相同访问h小的。  而估价函数是用的曼哈顿距离
A*算法解决八数码问题
热门推荐
我的新博客
10-12 7万+
1 问题描述 1.1什么是八数码问题 八数码游戏包括一个33的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。与空位相邻的棋子可以滑动到空位中。游戏的目的是要达到一个特定的目标状态。标注的形式化如下：   1 2 3 4 5 6 7 8 1.2问题的搜索形式描述
从键盘任意输入一个4位整数,编程计算并输出它的逆序数.例如:输入1234,分离出千位1、百位2、十位3和个位4，然后计算4*1000+3*100+2*10+1=4321，并输出4321。
03-14
好的，我可以回答这个问题。以下是Lua的代码： ``` io.write("请输入一个4位整数：") ...输入一个4位整数后，程序会将其分离出千位、百位、十位和个位，然后计算逆序数并输出。例如，如果输入1234，则输出4321。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值