广度优先搜索+队列 5211. 概率最大的路径

5211. 概率最大的路径
      给你一个由 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
每两个节点之间最多有一条边

思路

1. 在比赛中用dfs深度优先搜索直接超时了，最后结果是采用广度优先+队列
   使用邻接矩阵存储结点之间的权值，使用队列进行广度优先遍历，并使用一个辅助数组保存经过每个结点的最大值，遍历完成后直接根据要求的终点结点返回辅助数组中的值。

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {

            unordered_map<int,unordered_map<int,double>> graph;//邻接矩阵存储权值
            int i = 0;
            for(auto edge:edges)
            {
                graph[edge[0]][edge[1]] = graph[edge[1]][edge[0]] = succProb[i++];
            }

            //bfs
            queue<pair<int,double>> q;
            vector<double> prob(n,0);
            q.push(pair(start,1));
            while(!q.empty())
            {
                auto [cur,p] = q.front();
                q.pop();
                if(p > prob[cur])
                {
                    prob[cur] = p;
                    for(auto next:graph[cur])
                    {
                        q.push(pair(next.first,p*next.second));
                    }
                }
            }
            return prob[end];

    }
};