A与IDA算法学习笔记

阿华咸

于 2021-01-25 22:21:12 发布

阅读量579

点赞数

分类专栏： ACM学习文章标签：算法

本文链接：https://blog.csdn.net/weixin_49082066/article/details/113121111

版权

ACM学习专栏收录该内容

14 篇文章 1 订阅

订阅专栏

A*

简介

A*搜索算法（英文：A*search algorithm，A*读作 A-star），简称 A*算法，是一种在图形平面上，对于有多个节点的路径求出最低通过成本的算法。它属于图遍历（英文：Graph traversal）和最佳优先搜索算法（英文：Best-first search），亦是 BFS 的改进。

定义起点 $s$ ，终点 $t$ ，从起点（初始状态）开始的距离函数 $g (x)$ ，到终点（最终状态）的距离函数 $h (x)$ ， $h^{'} (x)$ ，以及每个点的估价函数 $f (x) = g (x) + h (x)$ 。

A*算法每次从优先队列中取出一个 $f$ 最小的元素，然后更新相邻的状态。

如果 $\leq h'$ ，则 A*算法能找到最优解。

上述条件下，如果 $h$ 满足三角形不等式，则 A*算法不会将重复结点加入队列。且 $h$ 越大，效果越好，当然，如果 $h$ 过大的话可能会直接跳过最优解。

当 $h = 0$ 时，A*算法变为 DFS ；当 $h = 0$ 并且边权为 $1$ 时变为 BFS。

典型例题（15数码)

15 puzzle

思路分析

首先通过分析我们可以知道，使用 $b f s$ 或者是普通的 $d f s$ 剪枝肯定会TLE，所以考虑A*，我们先把普通的状态搜索 $b f s$ 的板子打出来。这里定义两类结构体 $M a t r i x$ 和 $S t a t e$ ， $M a t r i x$ 结构体是普通 $b f s$ 板子中的状态量结点，这里我们给它增加一个权值 $e s t$ ，表示一个预估量，预估的是从当前结点到目标状态所需的最小步数。 $S t a t e$ 结构体总共有两个成员： $M a t r i x$ 和 $e s t$ ；它的作用是在出队入队操作时作为一个标准。因为 A*的剪枝策略实际上时对 起点到当前位置的成本+当前位置到目标状态的推测值 的最小值进行优先选择，所以原先 $b f s$ 中的队列要改成堆式结构，也就是优先队列，这里就是对 $S t a t e$ 进行操作了。具体实现见下方代码。

Codes (A*)

#include<bits/stdc++.h>
using namespace std;
typedef struct Matrix{   //存16宫格的棋型
	    int x,y; //0所在的坐标
        int cost; //状态迭代过程中的实际花费
	    int f[17];  //将二维宫格用一维序列存储
	    int est;  //表示此棋型号还需至少est步才能到达目标状态
	    bool operator < (const Matrix &k) const{
	    	 for (int i=1; i<=16; i++)
	    	     if (f[i]==k.f[i]) continue;
	    	     else
	    	        return f[i]>k.f[i];
	    	  return false;
		}
};

typedef struct State{    //搜索过程中的状态结点
	    Matrix u;  //该状态16宫格的具体内容
	    int est;  //预计该状态总共至少还剩est步才能到达目标
	    bool operator < (const State &s) const{
		     return est>s.est;
		}
};

int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};

int main(){
    priority_queue<State> q;
    map<Matrix,bool> vis;  //表示每个棋型状态是否到达过
    int x,cnt=0,cost_sum=0;
    int estimate[25][25][25]={0}; //estimate[i][j][k]表示从位置(i,j)到目标答案中k所在位置的曼哈顿距离
    
    for (int i=0; i<=15; i++){
   	   for (int j=1; j<=16; j++){
   	       if (i==0){
   	          if (j%4!=0){
   	             estimate[(j-1)/4+1][j%4][0]=abs((j-1)/4+1-4)+abs(j%4-4);	
			  }
			  else{
			  	 estimate[j/4][4][0]=abs(j/4-4)+abs(4-4);
			  }	
		   }
		   else{
		   	  if (j%4!=0){
		   	  	 if (i%4!=0){
		   	  	    estimate[(j-1)/4+1][j%4][i]=abs((j-1)/4+1-(i-1)/4-1)+abs((j%4-i%4));	
				  }
				  else{
				  	 estimate[(j-1)/4+1][j%4][i]=abs((j-1)/4+1-i/4)+abs(j%4-4);
				  }
			  }
			  else{
			  	 if (i%4!=0){
		   	  	    estimate[j/4][4][i]=abs(j/4-(i-1)/4-1)+abs(4-i%4);	
				  }
				  else{
				  	 estimate[j/4][4][i]=abs(j/4-i/4)+abs(4-4);
				  }
			  }
		   }	
	   }
   }
   
	Matrix uu;       
	for (int i=1; i<=4; i++)
	   for (int j=1; j<=4; j++){
	   	   scanf("%d",&x);  //读入初始的每个棋盘位置上的值
	   	   if (x==0)
	   	      uu.x=i,uu.y=j;
	   	   uu.f[++cnt]=x;
	   }

	for (int i=1; i<=16; i++){  //统计初始状态所有需要的est值
		if (i%4!=0){
			cost_sum+=estimate[(i-1)/4+1][i%4][uu.f[i]];
		}
		else{
			cost_sum+=estimate[i/4][4][uu.f[i]];
		}
	}
    State start; //定义初始状态start
	start.est=uu.est=cost_sum;
	start.u=uu;
	q.push(start);
	vis[start.u]=1; start.u.cost=0;
	while (!q.empty()){   //用bfs进行搜索
		  State u=q.top(); q.pop();
		  Matrix uu=u.u,u1;
		  if (uu.est==0){ //如果预计还需0步（也就是已经到了目标状态了），输出实际花费，退出。
		  	 cout<<uu.cost<<endl;
		  	 return 0;
		  }
		  vis[uu]=1; //标记状态uu已经访问过
		  int x1,y1;
		  for (int i=0; i<4; i++){
		  	  u1=uu; //建立新状态u1
		  	  x1=uu.x+dx[i]; y1=uu.y+dy[i];
		  	  if (x1>=1 && x1<=4 && y1>=1 && y1<=4){ //如果(x1,y1)可以移动到0所在位置
		  	  	 /*更新u1状态的总est*/
                 u1.est+=estimate[x1][y1][0]-estimate[uu.x][uu.y][0]+estimate[uu.x][uu.y][uu.f[(x1-1)*4+y1]]-estimate[x1][y1][uu.f[(x1-1)*4+y1]];
				 int tmp;
				 tmp=u1.f[(uu.x-1)*4+uu.y];
				 u1.f[(uu.x-1)*4+uu.y]=u1.f[(x1-1)*4+y1];
				 u1.f[(x1-1)*4+y1]=tmp;
				 //=uu.f[(x1-1)*4+y1];
                 u1.x=x1; u1.y=y1;
				 if (vis[u1]!=1){
				 	u1.cost++;
				 	State news;
				 	news.est=u1.est+u1.cost;
				 	news.u=u1;
				 	q.push(news);
				 }
			  }
		  }
	}
	return 0;
}