```python
import collections

def solve(a, n):
    if n <= 1:
        return True

    def count_equal_pairs(arr):
        counts = collections.Counter(arr)
        num_equal_pairs = 0
        for count in counts.values():
            num_equal_pairs += count * (count - 1) // 2
        return num_equal_pairs

    def _merge_and_count(arr, temp_arr, left, mid, right):
        i = left
        j = mid + 1
        k = left
        inv_count = 0

        while i <= mid and j <= right:
            if arr[i] <= arr[j]:
                temp_arr[k] = arr[i]
                i += 1
            else:
                temp_arr[k] = arr[j]
                inv_count += (mid - i + 1)
                j += 1
            k += 1

        while i <= mid:
            temp_arr[k] = arr[i]
            i += 1
            k += 1

        while j <= right:
            temp_arr[k] = arr[j]
            j += 1
            k += 1

        for idx in range(left, right + 1):
            arr[idx] = temp_arr[idx]

        return inv_count

    def _merge_sort_and_count(arr, temp_arr, left, right):
        inv_count = 0
        if left < right:
            mid = (left + right) // 2
            inv_count += _merge_sort_and_count(arr, temp_arr, left, mid)
            inv_count += _merge_sort_and_count(arr, temp_arr, mid + 1, right)
            inv_count += _merge_and_count(arr, temp_arr, left, mid, right)
        return inv_count

    def count_inversions(arr, size):
        if size == 0:
            return 0
        arr_copy = list(arr)
        temp_arr = [0] * size
        return _merge_sort_and_count(arr_copy, temp_arr, 0, size - 1)

    inversion_count = count_inversions(a, n)
    equal_pairs_count = count_equal_pairs(a)
    total_pairs = n * (n - 1) // 2

    co_inversion_count = total_pairs - inversion_count - equal_pairs_count

    return inversion_count == co_inversion_count
```