通过交换数组中成对的字符串的前缀，可以计算不同的字符串

给定一个由N个长度为M的数字字符串组成的数组字符串[] ，任务是查找可以通过选择任意两个字符串(例如，从数组中选择i和j)并在它们之间交换所有可能的前缀而生成的不同字符串的数量。
注意：由于答案可能非常大，请以模1000000007为模。

例子：

Input: N = 2 M = 3 string[] = {“112”, “211”} 
Output: 4 
Explanation: 
Swapping “1” and “2” between the strings generates “212” and “111“. 
Swapping “11” and “21” between the strings generates “212” and “111”. 
Swapping “112” and “211” between the strings generates “211” and “112“. 
Therefore, 4 distinct strings are generated.

Input: N = 4 M = 5 string[] = {“12121”, “23545”, “11111”, “71261”} 
Output: 216

方法：考虑一个字符串S的形式S ₁ S ₂ S ₃ S ₄ … S _M，其中S ₁是任何阵列中的字符串的第一个字母，S ₂是任意字符串的第二个字母，及依此类推，问题的答案是count(i)的乘积，其中count(i)是给定字符串位于相同索引处的不同字母的计数。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
#include   
using namespace std;
 
int mod = 1000000007;
 
// Function to count the distinct strings
// possible after swapping the prefixes
// between two possible strings of the array
long countS(string str[],int n, int m)
{
     
    // Stores the count of unique
    // characters for each index
    unordered_map> counts;
 
    for(int i = 0; i < n; i++)
    {
         
        // Store current string
        string s = str[i];
     
        for(int j = 0; j < m; j++)
        {
            counts[j].insert(s[j]);
        }
    }
 
    // Stores the total number of
    // distinct strings possible
    long result = 1;
     
    for(auto index : counts)
    {
        result = (result *
                  counts[index.first].size()) % mod;
    }
     
    // Return the answer
    return result;
}
 
// Driver Code
int main()
{
    string str[] = { "112", "211" };
 
    int N = 2, M = 3;
     
    cout << countS(str, N, M);
     
    return 0;
}
 
// This code is contributed by rutvik_56

Java

// Java Program to implement
// the above approach
import java.util.*;
import java.io.*;
 
public class Main {
 
    static int mod = 1000000007;
 
    // Function to count the distinct strings
    // possible after swapping the prefixes
    // between two possible strings of the array
    public static long countS(String str[], int n, int m)
    {
 
        // Stores the count of unique
        // characters for each index
        Map > counts
            = new HashMap<>();
 
        for (int i = 0; i < m; i++) {
            counts.put(i, new HashSet<>());
        }
 
        for (int i = 0; i < n; i++) {
 
            // Store current string
            String s = str[i];
 
            for (int j = 0; j < m; j++) {
                counts.get(j).add(s.charAt(j));
            }
        }
 
        // Stores the total number of
        // distinct strings possible
        long result = 1;
 
        for (int index : counts.keySet())
            result = (result
                    * counts.get(index).size())
                    % mod;
 
        // Return the answer
        return result;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        String str[] = { "112", "211" };
 
        int N = 2, M = 3;
        System.out.println(countS(str, N, M));
    }
}

Python3

# Python3 program to implement
# the above approach
from collections import defaultdict
 
mod = 1000000007
 
# Function to count the distinct strings
# possible after swapping the prefixes
# between two possible strings of the array
def countS(string: list, n: int, m: int) -> int:
     
    # Stores the count of unique
    # characters for each index
    counts = defaultdict(lambda: set())
 
    for i in range(n):
         
        # Store current string
        s = string[i]
 
        for j in range(m):
            counts[j].add(s[j])
 
    # Stores the total number of
    # distinct strings possible
    result = 1
 
    for index in counts:
        result = (result *
                  len(counts[index])) % mod
 
    # Return the answer
    return result
 
# Driver Code
if __name__ == "__main__":
     
    string = [ "112", "211" ]
 
    N = 2
    M = 3
     
    print(countS(string, N, M))
 
# This code is contributed by sanjeev2552

C#

// C# Program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
static int mod = 1000000007;
 
// Function to count the distinct strings
// possible after swapping the prefixes
// between two possible strings of the array
public static long countS(String []str,
                            int n, int m)
{
 
    // Stores the count of unique
    // characters for each index
    Dictionary > counts = new Dictionary>();
 
    for (int i = 0; i < m; i++)
    {
    counts.Add(i, new HashSet());
    }
 
    for (int i = 0; i < n; i++)
    {
 
    // Store current string
    String s = str[i];
 
    for (int j = 0; j < m; j++)
    {
        counts[j].Add(s[j]);
    }
    }
 
    // Stores the total number of
    // distinct strings possible
    long result = 1;
 
    foreach (int index in counts.Keys)
    result = (result * counts[index].Count) % mod;
 
    // Return the answer
    return result;
}
 
// Driver Code
public static void Main(String[] args)
{
    String []str = { "112", "211" };
 
    int N = 2, M = 3;
    Console.WriteLine(countS(str, N, M));
}
}
 
// This code is contributed by Rajput-Ji

输出：

4

时间复杂度： O(N * M)
辅助空间： O(N)