Open In App

Check if the count of inversions of two given types on an Array are equal or not

Improve
Improve
Like Article
Like
Save
Share
Report

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 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 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 <bits/stdc++.h>
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[0]);
 
    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


Javascript




<script>
// Javascript implementation of the above approach
 
// Function to check if the
// count of inversion of two
// types are same or not
function solve(a, n)
{
    let mx = 0;
 
    for(let 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
     
    let a = [ 1, 0, 2 ];
 
    let n = a.length;
     
    let possible = solve(a, n);
     
    if (possible)
        document.write("Yes");
    else
        document.write("No");
 
</script>


Output: 

Yes

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



Last Updated : 13 May, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads