八数码(双向BFS和A *和康托展开)

八数码(双向BFS和A * 和康托展开)

https://www.luogu.com.cn/problem/P1379(传送门)

一道题用三种方法来写

题目大意

在3×3的棋盘上,摆有八个棋子,每个棋子上标有1至8的某一数字。棋盘中留有一个空格,空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是:给出一种初始布局(初始状态)和目标布局(为了使题目简单,设目标状态为123804765),找到一种最少步骤的移动方法,实现从初始布局到目标布局的转变。

输入格式

输入初始状态,一行九个数字,空格用0表示

输出格式

只有一行,该行只有一个数字,表示从初始状态到目标状态需要的最少移动次数(测试数据中无特殊无法到达目标状态数据)

输入 #1复制

283104765

输出 #1复制

4

样例可变成这样

八数码(双向BFS和A *和康托展开)_第1张图片

一、康托展开

康托展开

函数cantor()实现的功能是 : 输入一个排列,计算出它的cantor值 即在全排列中是第几个。

例如 12345 cantor值是 1; 12354 cantor值是 2;12435cantor值是 3;

那么如何实现呢?很简单

比如说求2143是{1.2.3.4}的全排列第几大的数

1、比首位2小的只有1这一个数,后面3个数的排列有3!种,所以ans+=1 × \times × 3!;

2、首位为2,比第二位1小的数的个数为0,后面两个数的排列有2!种,所以ans+=0 × \times × 2!;

3、前面为21,比第三位4小的只有3一个(因为前面21已经用了),后面的一个数的排列有1!种,所以ans+=1 × \times × 1!;

4、前三位为214,emmm,不用看也是0了(因为总共只有四位)

总的来说就是

从第一位依次往后遍历,看在未出现的元素中比当前位小的有多少个,然后乘上后面的位数个数的阶乘。累积起来即可。

代码

int cantor(string x){
int len=x.length();
    int ans=0;
for(int i=0;i

逆康拓展开

顾名思义就是康托展开的逆过程,在一个集合的全排列中,给你一个数k,求出第k大的排列,即为逆康托展开

代码(限于篇幅,会在代码中注明原理)

void decantor(int k,int n)//n是排列的长度
{
    vectorp;//存放当前可用的数
    vectorq;//存放所求排列,用vector主要是觉得比较方便
    for(int i=1;i<=n;i++)
        p.push_back(i)//将全部能用的数存储进去
    for(int i=n;i>=1;i++){
      int a=k%(i-1)!;//即减去第一位的个数后剩余的个数
      int b=k/(i-1)!;//第一位是由后面的个数的阶乘来乘没出现的元素里比它小的个数,除以阶乘,既可以求出在它后面比它小的有多少个了
        k=a;
        sort(p.begin(),p.end());
        q.push_back(p[b])//因为p是从零开始,所以不需要加一
        p.erase(p.begin()+b);//删去使用过的数
    }
}

言归正传,接下来用康托展开去重(也可以用map),外加bfs做这道题

代码

#include
using namespace std;
typedef long long ll;
int dx[]={1,0,0,-1};
int dy[]={0,1,-1,0};
int st[9];
int goal[]={1,2,3,8,0,4,7,6,5};
int fuc[]={1,1,2,6,24,120,720,5040,40320,362880};
int mp[1000000];
struct node{
	int sum[9];
	ll step;
};
bool cantor(int a[]){
	ll ans=0;
	for(int i=0;i<9;i++){
		int z=0;
		for(int j=i+1;j<9;j++)
		if(a[j]p;
ll bfs(){
	node t;
	memcpy(t.sum,st,sizeof(t.sum));
	t.step=0;
	cantor(st);
if(memcmp(t.sum,goal,sizeof(goal))==0)//特判起点即为终点时
			return t.step;
	p.push(t);
	while(!p.empty()){
	 t=p.front();
		p.pop();
		int base;
		for(base=0;base<9;base++){
			if(t.sum[base]==0)
			break;
		}//将一维转化为二维 
		int x=base%3;//横坐标 
		int y=base/3;//纵坐标 
		for(int i=0;i<4;i++){
			int nx=x+dx[i];//元素0转移后的新坐标 
			int ny=y+dy[i];
			if(nx<0||nx>2||ny<0||ny>2)
			continue;
			node h;
			memcpy(&h,&t,sizeof(struct node));//将t复制给h;
			swap(h.sum[y*3+x],h.sum[ny*3+nx]);//这样改变的是h里的值,t的值并未改变。 至于y*3+x是将二维转化为一维 
			h.step++;
			if(memcmp(h.sum,goal,sizeof(goal))==0)
			return h.step;
			if(cantor(h.sum))//只有之前没出现的才压入队列 
			p.push(h); 
		}
	}
	return -1;
}
int main(){
	ll x,k=8;
	cin>>x;
	while(x){
	st[k--]=x%10;
	x/=10;	
	}
	ll anss=bfs();
	cout<

二、双向bfs

同时从起点和终点向对方做bfs,将在中间的某个位置相遇,此时即得到了最优路径。双向广搜的应用场合是知道起点,终点,并且正向和逆向都能进行搜索。

#include
using namespace std;
typedef long long ll;
int dx[]={1,0,0,-1};
int dy[]={0,1,-1,0};
int st[9];
int goal[]={1,2,3,8,0,4,7,6,5};
int fuc[]={1,1,2,6,24,120,720,5040,40320,362880};
int mp[10000000];
int mq[10000000];
struct node{
	int s[9];
	int step;
};
queuep;
queueq;
ll cantor(int a[]){
	ll ans=0;
	for(int i=0;i<9;i++){
		int z=0;
		for(int j=i+1;j<9;j++)
		if(a[j]2||ny<0||ny>2)
			continue;
			node h;
			memcpy(&h,&t,sizeof(struct node));
			swap(h.s[y*3+x],h.s[ny*3+nx]);
			++h.step;
			ll sum=cantor(h.s);
			if(!mp[sum]){
				p.push(h);
				mp[sum]=h.step;
			}
			if(mp[sum]&&mq[sum]){
				return mp[sum]+mq[sum];
			}
			
		}
		}
		else{
			t2=q.front();
			q.pop();
				for(int i=0;i<9;i++){
	           if(t2.s[i]==0)
	               z2=i;
               	}
				 int x2=z2%3;
	             int y2=z2/3;	
			for(int i=0;i<4;i++){
				int nx=x2+dx[i];
				int ny=y2+dy[i];
			if(nx<0||nx>2||ny<0||ny>2)
			continue;
			node h;
			memcpy(&h,&t2,sizeof(struct node));
			swap(h.s[y2*3+x2],h.s[ny*3+nx]);
			h.step++;
			ll sum=cantor(h.s);
			if(!mq[sum]){
				q.push(h);
				mq[sum]=h.step;
			}
			if(mp[sum]&&mq[sum]){
				return mp[sum]+mq[sum];
			} 
			
		}
		}
	}
}
int main(){
	int x,k=8;
	cin>>x;
	while(x){
		st[k--]=x%10;
		x/=10;
	}
	ll anss=bfs();
	cout<

三、A*算法

在搜索过程中,用一个评估函数对当前情况进行评估,得到最好的状态,从这个状态继续搜索,直到目标。设x是当前所在状态,f(x)是对x的评估函数,有 f(x)=g(x)+h(x)

g(x):表示从初始状态到现在状态(x)的代价;

h(x):表示从现在状态(x)到终点的最优路径的评估。(abs(a.x-x2)+abs(a.y-y2))*10;(曼哈顿距离,x2,y2表示终点坐标。a表示当前点)

A*算法的具体步骤:

1.把起点加入openlist(开启列表,一般是一个优先队列)

2.遍历openlist ,找到F值最小的节点,把它作为当前处理的节点,并把该节点加入closelist(关闭列表,可以开个数组表示)中

3.对该节点的8个相邻格子进行判断,如果格子是不可抵达的或者在closelist中,则忽略它,否则如下操作:

a. 如果相邻格子不在openlist中,把它加入,并将parent设置为该节点和计算f,g,h值

b.如果相邻格子已在openlist中,并且新的G值比旧的G值小,则把相邻格子的parent设置为该节点,并且重新计算f值。

重复2,3步,直到终点加入了openlist中,表示找到路径;或者openlist空了,表示没有路径。

最后从目标格开始,沿着每一格的父节点移动直到回到起始格,这就是路径。

#include
using namespace std;
typedef long long ll;
int dx[]={1,0,0,-1};
int dy[]={0,1,-1,0};
int goal[]={1,2,3,8,0,4,7,6,5};
int fuc[]={1,1,2,6,24,120,720,5040,40320,362880};
int st[9];
int vis[1000000];//关闭列表 
int po[1000000];
struct node{
	int step;
	int f;
	int s[9];
	bool operator < (const node &x) const {  //在优先队列里按f的大小排序 
        return f > x.f;        
    } 
};
struct hh{
	int x;
	int y;
}mp[10000];
priority_queueq;//开启列表 
ll cantor(int a[]){
	ll ans=0;
	for(int i=0;i<9;i++){
		int k=0;
		for(int j=i+1;j<9;j++){
			if(a[i]>a[j])
			k++;
		}
		ans+=k*fuc[8-i];
	}
	return ans;
}
//启发函数h为所有数字离正确位置的曼哈顿距离.
ll h(int cur[]){
	int res = 0;
	for (int i = 0; i < 9; i ++ ){
		if (goal[i] != cur[i] && goal[i] != 0) res++;
	}
	return res;
}
ll axing(){
	node t;
	t.step=0;
	memcpy(t.s,st,sizeof(st));
    t.f=h(t.s);
    q.push(t);
    vis[cantor(t.s)]=1;
	while(!q.empty()){
		t=q.top();
		q.pop();
		if(memcmp(t.s,goal,sizeof(goal))==0)
			return t.step;
		int z;
		for(int i=0;i<9;i++){
			if(t.s[i]==0)
				z=i;
		}
		int x=z%3;
		int y=z/3;
		for(int i=0;i<4;i++){
			int nx=x+dx[i];
			int ny=y+dy[i];
			if(nx<0||nx>2||ny<0||ny>2)
			continue;
			node he;
			memcpy(&he,&t,sizeof(struct node));
			swap(he.s[y*3+x],he.s[ny*3+nx]);
			ll sum=cantor(he.s);
			if(!vis[sum]||(vis[sum]&&(he.step+1)>x;
	while(x){
		st[k--]=x%10;
		x/=10;
	}	
	for(int i=0;i<9;i++){
		int xx=i%3;
		int yy=i/3;
		mp[goal[i]].x=xx;
		mp[goal[i]].y=yy;
	}
	ll anss=axing();
	cout<

你可能感兴趣的:(算法)