```python
from collections import Counter

def solve(a, n):
    
    def _merge(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]
                k += 1
                i += 1
            else:
                temp_arr[k] = arr[j]
                inv_count += (mid - i + 1)
                k += 1
                j += 1

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

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

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

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

    if n <= 1:
        return True

    arr_copy = list(a)
    temp_arr = [0] * n
    
    # Count of Type 1 inversions: a[i] > a[j] for i < j
    count1 = _merge_sort(arr_copy, temp_arr, 0, n - 1)

    # Count of pairs with equal elements: a[i] == a[j] for i < j
    freq = Counter(a)
    count_eq = 0
    for count in freq.values():
        count_eq += count * (count - 1) // 2

    total_pairs = n * (n - 1) // 2
    
    # Count of Type 2 inversions: a[i] < a[j] for i < j
    count2 = total_pairs - count1 - count_eq

    return count1 == count2
```