Count Number Of Distinct Integers After Reverse Operations - Leetcode Solution

Problem Statement:

You are given an integer array nums of length n which represents a permutation of all integers in the range [0, n - 1]. The following operations are done repeatedly on nums until it becomes sorted:

• Pick the largest element in nums. Remove it and insert it at the end of nums.
• Pick the smallest element in nums. Remove it and insert it at the beginning of nums. Return the number of distinct arrays that can be obtained after applying the above operations on nums.

Solution:

To solve this problem, we need to simulate the process of applying the given operations repeatedly on the given array nums.

We can start by creating a set to keep track of all the distinct arrays that can be obtained. Then, we can perform the following steps in a loop until the array becomes sorted:

1. Find the largest element in nums and remove it from the array.
2. Find the smallest element in nums and remove it from the array.
3. Append the largest element to the end of the array.
4. Prepend the smallest element to the beginning of the array.
5. Check if the current array is distinct and add it to the set if it is.

Here is the Python code for the above algorithm:

def countDistinct(nums: List[int]) -> int:
    n = len(nums)
    distinct_arrays = set()

    while not is_sorted(nums):
        largest = max(nums)
        smallest = min(nums)

        nums.remove(largest)
        nums.remove(smallest)

        nums.append(largest)
        nums.insert(0, smallest)

        if is_distinct(nums):
            distinct_arrays.add(tuple(nums))

    return len(distinct_arrays)


def is_sorted(nums):
    return all(nums[i] <= nums[i+1] for i in range(len(nums)-1))


def is_distinct(nums):
    return len(set(nums)) == len(nums)

In this code, the is_sorted function checks if the given array is sorted, and the is_distinct function checks if the given array is distinct. The countDistinct function performs the main algorithm and returns the number of distinct arrays.

The time complexity of this algorithm is O(n^2) because we perform n iterations in the worst case, and each iteration involves finding the minimum and maximum elements in the array, which takes O(n) time. The space complexity is also O(n^2) because we need to store all the distinct arrays in a set. However, since n is at most 2000, this algorithm should run efficiently on the given input size.

Conclusion:

In this problem, we have learned how to simulate a process of applying operations on an array, and how to use a set to keep track of distinct arrays. By implementing the above algorithm, we are able to solve the problem and count the number of distinct arrays that can be obtained after the operations.

1