计算排列，使序列不递减

给定整数数组arr [] ，任务是查找数组的排列数，以使排列按递增顺序进行，即arr [0]≤arr [1]≤arr [2]≤…≤arr [n – 1] 。

例子：

Input: arr[] = {1, 2, 1}
Output: 2
1, 1, 2 and 1, 1, 2 are the only valid permutations.

Input: arr[] = {5, 4, 4, 5}
Output: 4

方法：序列应不降序，即arr [0]≤arr [1]≤arr [2]≤…≤arr [n – 1] 。
首先，对数组排序，然后关注所有元素都相等的块，因为这些元素可以在P中重新排列！ P是该块的大小的方法。
排列该块不会违反给定条件。现在，找到所有元素均相等的所有块，并将该单个块的答案乘以最终答案，以获得可能排列的总数。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
#define N 20
  
// To store the factorials
int fact[N];
  
// Function to update fact[] array
// such that fact[i] = i!
void pre()
{
  
    // 0! = 1
    fact[0] = 1;
    for (int i = 1; i < N; i++) {
  
        // i! = i * (i - 1)!
        fact[i] = i * fact[i - 1];
    }
}
  
// Function to return the count
// of possible permutations
int CountPermutation(int a[], int n)
{
  
    // To store the result
    int ways = 1;
  
    // Sort the array
    sort(a, a + n);
  
    // Initial size of the block
    int size = 1;
    for (int i = 1; i < n; i++) {
  
        // Increase the size of block
        if (a[i] == a[i - 1]) {
            size++;
        }
        else {
  
            // Update the result for
            // the previous block
            ways *= fact[size];
  
            // Reset the size to 1
            size = 1;
        }
    }
  
    // Update the result for
    // the last block
    ways *= fact[size];
  
    return ways;
}
  
// Driver code
int main()
{
  
    int a[] = { 1, 2, 4, 4, 2, 4 };
    int n = sizeof(a) / sizeof(a[0]);
  
    // Pre-calculating factorials
    pre();
  
    cout << CountPermutation(a, n);
  
    return 0;
}

Java

//Java implementation of the approach
import java.util.Arrays; 
import java.io.*;
  
class GFG 
{
static int N = 20;
  
// To store the factorials
static int []fact=new int[N];
  
// Function to update fact[] array
// such that fact[i] = i!
static void pre()
{
  
    // 0! = 1
    fact[0] = 1;
    for (int i = 1; i < N; i++)
    {
  
        // i! = i * (i - 1)!
        fact[i] = i * fact[i - 1];
    }
}
  
// Function to return the count
// of possible permutations
static int CountPermutation(int a[], int n)
{
  
    // To store the result
    int ways = 1;
  
    // Sort the array
    Arrays.sort(a);
  
    // Initial size of the block
    int size = 1;
    for (int i = 1; i < n; i++) 
    {
  
        // Increase the size of block
        if (a[i] == a[i - 1]) 
        {
            size++;
        }
        else
        {
  
            // Update the result for
            // the previous block
            ways *= fact[size];
  
            // Reset the size to 1
            size = 1;
        }
    }
  
    // Update the result for
    // the last block
    ways *= fact[size];
  
    return ways;
}
  
// Driver Code
public static void main (String[] args) 
{
    int a[] = { 1, 2, 4, 4, 2, 4 };
    int n = a.length;
      
    // Pre-calculating factorials
    pre();
      
    System.out.println (CountPermutation(a, n));
}
}
  
// This code is contributed by Sachin

Python3

# Python3 implementation of the approach 
N = 20
  
# To store the factorials 
fact = [0] * N; 
  
# Function to update fact[] array 
# such that fact[i] = i! 
def pre() :
  
    # 0! = 1 
    fact[0] = 1; 
    for i in range(1, N):
  
        # i! = i * (i - 1)! 
        fact[i] = i * fact[i - 1]; 
  
# Function to return the count 
# of possible permutations 
def CountPermutation(a, n): 
  
    # To store the result 
    ways = 1; 
  
    # Sort the array 
    a.sort();
  
    # Initial size of the block 
    size = 1; 
    for i in range(1, n):
  
        # Increase the size of block 
        if (a[i] == a[i - 1]):
            size += 1; 
          
        else :
  
            # Update the result for 
            # the previous block 
            ways *= fact[size]; 
  
            # Reset the size to 1 
            size = 1; 
  
    # Update the result for 
    # the last block 
    ways *= fact[size]; 
  
    return ways; 
  
# Driver code 
if __name__ == "__main__" : 
  
    a = [ 1, 2, 4, 4, 2, 4 ]; 
    n = len(a); 
  
    # Pre-calculating factorials 
    pre(); 
  
    print(CountPermutation(a, n)); 
      
# This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;
  
class GFG
{
      
static int N = 20;
  
// To store the factorials
static int []fact = new int[N];
  
// Function to update fact[] array
// such that fact[i] = i!
static void pre()
{
  
    // 0! = 1
    fact[0] = 1;
    for (int i = 1; i < N; i++)
    {
  
        // i! = i * (i - 1)!
        fact[i] = i * fact[i - 1];
    }
}
  
// Function to return the count
// of possible permutations
static int CountPermutation(int []a, int n)
{
  
    // To store the result
    int ways = 1;
  
    // Sort the array
    Array.Sort(a);
  
    // Initial size of the block
    int size = 1;
    for (int i = 1; i < n; i++) 
    {
  
        // Increase the size of block
        if (a[i] == a[i - 1]) 
        {
            size++;
        }
        else
        {
  
            // Update the result for
            // the previous block
            ways *= fact[size];
  
            // Reset the size to 1
            size = 1;
        }
    }
  
    // Update the result for
    // the last block
    ways *= fact[size];
  
    return ways;
}
  
// Driver Code
static public void Main ()
{
    int []a = { 1, 2, 4, 4, 2, 4 };
    int n = a.Length;
      
    // Pre-calculating factorials
    pre();
      
    Console.Write(CountPermutation(a, n));
}
}
  
// This code is contributed by Sachin.

输出：

12

时间复杂度： O(N * logN)