如何在C++中修改Dijkstra算法以适应A*搜索算法

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

class Node {
public:
    int id;        // 节点ID
    int g;         // 起始节点到当前节点的实际代价
    int h;         // 当前节点到目标节点的预估代价
    int f;         // f = g + h，用于比较节点优先级

    Node(int _id, int _g, int _h) : id(_id), g(_g), h(_h), f(_g + _h) {}

    bool operator<(const Node& other) const {
        return f > other.f;    // 用于定义节点的优先级队列
    }
};

// 修改后的Dijkstra算法，适应A*搜索算法
vector<int> aStar(const vector<vector<pair<int, int>>>& graph, int start, int end) {
    int n = graph.size();   // 图中节点的数量

    vector<int> dist(n, INT_MAX);    // 起始节点到各个节点的实际代价
    vector<int> prev(n, -1);         // 记录节点的前驱节点

    priority_queue<Node> pq;   // 优先级队列，按照f值从小到大排序
    pq.emplace(start, 0, 0);
    dist[start] = 0;

    while (!pq.empty()) {
        Node node = pq.top();
        pq.pop();

        int curr = node.id;
        int g = node.g;

        if (curr == end) {
            break;    // 已找到目标节点，退出循环
        }

        if (g > dist[curr]) {
            continue;    // 如果已经有更短的路径到达该节点，则忽略当前节点
        }

        // 遍历当前节点的邻居节点
        for (const auto& neighbor : graph[curr]) {
            int next = neighbor.first;
            int weight = neighbor.second;

            int newG = g + weight;

            if (newG < dist[next]) {
                dist[next] = newG;
                prev[next] = curr;

                int h = /*计算当前节点到目标节点的预估代价*/;   // 根据实际情况计算节点的预估代价

                pq.emplace(next, newG, h);
            }
        }
    }

    // 构建最短路径
    vector<int> path;
    int curr = end;
    while (curr != -1) {
        path.push_back(curr);
        curr = prev[curr];
    }
    reverse(path.begin(), path.end());

    return path;
}

int main() {
    // 构建图的邻接表表示
    vector<vector<pair<int, int>>> graph = {
        {{1, 5}, {2, 3}},          // 节点0的邻居节点及对应的边权重
        {{3, 2}, {4, 3}},          // 节点1的邻居节点及对应的边权重
        {{1, 1}, {3, 9}, {4, 2}},  // 节点2的邻居节点及对应的边权重
        {{4, 2}},                  // 节点3的邻居节点及对应的边权重
        {{3, 1}},                  // 节点4的邻居节点及对应的边权重
    };

    int start = 0;
    int end = 4;

    vector<int> path = aStar(graph, start, end);

    // 输出最短路径
    cout << "Shortest path from " << start << " to " << end << ": ";
    for (int node : path) {
        cout << node << " ";
    }
    cout << endl;

    return 0;
}