圖論——迪傑斯特拉演算法（Dijkstra）實現，leetcode

阿新 • • 發佈：2020-09-16

迪傑斯特拉演算法（Dijkstra）：求一點到另外一點的最短距離

兩種實現方法：

鄰接矩陣，時間複雜度O(n^2)

鄰接表+優先佇列，時間複雜度O(mlogn)（適用於稀疏圖）

（n：圖的節點數，m：圖的邊數）

(參考https://leetcode-cn.com/problems/path-with-maximum-probability/solution/gai-lu-zui-da-de-lu-jing-by-leetcode-solution/)

leetcode經典例題：

（1）

743. 網路延遲時間

https://leetcode-cn.com/problems/network-delay-time/

鄰接矩陣，時間複雜度O(n^2)

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        vector<int> visit(N,0);
        vector<vector<int>> d(N, vector<int>(N,INT_MAX));
        for(auto& t:times)
        {
            d[t[0]-1 
][t[1]-1] = t[2];
        }
        if(N==1)
        return 0;

        int result=-1;

        visit[K-1] = 1;
        for(int i=0;i<N-1;i++)
        {
            int k, min_v = INT_MAX;
            for(int j=0;j<N;j++)
            {;
                if(visit[j]==0 && d[K-1][j]<min_v) 
                {
                    min_v  
= d[K-1][j];
                    k = j;
                }
            }
            if(min_v == INT_MAX)
            {
                result = -1;
                break;
            }

            if(min_v >result)
            result = min_v;
            
            visit[k] = 1;
            for(int j=0;j<N;j++)
            {
                //cout<<"second j:"<<j<<endl;
                if(visit[j]==0 && d[k][j]!=INT_MAX)
                {
                    if(d[K-1][j] > d[K-1][k]+d[k][j])
                    d[K-1][j] = d[K-1][k]+d[k][j];
                }
            }

        }
        
        return result;
    }
};

（2）

1514. 概率最大的路徑

https://leetcode-cn.com/problems/path-with-maximum-probability/鄰接表+優先佇列，時間複雜度O(mlogn)

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
        vector<int> visit(n,0);
        vector<vector<pair<double, int>>> neighbor(n);
        for(int i=0;i<edges.size();i++)
        {
            neighbor[edges[i][0]].push_back({succProb[i], edges[i][1]});
            neighbor[edges[i][1]].push_back({succProb[i], edges[i][0]});
        }
        vector<double> d(n,0);
        d[start] = 1;

        typedef pair<double,int> P;
        priority_queue<P, vector<P>, less<P>> q; //最大堆，因為是要求概率值最大，如果是路徑最短，應該用最小堆
        q.push({1,start});
        while(!q.empty())
        {
            auto t = q.top();
            q.pop();
            if(visit[t.second] == 1)
            continue;


            visit[t.second] = 1;
            for(auto& i:neighbor[t.second])
            {
                if(visit[i.second]==0 && d[i.second]< d[t.second]*i.first)
                {
                    d[i.second] = d[t.second]*i.first;
                    q.push({d[i.second], i.second});
                }
            }
        }
        return d[end];
    }
};