检查数组上两个给定类型的求反计数是否相等

给定数组a [] ，将执行以下两种类型的求逆：

• 使得A [i]> A [j]和i 的索引对(i，j)的计数
• 使得A [i]> A [j]且j = i + 1的索引对(i，j)的计数

任务是检查两个反转的计数是否相等。如果它们相等，则打印“是” 。否则，打印“否” 。
例子：

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) ]

方法：
要解决此问题，需要了解两个反演之间的区别：

• 对于类型2 ，如果j = 5，则我只能是4，因为j = i + 1
• 对于类型1，如果j = 5 ，则i可以从0到4 ，因为i小于j 。
• 因此，1型的反转基本上总结了与所有对索引(I，J)，其中i的2型的反转小于(j – 1)和[Ⅰ]>一个[J]。
• 因此，对于任何索引j ，任务是检查是否存在小于i – 1且a [i]> a [j]的索引i 。如果找到任何这样的索引对(i，j) ，则打印“ No ”。否则，打印“是”。

下面是上述方法的实现：

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[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

输出：

Yes

时间复杂度： O(N)
辅助空间： O(1)