通过附加给定数组 K 次生成的序列中的反转计数

给定一个数组arr[] ，任务是将给定的数组精确地追加K – 1次，并打印结果数组中的反转总数。

例子：

Input: arr[]= {2, 1, 3}, K = 3
Output: 12
Explanation:
Appending 2 copies of array arr[] modifes arr[] to {2, 1, 3, 2, 1, 3, 2, 1, 3}
The pairs (arr[i], arr[j]), where i < j and arr[i] > arr[j] are (2, 1), (2, 1), (2, 1), (3, 2), (3, 1), (3, 2), (3, 1), (2, 1), (2, 1), (3, 2), (3, 1), (2, 1)
Therefore, the total number of inversions are 12.

Input: arr[]= {6, 2}, K = 2
Output: 3
Explanation:
Appending 2 copies of array arr[] = {6, 2, 6, 2}
The pairs (arr[i], arr[j]), where i < j and arr[i] > arr[j] are (6, 2), (6, 2), (6, 2)
Therefore, the total number of inversions are 3.

朴素的方法：最简单的方法是将给定数组的K 个副本存储在一个向量中，然后找到结果向量的反转计数。
时间复杂度： O(N ² )
辅助空间： O(K * N)

有效的方法：解决这个问题的想法是首先找到给定数组中的反转总数，比如inv 。然后，计算单个副本中的不同元素对，例如X 。现在，通过以下等式计算附加数组的K 个副本后的反转总数：

(inv*K + ((K*(K-1))/2)*X).

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to count the number of
// inversions in K copies of given array
void totalInversions(int arr[],
                     int K, int N)
{
    // Stores count of inversions
    // in the given array
    int inv = 0;
 
    // Stores the count of pairs
    // of distinct array elements
    int X = 0;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Generate each pair
        for (int j = 0; j < N; j++) {
 
            // Check for each pair, if the
            // condition is satisfied or not
            if (arr[i] > arr[j] and i < j)
                inv++;
 
            // If pairs consist of
            // distinct elements
            if (arr[i] > arr[j])
                X++;
        }
    }
 
    // Count inversiosn in the sequence
    int totalInv = X * K * (K - 1) / 2
                   + inv * K;
 
    // Print the answer
    cout << totalInv << endl;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 2, 1, 3 };
 
    // Given K
    int K = 3;
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    totalInversions(arr, K, N);
}

Java

// Java program for the above approach
import java.util.*;
class GFG
{
  
 // Function to count the number of
// inversions in K copies of given array
static void totalInversions(int arr[],
                     int K, int N)
{
   
    // Stores count of inversions
    // in the given array
    int inv = 0;
 
    // Stores the count of pairs
    // of distinct array elements
    int X = 0;
    int i, j;
 
    // Traverse the array
    for (i = 0; i < N; i++)
    {
 
        // Generate each pair
        for (j = 0; j < N; j++)
        {
 
            // Check for each pair, if the
            // condition is satisfied or not
            if(arr[i] > arr[j] && i < j)
                inv++;
 
            // If pairs consist of
            // distinct elements
            if(arr[i] > arr[j])
                X++;
        }
    }
 
    // Count inversiosn in the sequence
    int totalInv = X * K * (K - 1) / 2
                   + inv * K;
 
    // Print the answer
    System.out.println(totalInv);
}
 
// Driver Code
public static void main(String args[])
{
   
    // Given array
    int arr[] = { 2, 1, 3 };
 
    // Given K
    int K = 3;
 
    // Size of the array
    int N = arr.length;
    totalInversions(arr, K, N);
}
}
 
// This code is contributed by bgangwar59.

Python3

# Python program of the above approach
 
# Function to count the number of
# inversions in K copies of given array
def totalInversions(arr, K, N) :
                          
    # Stores count of inversions
    # in the given array
    inv = 0
 
    # Stores the count of pairs
    # of distinct array elements
    X = 0
 
    # Traverse the array
    for i in range(N):
 
        # Generate each pair
        for j in range(N):
 
            # Check for each pair, if the
            # condition is satisfied or not
            if (arr[i] > arr[j] and i < j) :
                inv += 1
 
            # If pairs consist of
            # distinct elements
            if (arr[i] > arr[j]) :
                X += 1
         
    # Count inversiosn in the sequence
    totalInv = X * K * (K - 1) // 2 + inv * K
 
    # Prthe answer
    print(totalInv)
 
# Driver Code
 
# Given array
arr = [ 2, 1, 3 ]
 
# Given K
K = 3
 
# Size of the array
N = len(arr)
totalInversions(arr, K, N)
 
# This code is contributed by susmitakundugoaldanga

C#

// C# program to implement
// the above approach
using System;
 
class GFG
{
 
  // Function to count the number of
  // inversions in K copies of given array
  static void totalInversions(int []arr,
                              int K, int N)
  {
 
    // Stores count of inversions
    // in the given array
    int inv = 0;
 
    // Stores the count of pairs
    // of distinct array elements
    int X = 0;
    int i, j;
 
    // Traverse the array
    for (i = 0; i < N; i++)
    {
 
      // Generate each pair
      for (j = 0; j < N; j++)
      {
 
        // Check for each pair, if the
        // condition is satisfied or not
        if(arr[i] > arr[j] && i < j)
          inv++;
 
        // If pairs consist of
        // distinct elements
        if(arr[i] > arr[j])
          X++;
      }
    }
 
    // Count inversiosn in the sequence
    int totalInv = X * K * (K - 1) / 2
      + inv * K;
 
    // Print the answer
    Console.WriteLine(totalInv);
  }
 
  // Driver Code
  public static void  Main()
  {
 
    // Given array
    int []arr = { 2, 1, 3 };
 
    // Given K
    int K = 3;
 
    // Size of the array
    int N = arr.Length;
    totalInversions(arr, K, N);
  }
}
 
// This code is contributed by jana_sayantan.

Javascript

 
// JavaScript program for
// the above approach
  
  
 // Function to count the number of
// inversions in K copies of given array
function totalInversions(arr, K, N)
{
   
    // Stores count of inversions
    // in the given array
    let inv = 0;
 
    // Stores the count of pairs
    // of distinct array elements
    let X = 0;
    let i, j;
 
    // Traverse the array
    for (i = 0; i < N; i++)
    {
 
        // Generate each pair
        for (j = 0; j < N; j++)
        {
 
            // Check for each pair, if the
            // condition is satisfied or not
            if(arr[i] > arr[j] && i < j)
                inv++;
 
            // If pairs consist of
            // distinct elements
            if(arr[i] > arr[j])
                X++;
        }
    }
 
    // Count inversiosn in the sequence
    let totalInv = X * K * (K - 1) / 2
                   + inv * K;
 
    // Print the answer
    document.write(totalInv);
}
  
// Driver Code
  
    // Given array
    let arr = [ 2, 1, 3 ];
 
    // Given K
    let K = 3;
 
    // Size of the array
    let N = arr.length;
    totalInversions(arr, K, N);
  

输出：

12

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live