记一个BUG

其实如果老老实实按照之前的套路写本来不会有BUG的，只能说手欠这次写的时候想用指针写一下，然后就寄了
用指针出BUG主要原因还是在更新dis的时候破坏了优先队列的结构

• 指针BUG代码

#include<bits/stdc++.h>
using namespace std;
struct Node{
    int id;
    vector<Node*>can_go;
    vector<int>len;
    int dis=INT32_MAX;//到start的距离  
    int pre_node;//路径上之前的节点  
    bool if_visit=false;
    Node(const int&id){
        this->id=id;
    }
    bool operator<(const Node&b){
        return this->dis<b.dis;
    }
};
struct CompareNode{
    bool operator()(Node*a,Node*b){
        return a->dis>b->dis;
    }
};
int main(){
    int node_num,edge_num,start;
    cin>>node_num>>edge_num>>start;
    vector<Node*>nodes;
    for(int i=0;i<=node_num;i++){
        nodes.push_back(new Node(i));
    }
    for(int i=0;i<edge_num;i++){
        int a,b,c;
        cin>>a>>b>>c;
        nodes[a]->can_go.push_back(nodes[b]);
        nodes[a]->len.push_back(c);
    }
    nodes[start]->dis=0;
    nodes[start]->pre_node=start;
    priority_queue<Node*,vector<Node*>,CompareNode>q;
    q.push(nodes[start]);
    while(!q.empty()){
        Node*now=q.top();
        q.pop();
        if(now->if_visit){
            continue;
        }
        now->if_visit=true;
        for(int i=0;i<now->can_go.size();i++){
            if(now->dis+now->len[i]<now->can_go[i]->dis){
                now->can_go[i]->dis=now->len[i]+now->dis;
                now->can_go[i]->pre_node=now->id;
                q.push(now->can_go[i]);
            }
        }
    }
    int sum=0;
    for(int i=1;i<=node_num;i++){
        cout<<nodes[i]->dis<<" ";
    }
    cout<<endl;
}

• 正确版本模板

#include<bits/stdc++.h>
using namespace std;
struct Node{
    int id;
    int dis;
    Node(const int&id,const int&dis=INT32_MAX){
        this->id=id;
        this->dis=dis;
    }
    Node(){};
    bool operator<(const Node&other)const{
        return this->dis<other.dis;
    }
};
struct Edge{
    int start,end,len;
    Edge(const int&start,const int&end,const int&len){
        this->start=start;
        this->end=end;
        this->len=len;
    }
    Edge(){

    }
};
struct CompareNode{
    bool operator()(const Node&a,const Node&b){
        return a.dis>b.dis;
    }
};
class Dijstra{
    public:
    int node_num,edge_num,start;
    vector<int>dis;
    vector<int>pre_node;
    vector<bool>if_visit;
    vector<vector<Edge>>edges;
    Dijstra(const int&node_num,vector<vector<Edge>>edges,const int&start){
        this->node_num=node_num;
        this->edge_num=edges.size();
        this->start=start;
        this->edges=edges;
        this->dis=vector<int>(node_num+1,INT32_MAX);
        this->pre_node=vector<int>(node_num+1,0);
        this->if_visit=vector<bool>(node_num+1,false);
    }
    void dijstra(){
        priority_queue<Node,vector<Node>,CompareNode>pq;
        pq.push(Node(start,0));
        dis[start]=0;
        while(!pq.empty()){
            Node now=pq.top();
            pq.pop();
            if(if_visit[now.id]){
                continue;
            }
            if_visit[now.id]=true;
            for(int i=0;i<edges[now.id].size();i++){
                int to_id=edges[now.id][i].end;
                if(now.dis+edges[now.id][i].len<dis[to_id]){
                    dis[to_id]=now.dis+edges[now.id][i].len;
                    pre_node[to_id]=now.id;
                    pq.push(Node(to_id,dis[to_id]));
                }
            }
        }
    }
};
int main(){
    int node_num,edge_num,start;
    cin>>node_num>>edge_num>>start;
    vector<vector<Edge>>edges=vector<vector<Edge>>(node_num+1,vector<Edge>(0));
    for(int i=0;i<edge_num;i++){
        int a,b,c;
        cin>>a>>b>>c;
        edges[a].push_back(Edge(a,b,c));
    }
    Dijstra dij=Dijstra(node_num,edges,start);
    dij.dijstra();
    for(int i=1;i<dij.dis.size();i++){
        cout<<dij.dis[i]<<" ";
    }
    cout<<endl;
}