LeetCode 565. Array Nesting

问题描述：

A zero-indexed array A consisting of N different integers is given. The array contains all integers in the range [0, N - 1].

Sets S[K] for 0 <= K < N are defined as follows:

S[K] = { A[K], A[A[K]], A[A[A[K]]], … }.

Sets S[K] are finite for each K and should NOT contain duplicates.

Write a function that given an array A consisting of N integers, return the size of the largest set S[K] for this array.

Example 1:

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:

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

分析问题：

找出一个子序列，这个子序列的特点是{A[K]，A[A[K]],A[A[A[K]]…]}.这个序列结束的结果是形成了一个环。

代码实现：

 public int arrayNesting(int[] nums) {
        int maxLength = 0;
        for (int i = 0; i < nums.length; i++) {
            int nextIndex = nums[i];
            int count = 0;
            do {
                nextIndex = nums[nextIndex];
                count++;
            } while (nextIndex != nums[i]);
            maxLength = Math.max(count, maxLength);
        }
        return maxLength;
    }

这个方法是选中当前队列中的一个值，然后不断的循环，最终循环到当前值结束。在这一个循环中只需要循环一次就好了，在一个队列中的所有的执行的过程都是一样的。所以可以做一个优化，把所有跟踪过的位置都设置为-1.这样时间复杂度就由O(n^2)变为O（n）.

改进的代码：

 public int arrayNesting(int[] nums) {
        int maxLength = 0;
        for (int i = 0; i < nums.length; i++) {
            int length = 0;
            int nextNum = i;
            while (nums[nextNum] != -1) {
                int temp = nextNum;
                nextNum = nums[temp];
                nums[temp] = -1;
                length++;
            }
            maxLength = maxLength > length ? maxLength : length;
        }
        return maxLength;
    }