Path with Maximum Probability

Path with Maximum Probability - Problem

You are given an undirected weighted graph of n nodes (0-indexed), represented by an edge list where edges[i] = [a, b] is an undirected edge connecting the nodes a and b with a probability of success of traversing that edge succProb[i].

Given two nodes start and end, find the path with the maximum probability of success to go from start to end and return its success probability.

If there is no path from start to end, return 0. Your answer will be accepted if it differs from the correct answer by at most 1e-5.

Input & Output

Example 1 — Basic Graph

$ Input: n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2

› Output: 0.25000

💡 Note: Two paths exist: 0→2 (probability 0.2) and 0→1→2 (probability 0.5×0.5=0.25). Maximum is 0.25.

Example 2 — No Direct Path

$ Input: n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2

› Output: 0.30000

💡 Note: Two paths: 0→2 (probability 0.3) and 0→1→2 (probability 0.5×0.5=0.25). Maximum is 0.3.

Example 3 — No Path Available

$ Input: n = 4, edges = [[0,1],[2,3]], succProb = [0.5,0.5], start = 0, end = 3

› Output: 0.00000

💡 Note: Nodes 0 and 3 are in different connected components, so no path exists.

Constraints

2 ≤ n ≤ 10⁴
0 ≤ start, end < n
start ≠ end
0 ≤ edges.length ≤ 2 * 10⁴
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
0 < succProb[i] ≤ 1

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use Dijkstra's algorithm but maximize probability instead of minimizing distance. Use a max-heap to always explore the most promising path first. Best approach is Dijkstra with Max-Heap: Time: O((V+E) log V), Space: O(V+E)

Common Approaches

✓ DFS with Path Exploration

⏱️ Time: O(n!) Space: O(n)

Use depth-first search to explore every possible path from start to end. For each path, calculate the probability by multiplying edge probabilities. Keep track of the maximum probability found.

Dijkstra's Algorithm with Max-Heap

⏱️ Time: O((V + E) log V) Space: O(V + E)

Apply Dijkstra's shortest path algorithm but modified to find maximum probability instead of minimum distance. Use a max-heap (priority queue) to always explore the most promising path first.

DFS with Path Exploration — Algorithm Steps

Build adjacency list from edges
Use DFS to explore all paths
Track visited nodes to avoid cycles
Calculate probability for each complete path

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at start node with probability 1.0

Explore Paths

Visit each neighbor and multiply probabilities

Find Maximum

Return highest probability path found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

struct Edge {
    int node;
    double prob;
    struct Edge* next;
};

struct Edge* graph[10001];
int visited[10001];

double dfs(int node, int target, double prob) {
    if (node == target) return prob;

    visited[node] = 1;
    double maxProb = 0;

    struct Edge* edge = graph[node];
    while (edge) {
        if (!visited[edge->node]) {
            double result = dfs(edge->node, target, prob * edge->prob);
            if (result > maxProb) maxProb = result;
        }
        edge = edge->next;
    }

    visited[node] = 0;
    return maxProb;
}

double solution(int n, int edges[][2], double* succProb, int edgeCount, int start, int end) {
    for (int i = 0; i < n; i++) { graph[i] = NULL; visited[i] = 0; }

    for (int i = 0; i < edgeCount; i++) {
        int a = edges[i][0], b = edges[i][1];
        struct Edge* e1 = malloc(sizeof(struct Edge));
        e1->node = b; e1->prob = succProb[i]; e1->next = graph[a]; graph[a] = e1;
        struct Edge* e2 = malloc(sizeof(struct Edge));
        e2->node = a; e2->prob = succProb[i]; e2->next = graph[b]; graph[b] = e2;
    }

    return dfs(start, end, 1.0);
}

int main() {
    char buf[100000];

    // Line 1: n
    fgets(buf, sizeof(buf), stdin);
    int n = atoi(buf);

    // Line 2: edges [[a,b],[c,d],...]
    fgets(buf, sizeof(buf), stdin);
    int edges[10000][2], edgeCount = 0;
    int depth = 0, vals[2], vc = 0;
    for (char* p = buf; *p; p++) {
        if (*p == '[') { depth++; if (depth == 2) vc = 0; }
        else if (*p == ']') {
            if (depth == 2) { edges[edgeCount][0] = vals[0]; edges[edgeCount][1] = vals[1]; edgeCount++; }
            depth--;
        } else if (depth == 2 && (isdigit(*p) || (*p == '-' && isdigit(*(p+1))))) {
            vals[vc++] = atoi(p);
            while (*p && (isdigit(*p) || *p == '-')) p++;
            p--;
        }
    }

    // Line 3: succProb [0.5,0.5,...]
    fgets(buf, sizeof(buf), stdin);
    double succProb[10000];
    int probCount = 0;
    for (char* p = buf; *p; p++) {
        if (isdigit(*p) || (*p == '.' && isdigit(*(p+1))) || (*p == '-' && (isdigit(*(p+1)) || *(p+1) == '.'))) {
            succProb[probCount++] = atof(p);
            while (*p && (isdigit(*p) || *p == '.')) p++;
            p--;
        }
    }

    // Line 4: start
    fgets(buf, sizeof(buf), stdin);
    int start = atoi(buf);

    // Line 5: end
    fgets(buf, sizeof(buf), stdin);
    int end = atoi(buf);

    double result = solution(n, edges, succProb, edgeCount, start, end);
    printf("%.5f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, explores all possible permutations of nodes

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth and visited array

✓ Linear Space

67.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS with Path Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler