Frog Position After T Seconds

Frog Position After T Seconds - Problem

Given an undirected tree consisting of n vertices numbered from 1 to n. A frog starts jumping from vertex 1.

In one second, the frog jumps from its current vertex to another unvisited vertex if they are directly connected. The frog can not jump back to a visited vertex. In case the frog can jump to several vertices, it jumps randomly to one of them with the same probability. Otherwise, when the frog can not jump to any unvisited vertex, it jumps forever on the same vertex.

The edges of the undirected tree are given in the array edges, where edges[i] = [ai, bi] means that exists an edge connecting the vertices ai and bi.

Return the probability that after t seconds the frog is on the vertex target. Answers within 10^-5 of the actual answer will be accepted.

Input & Output

Example 1 — Basic Tree Navigation

$ Input: n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 2, target = 4

› Output: 0.16666666666666666

💡 Note: Frog starts at 1. At t=1, it chooses between nodes 2,3,7 with probability 1/3 each. If it goes to 2, then at t=2 it chooses between 4,6 with probability 1/2 each. Total probability to reach 4 = (1/3) * (1/2) = 1/6 ≈ 0.1667

Example 2 — Early Arrival Case

$ Input: n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 4, target = 4

› Output: 0.16666666666666666

💡 Note: Frog can reach node 4 at t=2 with probability 1/6. Since node 4 is a leaf (no unvisited neighbors), frog stays there until t=4. Same probability as Example 1.

Example 3 — Impossible Target

$ Input: n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 1, target = 4

› Output: 0.0

💡 Note: Node 4 requires at least 2 steps to reach from node 1 (1→2→4), but we only have t=1 second. Impossible to reach.

Constraints

1 ≤ n ≤ 100
edges.length == n - 1
edges[i].length == 2
1 ≤ a_i, b_i ≤ n
1 ≤ t ≤ 50
1 ≤ target ≤ n

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that the frog can only reach the target at exactly time t, or arrive early and stay there if the target is a leaf node. Best approach uses DFS with early termination to explore all possible paths and calculate probabilities. Time: O(n), Space: O(n)

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

DFS Path Exploration

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

Use depth-first search to explore all possible paths the frog can take. For each path, calculate the probability based on the number of choices at each step. Sum up probabilities for paths that reach the target at exactly time t.

DFS with Early Termination

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

Enhanced DFS approach that calculates the minimum time needed to reach the target and terminates early if it's impossible to reach within the given time limit. Also handles the case where the frog arrives early and must stay at the target.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int graph[101][101];
static int graph_size[101];
static int target;

double dfs(int node, int parent, int time_left) {
    if (time_left == 0) {
        return (node == target) ? 1.0 : 0.0;
    }
    
    // Get unvisited neighbors
    int neighbors[101];
    int neighbor_count = 0;
    
    for (int i = 0; i < graph_size[node]; i++) {
        if (graph[node][i] != parent) {
            neighbors[neighbor_count++] = graph[node][i];
        }
    }
    
    // If no unvisited neighbors, frog stays here
    if (neighbor_count == 0) {
        return (node == target) ? 1.0 : 0.0;
    }
    
    // Probability of reaching target from this state
    double prob = 0.0;
    for (int i = 0; i < neighbor_count; i++) {
        prob += dfs(neighbors[i], node, time_left - 1) / neighbor_count;
    }
    
    return prob;
}

double solution(int n, int edges[][2], int edge_count, int t, int target_val) {
    target = target_val;
    
    // Initialize graph
    for (int i = 0; i <= n; i++) {
        graph_size[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edge_count; i++) {
        int a = edges[i][0];
        int b = edges[i][1];
        graph[a][graph_size[a]++] = b;
        graph[b][graph_size[b]++] = a;
    }
    
    return dfs(1, -1, t);
}

int main() {
    char line[1000];
    
    // Read n
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    // Read edges
    fgets(line, sizeof(line), stdin);
    
    // Parse edges array
    int edges[100][2];
    int edge_count = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++; // Skip [
    
    while (*ptr && *ptr != ']') {
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr == '[') {
            ptr++;
            edges[edge_count][0] = (int)strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ',') ptr++;
            ptr++; // Skip comma
            edges[edge_count][1] = (int)strtol(ptr, &ptr, 10);
            edge_count++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        } else {
            break;
        }
    }
    
    // Read t
    fgets(line, sizeof(line), stdin);
    int t = atoi(line);
    
    // Read target
    fgets(line, sizeof(line), stdin);
    int target_val = atoi(line);
    
    double result = solution(n, edges, edge_count, t, target_val);
    printf("%g\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

15.2K Views

Medium Frequency

~35 min Avg. Time

445 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