计算排列，使序列不递减

给定整数数组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.

Javascript

 
// Javascript implementation of the approach
 
const N = 20;
 
// To store the factorials
let fact = new Array(N);
 
// Function to update fact[] array
// such that fact[i] = i!
function pre()
{
 
    // 0! = 1
    fact[0] = 1;
    for (let i = 1; i < N; i++) {
 
        // i! = i * (i - 1)!
        fact[i] = i * fact[i - 1];
    }
}
 
// Function to return the count
// of possible permutations
function CountPermutation(a, n)
{
 
    // To store the result
    let ways = 1;
 
    // Sort the array
    a.sort();
 
    // Initial size of the block
    let size = 1;
    for (let 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
 
    let a = [ 1, 2, 4, 4, 2, 4 ];
    let n = a.length;
 
    // Pre-calculating factorials
    pre();
 
    document.write(CountPermutation(a, n));
 

输出：

12

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