Step-By-Step Directions From a Binary Tree Node to Another

Step-By-Step Directions From a Binary Tree Node to Another - Problem

Navigate Through a Binary Tree: Imagine you're exploring a family tree where each person has at most two children. You need to find directions from one person to another!

Given a binary tree with n nodes (each uniquely numbered from 1 to n), find the shortest path from a start node to a destination node. Your directions must be a string using only these moves:

• 'L' - Go to left child
• 'R' - Go to right child
• 'U' - Go up to parent

Goal: Return step-by-step directions as a string of 'L', 'R', and 'U' characters that represents the shortest path from startValue to destValue.

Think of it like GPS navigation through a tree structure - you might need to go up to a common ancestor before going down to your destination!

Input & Output

example_1.py — Basic Tree Navigation

$ Input: root = [5,1,2,3,null,6,4], startValue = 3, destValue = 6

› Output: "UURL"

💡 Note: The shortest path from 3 to 6 is: 3 → 1 (Up) → 5 (Up) → 2 (Right) → 6 (Left). This gives us directions 'UURL'.

example_2.py — Direct Parent-Child

$ Input: root = [2,1], startValue = 2, destValue = 1

› Output: "L"

💡 Note: Node 1 is the direct left child of node 2, so we just need to go left once.

example_3.py — Siblings Navigation

$ Input: root = [1,null,3,2,4], startValue = 2, destValue = 4

› Output: "UR"

💡 Note: From node 2, go up to parent 3, then right to node 4. Path: 2 → 3 (Up) → 4 (Right).

Visualization

Tap to expand

Understanding the Visualization

Map the Routes

Find paths from the city center (root) to both your starting point and destination

Find Common Highway

Identify where the two routes share the same path - this is your common highway (LCA)

Calculate Backtrack

From your start, count how many steps back to the common highway (these become 'U' moves)

Navigate Forward

From the common highway, follow the remaining route to your destination

Key Takeaway

🎯 Key Insight: The shortest path in any tree structure always goes through the Lowest Common Ancestor - there are no shortcuts around this natural highway!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might explore all nodes multiple times to find the path

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to the height of the tree, path storage

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is n where 2 ≤ n ≤ 10⁵
1 ≤ Node.val ≤ n
All values in the tree are unique
startValue != destValue
Both startValue and destValue exist in the tree

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 28 f Meta 22

The optimal approach finds paths from root to both nodes, then removes the common prefix (representing the path to their Lowest Common Ancestor). The remaining start path becomes 'U' moves (going up), and the remaining destination path provides the downward directions. Time complexity: O(n), Space complexity: O(h) where h is tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS Exploration)	O(n²)	O(n)	Try all possible paths using recursive DFS until finding the destination
LCA with Path Reconstruction	O(n)	O(h)	Find Lowest Common Ancestor first, then build paths from LCA to both nodes

Brute Force (DFS Exploration) — Algorithm Steps

Start DFS from the root to find both start and destination nodes
From start node, try all three directions (L, R, U) recursively
Track the current path as we explore
When destination is found, return the accumulated path
Use backtracking to try different routes

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Start Path

DFS from root to find path to start node

Find Dest Path

DFS from root to find path to destination node

Remove Common Prefix

Find where paths diverge (LCA point)

Build Result

Add 'U's for going up, then remaining dest path

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

bool findPath(struct TreeNode* node, int target, char* path, int* pathLen) {
    if (!node) return false;
    if (node->val == target) return true;
    
    path[(*pathLen)++] = 'L';
    if (findPath(node->left, target, path, pathLen)) return true;
    (*pathLen)--;
    
    path[(*pathLen)++] = 'R';
    if (findPath(node->right, target, path, pathLen)) return true;
    (*pathLen)--;
    
    return false;
}

char* getDirections(struct TreeNode* root, int startValue, int destValue) {
    char startPath[1001], destPath[1001];
    int startLen = 0, destLen = 0;
    
    findPath(root, startValue, startPath, &startLen);
    findPath(root, destValue, destPath, &destLen);
    
    int i = 0;
    while (i < startLen && i < destLen && startPath[i] == destPath[i]) {
        i++;
    }
    
    char* result = malloc(2001);
    int idx = 0;
    
    for (int j = 0; j < startLen - i; j++) {
        result[idx++] = 'U';
    }
    
    for (int j = i; j < destLen; j++) {
        result[idx++] = destPath[j];
    }
    
    result[idx] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might explore all nodes multiple times to find the path

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to the height of the tree, path storage

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is n where 2 ≤ n ≤ 10⁵
1 ≤ Node.val ≤ n
All values in the tree are unique
startValue != destValue
Both startValue and destValue exist in the tree

67.2K Views

Medium-High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler