检查是否可以通过交换字符使数组的所有字符串相同

给定的阵列ARR大小为N的组成等于长度字符串的[]中，任务是检查是否能够使该阵列的所有字符串可以等于或不通过交换一个字符串中的任意的字符具有相同的字符串的任何字符或其他字符串。
注意：执行0次或多次操作。

例子：

Input : arr[] = {“fdd”, “fhh”}
Output: Yes
Explanation:
Swap(arr[0][1], arr[1][1]) then arr[]={“fhd”, “fdh”}
Swap(arr[1][1], arr[1][2]) then arr[]={“fhd”, “fhd”}. Therefore, it is possible to make all strings equal.

Input: arr[] = {“fde”, “fhg”}
Output: No

方法：可以通过计算给定数组的每个字符的频率并检查它是否可以被N整除来解决该问题。请按照以下步骤解决问题：

1. 初始化一个数组， hash[256]={0}来存储字符的频率。
2. 遍历hash[]数组并检查所有字符的频率是否可以被N整除。
3. 如果所有字符的频率都可以被N整除，则打印Yes 。
4. 否则，打印No 。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
// Function to check if all strings
// are equal after swap operations
bool checkEqual(string arr[], int N)
{
    // Stores the frequency
    // of characters
    int hash[256] = { 0 };
 
    // Stores the length of string
    int M = arr[0].length();
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
        // Traverse each string
        for (int j = 0; j < M; j++) {
            hash[arr[i][j]]++;
        }
    }
 
    // Check if frequency of character
    // is divisible by N
    for (int i = 0; i < 256; i++) {
        if (hash[i] % N != 0) {
            return false;
        }
    }
 
    return true;
}
 
// Driver Code
int main()
{
 
    string arr[] = { "fdd", "fhh" };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    if (checkEqual(arr, N)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
 
    return 0;
}

Java

// Java Program to implement
// the above approach
class GFG{
 
// Function to check if all Strings
// are equal after swap operations
static boolean checkEqual(String arr[],
                          int N)
{
  // Stores the frequency
  // of characters
  int hash[] = new int[256];
 
  // Stores the length of String
  int M = arr[0].length();
 
  // Traverse the array
  for (int i = 0; i < N; i++)
  {
    // Traverse each String
    for (int j = 0; j < M; j++)
    {
      hash[arr[i].charAt(j)]++;
    }
  }
 
  // Check if frequency of character
  // is divisible by N
  for (int i = 0; i < 256; i++)
  {
    if (hash[i] % N != 0)
    {
      return false;
    }
  }
 
  return true;
}
 
// Driver Code
public static void main(String[] args)
{
  String arr[] = {"fdd", "fhh"};
  int N = arr.length;
 
  if (checkEqual(arr, N))
  {
    System.out.print("Yes");
  }
  else
  {
    System.out.print("No");
  }
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program to implement
# the above approach
 
# Function to check if all strings
# are equal after swap operations
def checkEqual(arr, N):
 
    # Stores the frequency
    # of characters
    hash = [0] * 256
 
    # Stores the length of string
    M = len(arr[0])
 
    # Traverse the array
    for i in range(N):
         
        # Traverse each string
        for j in range(M):
            hash[ord(arr[i][j])] += 1
 
    # Check if frequency of character
    # is divisible by N
    for i in range(256):
        if(hash[i] % N != 0):
            return False
 
    return True
 
# Driver Code
arr = [ "fdd", "fhh" ]
N = len(arr)
 
# Function call
if(checkEqual(arr, N)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to check if all Strings
// are equal after swap operations
static bool checkEqual(String []arr,
                       int N)
{
     
    // Stores the frequency
    // of characters
    int []hash = new int[256];
     
    // Stores the length of String
    int M = arr[0].Length;
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Traverse each String
        for(int j = 0; j < M; j++)
        {
            hash[arr[i][j]]++;
        }
    }
     
    // Check if frequency of character
    // is divisible by N
    for(int i = 0; i < 256; i++)
    {
        if (hash[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
 
// Driver Code
public static void Main(String[] args)
{
    String []arr = { "fdd", "fhh" };
    int N = arr.Length;
     
    if (checkEqual(arr, N))
    {
        Console.Write("Yes");
    }
    else
    {
        Console.Write("No");
    }
}
}
 
// This code is contributed by Amit Katiyar

Javascript

 
// Javascript program to implement
// the above approach
 
// Function to check if all strings
// are equal after swap operations
function checkEqual(arr, N)
{
     
    // Stores the frequency
    // of characters
    var hash = Array(256).fill(0);
 
    // Stores the length of string
    var M = arr[0].length;
 
    // Traverse the array
    for(var i = 0; i < N; i++)
    {
         
        // Traverse each string
        for(var j = 0; j < M; j++)
        {
            hash[arr[i][j]]++;
        }
    }
 
    // Check if frequency of character
    // is divisible by N
    for(var i = 0; i < 256; i++)
    {
        if (hash[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
 
// Driver Code
var arr = ["fdd", "fhh"];
var N = arr.length;
if (checkEqual(arr, N))
{
    document.write("Yes");
}
else
{
    document.write("No");
}
 
// This code is contributed by importantly
 

输出：

Yes

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。