Longest Absolute File Path - Practice Coding Problems

Longest Absolute File Path - Problem

Imagine you're exploring a complex file system structure represented as a text string! 📁

You're given a string representation of a file system where:

Directories and files are separated by newline characters (\n)
Depth/nesting level is indicated by the number of tab characters (\t)
Files contain a dot (.) in their name (like file.txt)
Directories do not contain dots

Example: The string "dir\n\tsubdir1\n\t\tfile1.ext\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext" represents:

dir
	subdir1
		file1.ext
	subdir2
		subsubdir2
			file2.ext

Your mission: Find the length of the longest absolute path to any file in this system. An absolute path includes all directory names separated by forward slashes, like "dir/subdir2/subsubdir2/file2.ext".

If there are no files in the system, return 0.

Input & Output

example_1.py — Basic Directory Structure

$ Input: "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext"

› Output: 32

💡 Note: The longest path is "dir/subdir2/subsubdir2/file2.ext" with length 32. We have: 'dir' (3) + '/' (1) + 'subdir2' (7) + '/' (1) + 'subsubdir2' (10) + '/' (1) + 'file2.ext' (9) = 32 characters total.

example_2.py — Single File

$ Input: "file1.txt"

› Output: 9

💡 Note: There's only one file 'file1.txt' at the root level, so the longest path length is simply 9 (the length of 'file1.txt').

example_3.py — No Files

$ Input: "dir\n\tsubdir1\n\tsubdir2"

› Output: 0

💡 Note: There are only directories in the system, no files. Since we need to find the longest path to a file, and there are no files, we return 0.

Constraints

1 ≤ input.length ≤ 10⁴
input contains only valid English letters, digits, spaces, '\n', and '\t'
All folder and file names have length in range [1, 10]
The depth of the folder structure will not exceed 1000
File names contain exactly one dot to separate name and extension

Visualization

Tap to expand

Understanding the Visualization

Stack Initialization

Start with stack [0] representing root level with path length 0

Depth Detection

Count tabs in each line to determine directory depth level

Stack Management

Adjust stack size to match current depth, maintaining parent path lengths

Path Length Calculation

Add current name length to parent's path length plus separator

File Processing

When encountering a file (contains '.'), update maximum path length

Key Takeaway

🎯 Key Insight: The stack maintains cumulative path lengths at each depth, allowing us to calculate any file's absolute path length in constant time as we encounter it, achieving optimal O(n) time complexity.

Asked in

G Google 45 f Facebook 32 ⊞ Microsoft 28 a Amazon 22

The optimal solution uses a stack-based approach to track path lengths at each directory depth in O(n) time. As we process each line, we count tabs to determine depth, adjust the stack size, and calculate the current path length by adding the current name length to the parent's path length. When we encounter a file (contains '.'), we update our maximum. This elegant approach requires only O(depth) space and processes the input in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Stack (Optimal)	O(n)	O(d)	Use stack to track path lengths at each depth level in single pass
Brute Force (Generate All Paths)	O(n²)	O(n²)	Generate all possible paths and find the longest file path

One-Pass Stack (Optimal) — Algorithm Steps

Initialize a stack with 0 (root level path length)
For each line, count tabs to determine depth
Adjust stack size to match current depth level
Calculate current path length by adding name length to parent's path length
If it's a file, update maximum path length
Push current path length to stack for potential children

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Start with stack containing [0] for root level

Process Each Line

Count tabs to determine depth, adjust stack size

Calculate Length

Add current name length to parent's path length

Update Maximum

If it's a file, compare with current maximum

Code -

solution.c — C

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

int lengthLongestPath(char* input) {
    if (!input || strlen(input) == 0) return 0;
    
    int stack[1000]; // Stack to store path lengths
    int stackSize = 1;
    stack[0] = 0; // Root level
    int maxLength = 0;
    
    char* inputCopy = malloc(strlen(input) + 1);
    strcpy(inputCopy, input);
    
    char* token = strtok(inputCopy, "\n");
    
    while (token != NULL) {
        // Count depth (number of tabs)
        int depth = 0;
        char* name = token;
        while (*name == '\t') {
            depth++;
            name++;
        }
        
        // Adjust stack size to current depth
        while (stackSize > depth + 1) {
            stackSize--;
        }
        
        // Calculate current path length
        int currentLength = stack[stackSize - 1] + strlen(name);
        if (depth > 0) {
            currentLength += 1; // Add '/' separator
        }
        
        // If it's a file, update maxLength
        if (strchr(name, '.') != NULL) {
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        }
        
        // Push current path length for potential children
        stack[stackSize++] = currentLength;
        
        token = strtok(NULL, "\n");
    }
    
    free(inputCopy);
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all lines in the input

✓ Linear Growth

Space Complexity

O(d)

Stack depth equals maximum directory depth, not total number of entries

✓ Linear Space

89.2K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler