An inversion is a pair of indices `(i, j)` such that `i < j` and `arr[i] > arr[j]`. This problem can be solved efficiently using a divide-and-conquer approach, specifically by modifying the merge sort algorithm.

The core idea is:
1.  **Divide**: Split the array into two halves.
2.  **Conquer**: Recursively count inversions in the left half and the right half.
3.  **Combine**: Count the "split inversions" – those where one element is in the left half and the other is in the right half. This is done during the merge step.

When merging two sorted halves, if we take an element from the right half before an element from the left half, it means the element from the right half is smaller than all the remaining elements in the left half. This insight allows us to count the split inversions in linear time during the merge process.

The total number of inversions is the sum of inversions from the left half, the right half, and the split inversions.

```python
def get_Inv_Count(arr, n):
    def merge_and_count(left_half, right_half):
        merged_array = []
        inversion_count = 0
        left_pointer = 0
        right_pointer = 0

        while left_pointer < len(left_half) and right_pointer < len(right_half):
            if left_half[left_pointer] <= right_half[right_pointer]:
                merged_array.append(left_half[left_pointer])
                left_pointer += 1
            else:
                merged_array.append(right_half[right_pointer])
                right_pointer += 1
                inversion_count += (len(left_half) - left_pointer)

        merged_array.extend(left_half[left_pointer:])
        merged_array.extend(right_half[right_pointer:])

        return merged_array, inversion_count

    def sort_and_count(sub_array):
        if len(sub_array) <= 1:
            return sub_array, 0

        mid_point = len(sub_array) // 2
        
        sorted_left, left_inversions = sort_and_count(sub_array[:mid_point])
        sorted_right, right_inversions = sort_and_count(sub_array[mid_point:])
        
        merged, split_inversions = merge_and_count(sorted_left, sorted_right)

        total_inversions = left_inversions + right_inversions + split_inversions
        return merged, total_inversions

    if n <= 1:
        return 0
    
    arr_to_process = arr[:n]
    
    _, total_inversions = sort_and_count(arr_to_process)
    
    return total_inversions
```