2022/2/22 BFS dijestra A * routing algorithm

Posted by cowboy_x on Tue, 22 Feb 2022 14:50:56 +0100

A* search:

Combining BFS and greedy algorithm, it is usually used for game pathfinding. A * is one of the heuristic search algorithms


Like ripples, it spreads out circle by circle, but it doesn't care where the end point is

Breadth first, store the starting point in the queue, add the points that have not been visited up, down, left, right to the queue, and list the starting point. To save the state of a node, you can record the state directly with an array or add a state attribute with a structure.

struct Node
	int x, y;
	int state = 0;
int dir[4][2] = {
};//Lower left and upper right
//int room[9][9]={'.'};
void BFS(int dx, int dy)
	Node start, next;
	queue<Node> q;
	start.x = dx;
	start.y = dy;
	while (!q.empty())
		start = q.front();
		for (int i = 0; i < 4; i++)
			next.x = start.x + dir[i][0];
			next.y = start.y + dir[i][1];
			if (next.x >= 0 && next.x < 9 && next.y >= 0 && next.y < 9&&next.state == 0)
				next.state = 1;

Greedy algorithm:

As close as possible to the target, but it may fall into local optimization (stuck in the corner). A typical dijestra algorithm (take a shortcut, which must be the shortest path)

Save drawing:

There are two common methods for saving drawings:

Adjacency matrix: set the coordinate value of two points connected by one edge to 1; a[n][n];

Adjacency table: array plus vector, vector < edge > e[n], e[n] stores the edge e[n] connected by each point at(i);

Dijkstra's algorithm

1. Start from the starting point and go to the nearest point every time. (at this time, it is locally optimal, and the nearest point is q.top())

2. Go forward from the nearest point. If it is closer than the starting point, update the shortest distance


3. Go back to 1 and find the nearest point

4. Until all points are traversed (the queue is empty)

struct edge
	int to, w;
	edge(int a, int b) { to = a; w = b; }
};//Weight (distance) of the other end of the edge and the edge
vector<edge> e[V];
struct s_node {
	int v, dis;
	s_node(int a, int b) {
		v = a; dis = b;
	}//A structure built solely for the purpose that the priority queue can discharge the point closest to the starting point
	bool operator< (const s_node& a) const
		return dis < a.dis;
void dijkstra(int s)
	int dis[V] = { INF };//The distance from each point except the starting point to the starting point is Inf
	bool done[V] = { false };//At first, none of the points were visited
	dis[s] = 0;
	priority_queue<s_node> q;
	q.push(s_node(s, 0));//Put the starting point into the queue
	while (!q.empty())
		s_node u = q.top(); //u is the point closest to the starting point
           continue;//Card out the points in the queue that are in the back but have updated the shortest distance in front
		done[u.v] = true;//The tag u has been accessed and cannot go back
		for (int i = 0; i < e[u.v].size(); i++)//Traverse each edge
			edge e0 = e[u.v].at(i);//Easy to write at the other end E0 v. Edge weight E0 w
			if (done[e0.to] == false && dis[e0.to] > dis[u.v] + e0.w)//Update shortest distance
				dis[e0.to] = dis[u.v] + e0.w;
				q.push(s_node(e0.to, dis[e0.to]));//Join the queue
                pre[e0.to]=u0.v //Record path

A * algorithm

The expansion of dijestra algorithm knows where the end point is and will not blindly search in breadth.

Differences: greedy from the shortest path to the evaluation function f=g+h; The others are as like as two peas.

g is the distance from the starting point to the current square; h is the distance from the end point to the box (ignoring obstacles). Generally, it is Manhattan distance (horizontal distance plus vertical distance). The distance of walking obliquely is 1.414 times that of walking horizontally.

The code is implemented in resources

reference material:

Detailed explanation: (64 messages) detailed explanation of star a algorithm (I think the most detailed and easy to understand version)_ Colin, CSDN blog_ A-star algorithm

Code details: (64 messages) [introduction to algorithm] a * specific process and implementation of routing algorithm_ Summer CSDN blog_ Design and implementation of a * routing algorithm

Introduction to the a * algorithm (redblobnames. Com)

Teacher's ppt, algorithm book

Topics: Algorithm