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

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

You are given the root of a binary tree with n nodes. Each node is uniquely assigned a value from 1 to n. You are also given an integer startValue representing the value of the start node s, and a different integer destValue representing the value of the destination node t.

Find the shortest path starting from node s and ending at node t. Generate step-by-step directions of such path as a string consisting of only the uppercase letters 'L', 'R', and 'U'. Each letter indicates a specific direction:

'L' means to go from a node to its left child node.
'R' means to go from a node to its right child node.
'U' means to go from a node to its parent node.

Return the step-by-step directions of the shortest path from node s to node t.

Input & Output

Example 1 — Basic Tree Navigation

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

› Output: UURL

💡 Note: Start at node 3, go up to node 1, up to root node 5, then right to node 2, then left to reach node 6. Path: 3→1→5→2→6 gives directions UURL.

Example 2 — Sibling Nodes

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

› Output: UL

💡 Note: Start at node 3 (right child), go up to root node 2, then left to node 1. Simple sibling traversal: 3→2→1 gives UL.

Example 3 — Same Subtree

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

› Output: UURL

💡 Note: From node 3 to node 4: go up to node 1, then up to root 5, then right to node 2, then right to node 4. Path gives UURL.

Constraints

The number of nodes in the tree is n.
2 ≤ n ≤ 10⁵
1 ≤ Node.val ≤ n
All values in the tree are unique.
startValue ≠ destValue

Visualization

Tap to expand

Asked in

f Facebook 25 a Amazon 18 G Google 15 M Microsoft 12

The key insight is to find paths from root to both nodes, then identify their lowest common ancestor by finding the common prefix. The optimal approach uses DFS to find these paths and removes the common portion to create the shortest path. Best approach is DFS with LCA optimization: Time O(n), Space O(h).

Common Approaches

✓ Brute Force - Full Path Recording

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

Use DFS to find the complete path from root to start node and root to destination node. Then combine these paths by going up from start to root and down from root to destination.

DFS with Lowest Common Ancestor

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

Use DFS to find the lowest common ancestor (LCA) of start and destination nodes. Then find paths from LCA to both nodes and combine them efficiently, eliminating unnecessary 'U' moves.

Brute Force - Full Path Recording — Algorithm Steps

Step 1: Find path from root to start node
Step 2: Find path from root to destination node
Step 3: Reverse start path (all 'U's) and append destination path

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

Combine Paths

Convert start path to 'U's and append 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;
};

static int parseArray[100000];
static int arraySize = 0;
static struct TreeNode nodes[100000];
static int nodeCount = 0;

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* solution(struct TreeNode* root, int startValue, int destValue) {
    static char startPath[1000], destPath[1000];
    int startLen = 0, destLen = 0;
    
    findPath(root, startValue, startPath, &startLen);
    findPath(root, destValue, destPath, &destLen);
    
    // Find common prefix
    int i = 0;
    while (i < startLen && i < destLen && startPath[i] == destPath[i]) {
        i++;
    }
    
    static char result[2000];
    int idx = 0;
    
    // Add up moves
    for (int j = i; j < startLen; j++) {
        result[idx++] = 'U';
    }
    // Add down moves
    for (int j = i; j < destLen; j++) {
        result[idx++] = destPath[j];
    }
    result[idx] = '\0';
    
    return result;
}

struct TreeNode* createNode(int val) {
    nodes[nodeCount].val = val;
    nodes[nodeCount].left = NULL;
    nodes[nodeCount].right = NULL;
    return &nodes[nodeCount++];
}

struct TreeNode* buildTreeFromArray() {
    if (arraySize == 0 || parseArray[0] == -1) return NULL;
    
    struct TreeNode* root = createNode(parseArray[0]);
    static struct TreeNode* queue[100000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < arraySize) {
        struct TreeNode* node = queue[front++];
        
        if (i < arraySize && parseArray[i] != -1) {
            node->left = createNode(parseArray[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < arraySize && parseArray[i] != -1) {
            node->right = createNode(parseArray[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

void parseInput(char* line) {
    arraySize = 0;
    char* p = line + 1; // skip '['
    
    while (*p && *p != ']') {
        if (*p == 'n') { // null
            parseArray[arraySize++] = -1;
            while (*p && *p != ',' && *p != ']') p++;
        } else if (*p >= '0' && *p <= '9') {
            int num = 0;
            while (*p >= '0' && *p <= '9') {
                num = num * 10 + (*p - '0');
                p++;
            }
            parseArray[arraySize++] = num;
        } else {
            p++;
        }
        
        if (*p == ',') p++;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse tree array
    parseInput(line);
    struct TreeNode* root = buildTreeFromArray();
    
    int startValue, destValue;
    scanf("%d", &startValue);
    scanf("%d", &destValue);
    
    char* result = solution(root, startValue, destValue);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once during DFS traversal to find both paths

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus path storage

✓ Linear Space

89.5K Views

Medium 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

Brute Force - Full Path Recording — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler