给你一个由 n 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 edges[i] = [a, b] 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 succProb[i] 。

指定两个节点分别作为起点 start 和终点 end ，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。

如果不存在从 start 到 end 的路径，请 返回 0 。只要答案与标准答案的误差不超过 1e-5 ，就会被视作正确答案。

示例 1：

输入：n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
输出：0.25000
解释：从起点到终点有两条路径，其中一条的成功概率为 0.2 ，而另一条为 0.5 * 0.5 = 0.25
示例 2：

输入：n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
输出：0.30000
示例 3：

输入：n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
输出：0.00000
解释：节点 0 和 节点 2 之间不存在路径
 

提示：

2 <= n <= 10^4
0 <= start, end < n
start != end
0 <= a, b < n
a != b
0 <= succProb.length == edges.length <= 2*10^4
0 <= succProb[i] <= 1
每两个节点之间最多有一条边

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-with-maximum-probability
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1、dijkstra算法

标准的dijkstra算法，没有经过优化。测试能通过，但是提交不上去，超过了时间限制，但是思路还是可以的。

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
        if(start == end)
        return 1;
        //把邻接矩阵搞出来
        vector<vector<double>> g(n,vector<double>(n,0));       //设到每个节点的可能性为0
        for(int i = 0 ; i < succProb.size() ; i++)
        {
            vector<int> a = edges[i];
            g[a[0]][a[1]] = succProb[i];
            g[a[1]][a[0]] = succProb[i];
        }
        vector<bool> used(n,false); //已经选取的过的节点
        vector<double> prob(n,0); //用于存储概率
        prob[start] = 1;    //start到自己的概率为最大值1
        for(int i = 0 ; i < n ; i++)
        {
            int x = -1;
            for(int y = 0 ; y < n ; y++)
            {
                if(!used[y]&&(x == -1||prob[y]>prob[x]))     //未被使用过的中找概率最大的
                {
                    x = y;
                }
            }

            //跟新
            used[x] = true;
            for(int y = 0; y < n ; y++)
            {
                prob[y] = max(prob[y],prob[x]*g[x][y]);
            }
        }
        return prob[end];


    }
};

2、优化过后的dijkstra算法——leetcode上的标准答案

普通的 Dijkstra 算法是通过枚举来寻找「未确定节点」中与起点距离最近的点。在实际实现中，我们可以使用优先队列优化这一过程的时间复杂度。

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

        priority_queue<pair<double, int>> que;
        vector<double> prob(n, 0);

        que.emplace(1, start);
        prob[start] = 1;
        while (!que.empty()) {
            auto [pr, node] = que.top();
            que.pop();
            if (pr < prob[node]) {
                continue;
            }
            //这里为什么不要用一个已经观察节点的容器，应为不可能往回走，往回走那么他的值会更加的小
            for (auto& [prNext, nodeNext] : graph[node]) {
                if (prob[nodeNext] < prob[node] * prNext) {
                    prob[nodeNext] = prob[node] * prNext;
                    que.emplace(prob[nodeNext], nodeNext);
                }
            }
        }
        return prob[end];
    }
};