565. Array Nesting

Given an array A of positive integers (not necessarily distinct), return the lexicographically largest permutation that is smaller than A, that can be made with one swap (A swap exchanges the positions of two numbers A[i] and A[j]).  If it cannot be done, then return the same array.

Example 1:

Input: [3,2,1]
Output: [3,1,2]
Explanation: Swapping 2 and 1.

Example 2:

Input: [1,1,5]
Output: [1,1,5]
Explanation: This is already the smallest permutation.

Example 3:

Input: [1,9,4,6,7]
Output: [1,7,4,6,9]
Explanation: Swapping 9 and 7.

Example 4:

Input: [3,1,1,3]
Output: [1,3,1,3]
Explanation: Swapping 1 and 3.

Note:

1. 1 <= A.length <= 10000
2. 1 <= A[i] <= 10000

class Solution {
    public int arrayNesting(int[] nums) {
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            Set<Integer> set = new HashSet();
            int cur = nums[i];
            while(!set.contains(cur)) {
                set.add(cur);
                cur = nums[cur];
            }
            res = Math.max(res, set.size());
        }
        return res;
    }
}

brute force, 差点过，TLE了 O(n^2)

class Solution {
    public int arrayNesting(int[] nums) {
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            int cur = 0;
            for(int j = i; nums[j] >= 0; cur++) {
                int tmp = nums[j];
                nums[j] = -1;
                j = tmp;
            }
            res = Math.max(res, cur);
        }
        return res;
    }
}

O（n），标记visited过的点（-1），

class Solution {
    public int arrayNesting(int[] nums) {
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            int cur = 0;
            int j = i;
            while(nums[j] >= 0) {
                int tmp = nums[j];
                nums[j] = -1;
                j = tmp;
                cur++;
            }
            res = Math.max(res, cur);
        }
        return res;
    }
}

用while循环更自然一点