Array Nesting - Practice Coding Problems

Array Nesting - Problem

Imagine you're following a treasure map where each location points to another location, and you want to find the longest possible path before returning to a place you've already visited!

You are given an integer array nums of length n where nums is a permutation of the numbers in the range [0, n-1]. Think of each index as a location, and each value as directions to the next location.

For any starting index k, you can build a set s[k] by following this path:

Start at nums[k]
Next, go to nums[nums[k]]
Then nums[nums[nums[k]]]
Continue until you would revisit a number you've already seen

Goal: Return the maximum length of any such set s[k].

Example: If nums = [5,4,0,3,1,6,2], starting from index 0: we get 5 → 6 → 2 → 0 → 5 (length 4 before repeating).

Input & Output

example_1.py — Basic Case

$ Input: [5,4,0,3,1,6,2]

› Output: 4

💡 Note: Starting from index 0: nums[0]=5 → nums[5]=6 → nums[6]=2 → nums[2]=0 → back to nums[0]=5. The cycle 0→5→6→2→0 has length 4, which is the maximum possible.

example_2.py — Simple Case

$ Input: [0,1,2]

› Output: 1

💡 Note: Each element points to itself or forms cycles of length 1: 0→0, 1→1, 2→2. Maximum length is 1.

example_3.py — Two Element Cycle

$ Input: [0,2,1]

› Output: 2

💡 Note: Starting from index 1: nums[1]=2 → nums[2]=1 → back to nums[1]=2. The cycle 1→2→1 has length 2. Index 0 forms a self-loop with length 1. Maximum is 2.

Visualization

Tap to expand

Understanding the Visualization

Start Exploration

Begin at any unvisited location and start following the treasure map directions

Follow the Trail

Keep following nums[current] to get the next location, marking each as visited

Detect Cycle

Stop when you reach a location you've already visited - you've found a cycle!

Skip Explored Areas

Move to next unvisited location, skipping areas already explored

Find Maximum

The longest treasure hunt path is your answer!

Key Takeaway

🎯 Key Insight: Since it's a permutation, every element belongs to exactly one cycle. Mark elements as visited globally to avoid re-exploring cycles, achieving optimal O(n) time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited exactly once across all iterations

✓ Linear Growth

Space Complexity

O(1)

Only need a boolean visited array of size n, or can modify input array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] < nums.length
nums is a permutation of numbers [0, 1, ..., n-1]
All integers nums[i] are unique

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses cycle detection with global visited marking to achieve O(n) time complexity. Since the array is a permutation, each element belongs to exactly one cycle. We mark elements as visited globally to avoid re-exploring the same cycles, ensuring each element is visited exactly once across all iterations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Starting Point)	O(n²)	O(n)	Try every possible starting index and follow the path until we find a cycle
Cycle Detection with Visited Marking (Optimal)	O(n)	O(1)	Mark visited elements globally to avoid re-exploring the same cycles

Brute Force (Try Every Starting Point) — Algorithm Steps

For each starting index i from 0 to n-1
Create a visited set for this path
Follow the chain: current = nums[i], then current = nums[current], etc.
Count steps until current value is already in visited set
Update maximum length if this path is longer

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Starting Point 0

Follow path: 0 → nums[0] → nums[nums[0]] → ... until cycle

Try Starting Point 1

Follow path: 1 → nums[1] → nums[nums[1]] → ... until cycle

Continue for All Points

Repeat for every possible starting index

Track Maximum

Keep track of the longest path found

Code -

solution.c — C

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

int arrayNesting(int* nums, int numsSize) {
    int maxLength = 0;
    
    for (int start = 0; start < numsSize; start++) {
        bool* visited = (bool*)calloc(numsSize, sizeof(bool));
        int current = start;
        int length = 0;
        
        // Follow the path until we find a cycle
        while (!visited[current]) {
            visited[current] = true;
            current = nums[current];
            length++;
        }
        
        if (length > maxLength) {
            maxLength = length;
        }
        free(visited);
    }
    
    return maxLength;
}

int main() {
    char input[100000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for array format [1,2,3]
    int nums[10000];
    int size = 0;
    char* token = strtok(input + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", arrayNesting(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we try n starting points, and each path can be up to length n

⚠ Quadratic Growth

Space Complexity

O(n)

We need a visited set to track elements in current path, worst case size n

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] < nums.length
nums is a permutation of numbers [0, 1, ..., n-1]
All integers nums[i] are unique

42.8K Views

Medium Frequency

~15 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 (Try Every Starting Point) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler