Frog Position After T Seconds - Practice Coding Problems

Frog Position After T Seconds - Problem

The Jumping Frog's Probability Adventure!

Imagine a clever frog exploring an undirected tree with n vertices numbered from 1 to n. Our amphibian friend starts at vertex 1 and follows some interesting rules:

Movement Rules:

Each second, the frog jumps to an unvisited adjacent vertex
If multiple unvisited vertices are available, it chooses randomly with equal probability
If no unvisited vertices remain, it stays put forever
The frog never revisits a vertex it has already been to

Given the tree's edges and a target vertex, calculate the probability that after exactly t seconds, our frog friend is sitting on the target vertex.

Goal: Return the probability as a decimal number (answers within 10^-5 of the actual answer are accepted).

Input & Output

example_1.py — Basic Tree

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

› Output: 0.16666666666666666

💡 Note: The frog starts at vertex 1, then jumps to vertex 2 with probability 1/3, then jumps to vertex 4 with probability 1/2. So the probability is 1/3 * 1/2 = 1/6.

example_2.py — Staying at Target

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

› Output: 0.3333333333333333

💡 Note: The frog starts at vertex 1, then jumps to vertex 7 with probability 1/3.

example_3.py — Cannot Reach Target

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

› Output: 0.16666666666666666

💡 Note: The frog reaches vertex 6 at time 2 and stays there (no unvisited neighbors). Since 2 ≤ 20, the probability remains 1/6.

Constraints

1 ≤ n ≤ 100
edges.length == n - 1
edges[i].length == 2
1 ≤ a_i, b_i ≤ n
1 ≤ t ≤ 50
1 ≤ target ≤ n
Answers within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Frog begins at vertex 1 with 100% certainty

Make Random Choices

At each vertex, frog randomly picks from unvisited neighbors

Calculate Path Probability

Multiply choice probabilities: 1/3 × 1/2 = 1/6

Handle Stopping Condition

If no unvisited neighbors remain, frog stays forever

Key Takeaway

🎯 Key Insight: In a tree, there's exactly one path to any target. Calculate probability by multiplying choice probabilities along this unique path, considering timing constraints and staying conditions.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

This problem requires calculating path probabilities in a tree. The optimal approach uses BFS/DFS traversal to find the unique path to the target vertex, computing probabilities based on branching factors at each node. Key insight: since it's a tree, there's exactly one path to any target, and we must handle the staying condition when the frog reaches a dead-end.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS/BFS (Single Pass)	O(n)	O(n)	Use BFS to find path to target and calculate probability in one traversal
Brute Force (All Paths Enumeration)	O(k^t)	O(t)	Recursively explore all possible paths and calculate probabilities

Optimized DFS/BFS (Single Pass) — Algorithm Steps

Build adjacency list representation of the tree
Use BFS to find the unique path from vertex 1 to target
Track the minimum time needed to reach target
Calculate probability by considering choices at each step
Handle the case where frog must stay at target

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS

Start BFS from vertex 1 with probability 1.0

Explore Level by Level

Process each level of the tree, calculating probabilities

Check Target Conditions

When reaching target, verify timing constraints

Return Result

Return probability if conditions met, 0 otherwise

Code -

solution.c — C

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

typedef struct {
    int* neighbors;
    int count;
    int capacity;
} Node;

typedef struct {
    int vertex;
    int time;
    double prob;
} State;

double frogPosition(int n, int** edges, int edgesSize, int* edgesColSize, int t, int target) {
    if (n == 1) {
        return target == 1 ? 1.0 : 0.0;
    }
    
    // Build adjacency list
    Node* graph = malloc((n + 1) * sizeof(Node));
    for (int i = 0; i <= n; i++) {
        graph[i].neighbors = malloc(10 * sizeof(int));
        graph[i].count = 0;
        graph[i].capacity = 10;
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        
        if (graph[u].count == graph[u].capacity) {
            graph[u].capacity *= 2;
            graph[u].neighbors = realloc(graph[u].neighbors, graph[u].capacity * sizeof(int));
        }
        graph[u].neighbors[graph[u].count++] = v;
        
        if (graph[v].count == graph[v].capacity) {
            graph[v].capacity *= 2;
            graph[v].neighbors = realloc(graph[v].neighbors, graph[v].capacity * sizeof(int));
        }
        graph[v].neighbors[graph[v].count++] = u;
    }
    
    // BFS
    State* queue = malloc(1000 * sizeof(State));
    bool* visited = calloc(n + 1, sizeof(bool));
    
    int front = 0, rear = 0;
    queue[rear++] = (State){1, 0, 1.0};
    visited[1] = true;
    
    double result = 0.0;
    
    while (front < rear) {
        State curr = queue[front++];
        
        // Get unvisited neighbors
        int neighborCount = 0;
        for (int i = 0; i < graph[curr.vertex].count; i++) {
            if (!visited[graph[curr.vertex].neighbors[i]]) {
                neighborCount++;
            }
        }
        
        // If no unvisited neighbors
        if (neighborCount == 0) {
            if (curr.vertex == target && curr.time <= t) {
                result = curr.prob;
                break;
            }
            continue;
        }
        
        // If we found target
        if (curr.vertex == target) {
            result = (curr.time == t) ? curr.prob : 0.0;
            break;
        }
        
        // Continue BFS
        if (curr.time < t) {
            double choiceProb = curr.prob / neighborCount;
            for (int i = 0; i < graph[curr.vertex].count; i++) {
                int neighbor = graph[curr.vertex].neighbors[i];
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue[rear++] = (State){neighbor, curr.time + 1, choiceProb};
                }
            }
        }
    }
    
    // Clean up
    for (int i = 0; i <= n; i++) {
        free(graph[i].neighbors);
    }
    free(graph);
    free(queue);
    free(visited);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

BFS visits each vertex at most once, and we process each edge once while building the adjacency list

✓ Linear Growth

Space Complexity

O(n)

Storage for adjacency list and BFS queue, both proportional to number of vertices

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Optimized DFS/BFS (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler