Related Articles
Check if the count of inversions of two given types on an Array are equal or not
• Last Updated : 22 Sep, 2020

Given an array a[] on which, the following two types of inversions are performed:

• Count of pairs of indices (i, j) such that A[i] > A[j] and i < j
• Count of pairs of indices (i, j) such that A[i] > A[j] and j = i + 1

The task is to check if the count of both the inversions is equal or not. If they are the equal, print “Yes”. Otherwise, print “No”.
Examples:

Input: a[] = {1, 0, 2}
Output: Yes
Explanation:
Count of inversion of Type 1 = 1 [ (i, j) : (0, 1) ]
Count of inversion of Type 2 = 1 [ (i, j) : (0, 1) ]

Input: a[] = {1, 2, 0}
Output: No
Explanation:
Count of inversion of Type 1 = 2 [ (i, j) : (0, 2);(1, 2) ]
Count of inversion of Type 2 = 1 [ (i, j) : (1, 2) ]

Approach:
To solve the problem, the difference between the two inversions need to be understood:

• For Type 2, if j = 5, then i can only be 4 as j = i + 1
• For Type 1, if j = 5, then i can be from 0 to 4, as i is less than j.
• Therefore, the inversion of Type 1 is basically an inversion of Type 2 summed up with all pair of indices(i, j) with i which is less than (j – 1) and a[i] > a[j].
• So, for any index j, the task is to check if there is an index i, which is less than j – 1 and a[i] > a[j]. If any such pair of indices (i, j) is found, then print “No“. Otherwise, print “Yes“.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement ``// the above approach `` ` `#include  ``using` `namespace` `std; `` ` `// Function to check if the ``// count of inversion of two ``// types are same or not ``bool` `solve(``int` `a[], ``int` `n) ``{ ``    ``int` `mx = INT_MIN; `` ` `    ``for` `(``int` `j = 1; j < n; j++) { `` ` `        ``// If maximum value is found ``        ``// to be greater than a[j], ``        ``// then that pair of indices ``        ``// (i, j) will add extra value ``        ``// to inversion of Type 1 ``        ``if` `(mx > a[j]) `` ` `            ``return` `false``; `` ` `        ``// Update max ``        ``mx = max(mx, a[j - 1]); ``    ``} `` ` `    ``return` `true``; ``} `` ` `// Driver code ``int` `main() ``{ `` ` `    ``int` `a[] = { 1, 0, 2 }; `` ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); `` ` `    ``bool` `possible = solve(a, n); `` ` `    ``if` `(possible) ``        ``cout << ``"Yes"` `<< endl; ``    ``else``        ``cout << ``"No"` `<< endl; `` ` `    ``return` `0; ``} `

## Java

 `// Java program to implement ``// the above approach ``import` `java.io.*;`` ` `class` `GFG{``     ` `// Function to check if the ``// count of inversion of two ``// types are same or not ``static` `boolean` `solve(``int` `a[], ``int` `n) ``{ ``    ``int` `mx = Integer.MIN_VALUE; `` ` `    ``for``(``int` `j = ``1``; j < n; j++)``    ``{``         ` `        ``// If maximum value is found ``        ``// to be greater than a[j], ``        ``// then that pair of indices ``        ``// (i, j) will add extra value ``        ``// to inversion of Type 1 ``        ``if` `(mx > a[j]) ``            ``return` `false``; `` ` `        ``// Update max ``        ``mx = Math.max(mx, a[j - ``1``]); ``    ``} ``    ``return` `true``; ``}``     ` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``int` `a[] = { ``1``, ``0``, ``2` `}; `` ` `    ``int` `n = a.length; ``     ` `    ``boolean` `possible = solve(a, n); ``     ` `    ``if` `(possible) ``        ``System.out.println(``"Yes"``); ``    ``else``        ``System.out.println(``"No"``); ``}``}`` ` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement  ``# the above approach ``import` `sys`` ` `# Function to check if the ``# count of inversion of two ``# types are same or not ``def` `solve(a, n): ``     ` `    ``mx ``=` `-``sys.maxsize ``-` `1`` ` `    ``for` `j ``in` `range``(``1``, n): `` ` `        ``# If maximum value is found ``        ``# to be greater than a[j], ``        ``# then that pair of indices ``        ``# (i, j) will add extra value ``        ``# to inversion of Type 1 ``        ``if` `(mx > a[j]): ``            ``return` `False`` ` `        ``# Update max ``        ``mx ``=` `max``(mx, a[j ``-` `1``]) ``     ` `    ``return` `True`` ` `# Driver code ``a ``=` `[ ``1``, ``0``, ``2` `] `` ` `n ``=` `len``(a) `` ` `possible ``=` `solve(a, n) `` ` `if` `(possible !``=` `0``):``    ``print``(``"Yes"``) ``else``:``    ``print``(``"No"``)`` ` `# This code is contributed by sanjoy_62`

## C#

 `// C# program to implement  ``// the above approach ``using` `System; ``     ` `class` `GFG{ ``     ` `// Function to check if the ``// count of inversion of two ``// types are same or not ``static` `bool` `solve(``int``[] a, ``int` `n) ``{ ``    ``int` `mx = Int32.MinValue; ``     ` `    ``for``(``int` `j = 1; j < n; j++) ``    ``{ ``             ` `        ``// If maximum value is found ``        ``// to be greater than a[j], ``        ``// then that pair of indices ``        ``// (i, j) will add extra value ``        ``// to inversion of Type 1 ``        ``if` `(mx > a[j]) ``            ``return` `false``; ``     ` `        ``// Update max ``        ``mx = Math.Max(mx, a[j - 1]); ``    ``} ``    ``return` `true``; ``} ``         ` `// Driver code ``public` `static` `void` `Main () ``{ ``    ``int``[] a = { 1, 0, 2 }; ``    ``int` `n = a.Length; ``         ` `    ``bool` `possible = solve(a, n); ``         ` `    ``if` `(possible) ``        ``Console.WriteLine(``"Yes"``); ``    ``else``        ``Console.WriteLine(``"No"``); ``} ``}`` ` `// This code is contributed by sanjoy_62`
Output:
```Yes
```

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up