Longest Absolute File Path - Problem

Suppose we have a file system that stores both files and directories. Given a string input representing the file system in a specific format, return the length of the longest absolute path to a file in the abstracted file system.

The input string uses \n (newline) to separate different files/directories, and \t (tab) characters to represent the depth level in the directory hierarchy.

Each file name is of the form name.extension, while directory names consist of letters, digits, and/or spaces without extensions.

For example:

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

represents the directory structure where file2.ext has the absolute path "dir/subdir2/subsubdir2/file2.ext" with length 32.

If there is no file in the system, return 0.

Input & Output

Example 1 — Basic Directory Structure

$ Input: 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. This beats "dir/subdir1/file1.ext" which has length 20.

Example 2 — Single File

$ Input: input = "file1.txt"

› Output: 9

💡 Note: Only one file exists at root level with name "file1.txt", so the length is 9.

Example 3 — No Files

$ Input: input = "dir1\n\tdir2\n\t\tdir3"

› Output: 0

💡 Note: All entries are directories (no extensions), so no files exist. Return 0.

Constraints

1 ≤ input.length ≤ 10⁴
input contains only valid directory/file names
File names contain exactly one '.' character
No empty directory or file names

Visualization

Tap to expand

Asked in

G Google 35 A Amazon 28 M Microsoft 22 F Facebook 18

The key insight is to use a stack to efficiently track directory path lengths at each nesting level. Best approach is the stack-based solution which processes input in a single pass. Time: O(n), Space: O(d) where d is maximum directory depth.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

Generate All Paths

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

Parse the input to build the complete directory tree structure, then recursively generate all possible paths to files and track the maximum length.

Stack-Based Path Tracking

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

Parse the input line by line, use a stack to maintain the current directory path lengths based on indentation depth. When encountering a file, calculate the total path length.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static char input_buffer[10000];
static char* lines[1000];
static int line_count = 0;

int max(int a, int b) {
    return a > b ? a : b;
}

int count_tabs(const char* line) {
    int count = 0;
    while (line[count] == '\t') {
        count++;
    }
    return count;
}

int is_file(const char* name) {
    return strchr(name, '.') != NULL;
}

int dfs(int start_idx, int target_depth, const char* current_path) {
    int max_len = 0;
    
    for (int i = start_idx; i < line_count; i++) {
        const char* line = lines[i];
        int depth = count_tabs(line);
        
        // If we've gone back to a shallower depth, we're done with this subtree
        if (depth < target_depth) {
            break;
        }
        
        // Only process items at exactly the target depth (immediate children)
        if (depth == target_depth) {
            const char* name = line + depth;  // Skip tabs
            
            // Build new path
            char new_path[1000];
            if (strlen(current_path) == 0) {
                strcpy(new_path, name);
            } else {
                sprintf(new_path, "%s/%s", current_path, name);
            }
            
            if (is_file(name)) {
                max_len = max(max_len, (int)strlen(new_path));
            } else {
                // It's a directory, explore its children
                int child_max = dfs(i + 1, depth + 1, new_path);
                max_len = max(max_len, child_max);
            }
        }
    }
    
    return max_len;
}

int solution(const char* input_str) {
    if (!input_str || strlen(input_str) == 0) {
        return 0;
    }
    
    // Split input by newlines
    char* input_copy = malloc(strlen(input_str) + 1);
    strcpy(input_copy, input_str);
    
    line_count = 0;
    char* token = strtok(input_copy, "\n");
    while (token != NULL && line_count < 1000) {
        lines[line_count] = malloc(strlen(token) + 1);
        strcpy(lines[line_count], token);
        line_count++;
        token = strtok(NULL, "\n");
    }
    
    int result = dfs(0, 0, "");
    
    // Free allocated memory
    for (int i = 0; i < line_count; i++) {
        free(lines[i]);
    }
    free(input_copy);
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    // Read input
    if (!fgets(input_buffer, sizeof(input_buffer), stdin)) {
        printf("0\n");
        return 0;
    }
    
    // Remove newline
    int len = strlen(input_buffer);
    if (len > 0 && input_buffer[len-1] == '\n') {
        input_buffer[len-1] = '\0';
        len--;
    }
    
    // Remove surrounding quotes if present
    char* start = input_buffer;
    char* end = input_buffer + len - 1;
    if (*start == '"') start++;
    if (*end == '"') *end = '\0';
    
    // Process escaped characters
    char processed[10000];
    int j = 0;
    for (int i = 0; start[i]; i++) {
        if (start[i] == '\\' && start[i+1] == 'n') {
            processed[j++] = '\n';
            i++; // skip the 'n'
        } else if (start[i] == '\\' && start[i+1] == 't') {
            processed[j++] = '\t';
            i++; // skip the 't'
        } else {
            processed[j++] = start[i];
        }
    }
    processed[j] = '\0';
    
    int result = solution(processed);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

67.0K Views

Medium Frequency

~25 min Avg. Time

890 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