A*算法实现

原创已于 2025-08-30 16:01:42 修改 · 870 阅读

15 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

LeetCode刷题笔记

图论

于 2025-02-21 18:03:58 首次发布

题目：

在象棋中，马和象的移动规则分别是“马走日”和“象走田”。现给定骑士的起始坐标和目标坐标，要求根据骑士的移动规则，计算从起点到达目标点所需的最短步数。

骑士移动规则如图，红色是起始位置，黄色是骑士可以走的地方。
在这里插入图片描述

棋盘大小 1000 x 1000（棋盘的 x 和 y 坐标均在 [1, 1000] 区间内，包含边界）

输入描述

第一行包含一个整数 n，表示测试用例的数量。

接下来的 n 行，每行包含四个整数 a1, a2, b1, b2，分别表示骑士的起始位置 (a1, a2) 和目标位置 (b1, b2)。

输出描述

输出共 n 行，每行输出一个整数，表示骑士从起点到目标点的最短路径长度。

输入示例

输出示例

思路：

创建移动二维数组
设计小顶堆，并在优先队列中利用小顶堆将f值最小的节点排到堆顶
计算启发式函数h
代价函数f = 实际距离g + 启发距离h。每次从优先队列中选择f值最小的节点进行扩展。
遍历邻接节点并计算f值，将将邻接节点加入到优先队列中

代码：

#include<iostream>
#include<queue>
#include<string.h>

using namespace std;

int moves[1001][1001];  //  记录从起点到达目标点所需步数
int dirs[8][2] = {{-1, 2}, {1, 2}, {-2, 1}, {2, 1}, {-2, -1}, {-1, -2}, {1, -2}, {2, -1}};   //  马走日

int b1, b2;

class Point{
public:
    int x, y;
    int g, h, f;
};

//  小顶堆，将f值最小的元素排到堆顶
class MyComparison{
public:
    bool operator()(const Point& a, const Point& b){
        return a.f > b.f;
    }
};

//  优先队列
priority_queue<Point, vector<Point>, MyComparison> que;

//  计算启发距离h
int distance(const Point& cur){
    return (cur.x - b1) * (cur.x - b1) + (cur.y - b2) * (cur.y - b2);
}

//  A*算法实现
void aStar(const Point& start){
    Point curNode, nextNode;
    que.push(start);
    
    while(!que.empty()){
        curNode = que.top(); que.pop();
        if(curNode.x == b1 && curNode.y == b2) break;   //  到达终点，返回
        
        //  遍历临近节点
        for(const auto& dir : dirs){
            nextNode.x = curNode.x + dir[0];
            nextNode.y = curNode.y + dir[1];
            
            if(nextNode.x < 1 || nextNode.x > 1000 || nextNode.y < 1 || nextNode.y > 1000) continue;
            
            if(!moves[nextNode.x][nextNode.y]){ //  如果没扩展过，moves为0，所以不用visited标记了
                moves[nextNode.x][nextNode.y] = moves[curNode.x][curNode.y] + 1;
                
                //  开始计算f
                nextNode.g = curNode.g + 5;  //  统一不开根号，马走日，1 * 1 + 2 * 2 = 5
                nextNode.h = distance(nextNode);
                nextNode.f = nextNode.g + nextNode.h;
                que.push(nextNode);
            }
        }
    }
}

int main(){
    
    int n, a1, a2;
    cin >> n;
        
    while(n--){
        cin >> a1 >> a2 >> b1 >> b2;
        memset(moves, 0, sizeof(moves));    //  初始化为0
        Point start;
        start.x = a1;
        start.y = a2;
        start.g = 0;
        start.h = distance(start);
        start.f = start.g + start.h;
        aStar(start);
        while(!que.empty()) que.pop();    //  队列清空，防止影响下一组数据
        cout << moves[b1][b2] << endl;
    }
    
    return 0;
}