#743 网络延迟时间

class Solution {
public:
    struct cmpNode //仿函数
    {
        bool operator()(pair<int, int>& a, pair<int, int>& b) 
        {
            return a.second > b.second;//最小堆的比较函数
        }
    };

    vector<int> dijkstra(int k,   vector<vector<int>> graph)
    {
        const int inf = INT_MAX ;
        if(graph.size()==0) return vector<int>(1,inf);
        vector<int> dp(graph[0].size(),inf);
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmpNode> pque;
        dp[k-1]=0;
  
        pque.push(pair<int,int>(--k,0));//放入队列的是节点，和从起点到这个节点的距离,注意这里是--k，如果是后置++，放进去的就是没有减之前的了
        int cycle_cout=0;
    //BFS层级遍历
        while(!pque.empty())
        {   
            
            cout<<"cycle_cout"<<cycle_cout++<<endl;
            pair<int, int> cur=pque.top();//访问最开始的元素
            int id=cur.first;
            pque.pop();//弹出队头元素
            int dist=cur.second;
            cout<<"id:"<<id<<endl;
            cout<<"dist:"<<dist<<endl;
            //剔除加入堆中路径长的重复节点
            if(dist>dp[id])
                continue;

           
                
            
            for(int j=0;j<graph[id].size(); ++j)
            {
                if(graph[id][j]==inf)
                {
                    continue;
                }
                int next_id=j;
                int next_dist=graph[id][j];
                cout<<"next_id:"<<next_id<<endl;
                cout<<"next_dist:"<<next_dist<<endl;
                if((dist+next_dist)<dp[next_id])
                {
                    dp[next_id]=dist+next_dist;//更新dp的最小值用来，用来剔除放入队列中重复但是距离远的节点
                    pque.push(pair<int,int>(next_id,next_dist+dist));//我放入队列的一定是从源点到当前节点的距离
                    
                }
                for(auto i:dp)
                    cout<<"dp:"<<i<<endl;
            }
        }
        
        return dp;
    }


 
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        
        if(times.empty()) return -1;
        const int inf = INT_MAX ;
        //首先要建立图，用邻接矩阵表示
        vector<vector<int>> graph(n,vector<int>(n,inf));

        for(vector<int> time:times)//这里只是存放连接关系，不可能越界了
        {
            
            graph[time[0]-1][time[1]-1]=time[2];//顶点从1开始计数，放入vector时手动-1
        }
        for(int i=0; i<graph.size();++i)
            {
                for(int j=0; j<graph[0].size();++j)
                    cout<<graph[i][j]<<"    ";
                    cout<<endl;
            }
            
        cout<<"OK"<<endl;
        vector<int> scores=dijkstra(k,  graph);

        // 找到最长的那一条最短路径
        if(scores.size()==0) return -1;
         
        int max=scores[0];
        for(int index=1;index<scores.size();++index) 
       {
           if(max<scores[index])
                max=scores[index];
       }

       return max==inf?-1:max;
    }
};