Smallest String Starting From Leaf

Smallest String Starting From Leaf - Problem

Imagine you're working with a special binary tree where each node contains a letter from 'a' to 'z' (represented by values 0-25). Your task is to find the lexicographically smallest string that starts from any leaf node and travels up to the root.

Think of it like finding the "earliest" path in a dictionary - just like how "ab" comes before "aba" alphabetically. You need to explore all possible paths from leaves to root and return the one that would appear first in a dictionary.

Key Points:

A leaf node has no children
The string is built from leaf → root direction
Each node value (0-25) maps to letters 'a'-'z'
Return the lexicographically smallest such string

Example: If a path gives you nodes [7, 4, 11, 11, 14] from leaf to root, this translates to string "hello".

Input & Output

example_1.py — Basic Tree

$ Input: root = [0,1,2,3,4,3,4] Tree structure: a(0) / \ b(1) c(2) / | | \ d(3) e(4) d(3) e(4)

› Output: "dba"

💡 Note: There are four possible paths from leaves to root: "dba", "eba", "dca", "eca". The lexicographically smallest is "dba".

example_2.py — Single Path

$ Input: root = [25,1,3,1,3,0,2] Tree structure: z(25) / \ b(1) d(3) / | | \ b(1) d(3) a(0) c(2)

› Output: "adz"

💡 Note: The paths are "bbz", "ddz", "adz", "cdz". The smallest lexicographically is "adz".

example_3.py — Edge Case - Single Node

$ Input: root = [0] Tree structure: a(0)

› Output: "a"

💡 Note: Single node tree, so the only path from leaf to root is just "a".

Constraints

The number of nodes in the tree is in the range [1, 8500]
0 ≤ Node.val ≤ 25
Each node value represents a letter from 'a' to 'z' (0 = 'a', 1 = 'b', ..., 25 = 'z')
Important: The string is built from leaf to root, not root to leaf

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 25 f Meta 18

The optimal approach uses DFS traversal to build strings from leaf to root during traversal, comparing them on-the-fly without storing all paths. This achieves O(n) time and O(h) space complexity, where h is the tree height.

Common Approaches

✓ Brute Force (Collect All Paths)

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

This approach first collects all possible paths from leaves to root, converts each path to its corresponding string, and then finds the lexicographically smallest one. It's straightforward but not optimal due to storing all paths.

Optimized DFS (Single Pass)

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

This optimal approach builds strings during the DFS traversal and maintains the lexicographically smallest string found so far. It avoids storing all paths by comparing strings as soon as leaf nodes are reached.

Brute Force (Collect All Paths) — Algorithm Steps

Perform DFS to find all paths from root to leaves
For each path, reverse it (to get leaf-to-root order)
Convert each path to string using character mapping
Compare all strings to find lexicographically smallest

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Paths

DFS traversal collects all root-to-leaf paths

Reverse Paths

Each path is reversed to get leaf-to-root order

Convert to Strings

Numeric values converted to characters

Find Minimum

Compare all strings lexicographically

Code -

solution.c — C

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

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

static char result[10000];

void dfs(struct TreeNode* node, char* path, int len) {
    if (!node) return;
    
    // Add current character to path
    path[len] = 'a' + node->val;
    path[len + 1] = '\0';
    
    // If leaf node
    if (!node->left && !node->right) {
        // Reverse path to get leaf-to-root string
        char temp[10000];
        for (int i = 0; i <= len; i++) {
            temp[i] = path[len - i];
        }
        temp[len + 1] = '\0';
        
        // Update result if this is smaller or first path
        if (result[0] == '\0' || strcmp(temp, result) < 0) {
            strcpy(result, temp);
        }
        return;
    }
    
    // Continue DFS
    if (node->left) {
        dfs(node->left, path, len + 1);
    }
    if (node->right) {
        dfs(node->right, path, len + 1);
    }
}

char* smallestFromLeaf(struct TreeNode* root) {
    if (!root) {
        result[0] = '\0';
        return result;
    }
    
    char path[10000];
    result[0] = '\0';  // Reset result
    dfs(root, path, 0);
    return result;
}

struct TreeNode* buildTreeFromArray(char** arr, int size) {
    if (size == 0 || strcmp(arr[0], "null") == 0) {
        return NULL;
    }
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = atoi(arr[0]);
    root->left = root->right = NULL;
    
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && strcmp(arr[i], "null") != 0) {
            node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->left->val = atoi(arr[i]);
            node->left->left = node->left->right = NULL;
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && strcmp(arr[i], "null") != 0) {
            node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->right->val = atoi(arr[i]);
            node->right->left = node->right->right = NULL;
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char input[10000];
    if (!fgets(input, sizeof(input), stdin)) {
        printf("");
        return 0;
    }
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    // Trim whitespace
    char* start = input;
    while (*start == ' ' || *start == '\t') start++;
    
    if (strcmp(start, "[]") == 0 || strlen(start) == 0) {
        printf("");
        return 0;
    }
    
    // Parse input
    char* arr[1000];
    int size = 0;
    
    // Find brackets
    char* leftBracket = strchr(start, '[');
    char* rightBracket = strrchr(start, ']');
    
    if (!leftBracket || !rightBracket) {
        printf("");
        return 0;
    }
    
    *rightBracket = '\0';
    start = leftBracket + 1;
    
    char* token = strtok(start, ",");
    while (token != NULL && size < 1000) {
        // Trim whitespace
        while (*token == ' ' || *token == '\t') token++;
        char* endPtr = token + strlen(token) - 1;
        while (endPtr > token && (*endPtr == ' ' || *endPtr == '\t')) {
            *endPtr = '\0';
            endPtr--;
        }
        
        arr[size++] = token;
        token = strtok(NULL, ",");
    }
    
    struct TreeNode* root = buildTreeFromArray(arr, size);
    char* res = smallestFromLeaf(root);
    printf("%s", res);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to traverse tree + O(n*h) to build and compare strings, where h is height

✓ Linear Growth

Space Complexity

O(n*h)

Storing all paths, each of length h (height), with potentially n/2 leaves

✓ Linear Space

42.8K Views

Medium Frequency

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

Brute Force (Collect All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler