字符串可以具有的不同排列数

给我们一个仅包含小写字母的字符串。任务是找出该字符串可以生成的不同排列的总数。

例子：

Input : aab
Output : 3
Different permutations are "aab",
"aba" and "baa".

Input : ybghjhbuytb
Output : 1663200

一个简单的解决方案是找到所有不同的排列并对它们进行计数。

我们可以找到计数而不找到所有排列。想法是找到所有重复的字符，即所有字符的频率。然后，我们通过的阶乘字符的频率的乘法划分字符串的长度的阶乘。

在第二个示例中，字符数为11，此处的h和y重复2次，而g重复3次。
因此，排列数为11！ /(2！2！3！)= 1663200

以下是上述想法的实现。

C++

// C++ program to find number of distinct
// permutations of a string.
#include
using namespace std;
const int MAX_CHAR = 26;
  
// Utility function to find factorial of n.
int factorial(int n)
{
    int fact = 1;
    for (int i = 2; i <= n; i++)
        fact = fact * i;
    return fact;
}
  
// Returns count of distinct permutations
// of str.
int countDistinctPermutations(string str)
{
    int length = str.length();
  
    int freq[MAX_CHAR];
    memset(freq, 0, sizeof(freq));
  
    // finding frequency of all the lower case
    // alphabet and storing them in array of
    // integer
    for (int i = 0; i < length; i++)
        if (str[i] >= 'a')
            freq[str[i] - 'a']++;
  
    // finding factorial of number of appearances
    // and multiplying them since they are
    // repeating alphabets
    int fact = 1;
    for (int i = 0; i < MAX_CHAR; i++)
        fact = fact * factorial(freq[i]);
  
    // finding factorial of size of string and
    // dividing it by factorial found after
    // multiplying
    return factorial(length) / fact;
}
  
// Driver code
int main()
{
    string str = "fvvfhvgv";
    printf("%d", countDistinctPermutations(str));
    return 0;
}

Java

// Java program to find number of distinct
// permutations of a string.
public class GFG {
      
    static final int MAX_CHAR = 26;
       
    // Utility function to find factorial of n.
    static int factorial(int n)
    {
        int fact = 1;
        for (int i = 2; i <= n; i++)
            fact = fact * i;
        return fact;
    }
       
    // Returns count of distinct permutations
    // of str.
    static int countDistinctPermutations(String str)
    {
        int length = str.length();
       
        int[] freq = new int[MAX_CHAR];
       
        // finding frequency of all the lower case
        // alphabet and storing them in array of
        // integer
        for (int i = 0; i < length; i++)
            if (str.charAt(i) >= 'a')
                freq[str.charAt(i) - 'a']++;
       
        // finding factorial of number of appearances
        // and multiplying them since they are
        // repeating alphabets
        int fact = 1;
        for (int i = 0; i < MAX_CHAR; i++)
            fact = fact * factorial(freq[i]);
       
        // finding factorial of size of string and
        // dividing it by factorial found after
        // multiplying
        return factorial(length) / fact;
    }
       
    // Driver code
    public static void main(String args[])
    {
        String str = "fvvfhvgv";
        System.out.println(countDistinctPermutations(str));
    }
}
// This code is contributed by Sumit Ghosh

Python

# Python program to find number of distinct
# permutations of a string.
  
MAX_CHAR = 26
  
# Utility function to find factorial of n.
def factorial(n) :
      
    fact = 1;
    for i in range(2, n + 1) :
        fact = fact * i;
    return fact
        
# Returns count of distinct permutations
# of str.
def countDistinctPermutations(st) :
      
    length = len(st)
    freq = [0] * MAX_CHAR
      
    # finding frequency of all the lower
    # case alphabet and storing them in
    # array of integer
    for i in range(0, length) :
        if (st[i] >= 'a') :
            freq[(ord)(st[i]) - 97] = freq[(ord)(st[i]) - 97] + 1;
    
    # finding factorial of number of
    # appearances and multiplying them
    # since they are repeating alphabets
    fact = 1
    for i in range(0, MAX_CHAR) :
        fact = fact * factorial(freq[i])
    
    # finding factorial of size of string
    # and dividing it by factorial found
    # after multiplying
    return factorial(length) / fact
  
# Driver code
st = "fvvfhvgv"
print (countDistinctPermutations(st))
  
# This code is contributed by Nikita Tiwari.

C#

// C# program to find number of distinct
// permutations of a string.
using System;
  
public class GFG {
      
    static int MAX_CHAR = 26;
      
    // Utility function to find factorial of n.
    static int factorial(int n)
    {
        int fact = 1;
        for (int i = 2; i <= n; i++)
            fact = fact * i;
              
        return fact;
    }
      
    // Returns count of distinct permutations
    // of str.
    static int countDistinctPermutations(String str)
    {
        int length = str.Length;
      
        int[] freq = new int[MAX_CHAR];
      
        // finding frequency of all the lower case
        // alphabet and storing them in array of
        // integer
        for (int i = 0; i < length; i++)
            if (str[i] >= 'a')
                freq[str[i] - 'a']++;
      
        // finding factorial of number of appearances
        // and multiplying them since they are
        // repeating alphabets
        int fact = 1;
        for (int i = 0; i < MAX_CHAR; i++)
            fact = fact * factorial(freq[i]);
      
        // finding factorial of size of string and
        // dividing it by factorial found after
        // multiplying
        return factorial(length) / fact;
    }
      
    // Driver code
    public static void Main(String []args)
    {
        String str = "fvvfhvgv";
          
        Console.Write(countDistinctPermutations(str));
    }
}
  
// This code is contributed by parashar.

输出：

840