A zero-indexed array A of length N contains all integers from 0 to N-1. Find and return the longest length of set S, where S[i] = {A[i], A[A[i]], A[A[A[i]]], … } subjected to the rule below.

Suppose the first element in S starts with the selection of element A[i] of index = i, the next element in S should be A[A[i]], and then A[A[A[i]]]… By that analogy, we stop adding right before a duplicate element occurs in S.

Example 1:

1 2 3 4 5 6 7 Input: A = [5,4,0,3,1,6,2] Output: 4 Explanation: A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2. One of the longest S[K]: S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}

Note:

- N is an integer within the range [1, 20,000].
- The elements of A are all distinct.
- Each element of A is an integer within the range [0, N-1].

## Solution

The most naïve method is to iterate over the whole list. For each element in the list, the `walk`

function finds the length `n`

of the path starting from `start`

. It return the maximum length in the length list. It is intuitive but adds redundancy to the solution.

1
2
3
4
5

arrayNesting :: [Int] -> Int
arrayNesting arr = maximum $ map (\x -> walk (arr !! x) x 0) arr
where
walk cur start n =
if cur /= start then walk (arr !! cur) start (n + 1) else n + 1

Consider a process with the list [1,2,3,4,0]: The path we take for all the elements in the list is actually identical and the list mapped with `walk`

function is [5,5,5,5,5]. We can verify that each path is a closed loop so that no matter at which element we started to walk, the result will always be the period of the loop. We can utilize this property in a way that each time we encounter an element, mark it as visited. However, modifying a list in Haskell takes \(O(n)\) time as well as space. Clearly we need to use an array instead of a list to improve the current solution.

Comments powered by Disqus.