📌  相关文章
📜  在数组中找到满足给定条件的排列数

📅  最后修改于: 2021-06-25 11:16:39             🧑  作者: Mango

给定大小为N的数组arr [] ,任务是查找符合给定条件的数组中的排列数:

  • 如果K是数组中的最大元素,则数组中K之前的元素应按升序排列,数组K中之后的元素应按降序排列

例子:

观察:通过仔细观察,可以得出以下观察结果:

  1. 可以得出结论,如果任何数字重复两次以上,那么就不会有满足给定条件的排列。这是因为,在所有排列中,这将在最大元素之前或之后被看到两次,从而违反了给定条件。
  2. 可以得出的第二个观察结果是,数组中的最大元素应该只出现一次。如果出现不止一次,则可能会在最大元素之前看到多余的副本,从而违反了给定条件。

方法:当不违反上述两个观察结果时,则想法是将数组划分为两部分,并在每个分区中填充元素,如下所示:

  • 由于我们可以将数组分为两部分。一个在最大元素之前,另一个在最大元素之后。因此,每个元素都有两个选择,是出现在数组中最大元素之外的最大元素之前还是之后。
  • 如果任何元素在数组中出现两次,则该元素只有一个选项。它肯定必须在最大元素之前出现一次,并且在最大元素之后出现一次。
  • 例如,
  • 因此,如果N是数组的大小,M是出现次数= 2的数组中元素的数目,则满足条件的排列数将为2 (N –(2 * X)– 1)

下面是上述方法的实现:

C++
// C++ program to find the number
// of permutations that satisfy
// the given condition in an array
#include 
using namespace std;
  
// Function to calculate x ^ y
// recursively
int pow(int x, int y)
{
    if (y == 1)
        return x;
    if (y == 0)
        return 1;
  
    int temp = pow(x, y / 2);
  
    temp *= temp;
  
    if (y & 1)
        temp *= x;
  
    return temp;
}
  
// Function to return the number of
// permutations that satisfy the
// given condition in an array
int noOfPermutations(int* a, int n)
{
    // If there is only one element then
    // only one permutation is available
    if (n == 1) {
        return 1;
    }
  
    // Sort the array for calculating
    // the number of elements occurring twice
    sort(a, a + n);
  
    // If the maximum element is occurring
    // twice, then the number of permutations
    // satisfying the condition is 0
    if (a[n - 1] == a[n - 2]) {
        return 0;
    }
  
    // This variable will store the
    // number of element occurring twice
    int x = 0;
  
    // Loop to check the number of elements
    // occurring twice
    for (int i = 0; i < n - 2; ++i) {
  
        // Check if this element
        // is occurring twice
        if (a[i] == a[i + 1]) {
  
            // If this element is occurring
            // twice then check if this number
            // is occurring more than twice
            if (a[i] == a[i + 2]) {
  
                // If element occurring thrice
                // then no permutation will
                // satisfy the given condition
                return 0;
            }
  
            x++;
  
            // Since we have checked the next
            // element as well, then we can
            // increment the loop variable
            i++;
        }
    }
  
    return pow(2, n - 2 * x - 1);
}
  
// Driver code
int main()
{
    int a[] = { 1, 2, 2, 3, 4 };
    int n = sizeof(a) / sizeof(a[0]);
    int num = noOfPermutations(a, n);
    cout << num;
    return 0;
}


Java
// Java program to find the number
// of permutations that satisfy
// the given condition in an array
  
import java.util.*;
  
class GFG{
   
// Function to calculate x ^ y
// recursively
static int pow(int x, int y)
{
    if (y == 1)
        return x;
    if (y == 0)
        return 1;
   
    int temp = pow(x, y / 2);
   
    temp *= temp;
   
    if (y % 2 == 1)
        temp *= x;
   
    return temp;
}
   
// Function to return the number of
// permutations that satisfy the
// given condition in an array
static int noOfPermutations(int []a, int n)
{
    // If there is only one element then
    // only one permutation is available
    if (n == 1) {
        return 1;
    }
   
    // Sort the array for calculating
    // the number of elements occurring twice
    Arrays.sort(a);
   
    // If the maximum element is occurring
    // twice, then the number of permutations
    // satisfying the condition is 0
    if (a[n - 1] == a[n - 2]) {
        return 0;
    }
   
    // This variable will store the
    // number of element occurring twice
    int x = 0;
   
    // Loop to check the number of elements
    // occurring twice
    for (int i = 0; i < n - 2; ++i) {
   
        // Check if this element
        // is occurring twice
        if (a[i] == a[i + 1]) {
   
            // If this element is occurring
            // twice then check if this number
            // is occurring more than twice
            if (a[i] == a[i + 2]) {
   
                // If element occurring thrice
                // then no permutation will
                // satisfy the given condition
                return 0;
            }
   
            x++;
   
            // Since we have checked the next
            // element as well, then we can
            // increment the loop variable
            i++;
        }
    }
   
    return pow(2, n - 2 * x - 1);
}
   
// Driver code
public static void main(String[] args)
{
    int a[] = { 1, 2, 2, 3, 4 };
    int n = a.length;
    int num = noOfPermutations(a, n);
    System.out.print(num);
}
}
  
// This code is contributed by 29AjayKumar


Python 3
# Python 3 program to find the number
# of permutations that satisfy
# the given condition in an array
  
# Function to calculate x ^ y
# recursively
def pow( x, y):
  
    if (y == 1):
        return x
    if (y == 0):
        return 1
  
    temp = pow(x, y // 2)
  
    temp *= temp
  
    if (y & 1):
        temp *= x
  
    return temp
  
# Function to return the number of
# permutations that satisfy the
# given condition in an array
def noOfPermutations(a, n):
  
    # If there is only one element then
    # only one permutation is available
    if (n == 1):
        return 1
  
    # Sort the array for calculating
    # the number of elements occurring twice
    a.sort()
  
    # If the maximum element is occurring
    # twice, then the number of permutations
    # satisfying the condition is 0
    if (a[n - 1] == a[n - 2]):
        return 0
  
    # This variable will store the
    # number of element occurring twice
    x = 0
  
    # Loop to check the number of elements
    # occurring twice
    for i in range( n - 2):
  
        # Check if this element
        # is occurring twice
        if (a[i] == a[i + 1]):
  
            # If this element is occurring
            # twice then check if this number
            # is occurring more than twice
            if (a[i] == a[i + 2]):
  
                # If element occurring thrice
                # then no permutation will
                # satisfy the given condition
                return 0
          
            x += 1
  
            # Since we have checked the next
            # element as well, then we can
            # increment the loop variable
            i += 1
  
    return pow(2, n - 2 * x - 1)
  
# Driver code
if __name__ == "__main__":
  
    a = [ 1, 2, 2, 3, 4 ]
    n = len(a)
    num = noOfPermutations(a, n)
    print (num)
  
# This code is contributed by chitranayal


C#
// C# program to find the number
// of permutations that satisfy
// the given condition in an array 
using System;
  
class GFG{
    
// Function to calculate x ^ y
// recursively
static int pow(int x, int y)
{
    if (y == 1)
        return x;
    if (y == 0)
        return 1;
    
    int temp = pow(x, y / 2);
    
    temp *= temp;
    
    if (y % 2 == 1)
        temp *= x;
    
    return temp;
}
    
// Function to return the number of
// permutations that satisfy the
// given condition in an array
static int noOfPermutations(int []a, int n)
{
    // If there is only one element then
    // only one permutation is available
    if (n == 1) {
        return 1;
    }
    
    // Sort the array for calculating
    // the number of elements occurring twice
    Array.Sort(a);
    
    // If the maximum element is occurring
    // twice, then the number of permutations
    // satisfying the condition is 0
    if (a[n - 1] == a[n - 2]) {
        return 0;
    }
    
    // This variable will store the
    // number of element occurring twice
    int x = 0;
    
    // Loop to check the number of elements
    // occurring twice
    for (int i = 0; i < n - 2; ++i) {
    
        // Check if this element
        // is occurring twice
        if (a[i] == a[i + 1]) {
    
            // If this element is occurring
            // twice then check if this number
            // is occurring more than twice
            if (a[i] == a[i + 2]) {
    
                // If element occurring thrice
                // then no permutation will
                // satisfy the given condition
                return 0;
            }
    
            x++;
    
            // Since we have checked the next
            // element as well, then we can
            // increment the loop variable
            i++;
        }
    }
    
    return pow(2, n - 2 * x - 1);
}
    
// Driver code
public static void Main(String[] args)
{
    int []a = { 1, 2, 2, 3, 4 };
    int n = a.Length;
    int num = noOfPermutations(a, n);
    Console.Write(num);
}
}
   
// This code is contributed by 29AjayKumar


输出:
4

时间复杂度: O(N * log(N))