Open In App

Check if given strings can be made same by swapping two characters of same or different strings

Given an array of equal-length strings, arr[] of size N, the task is to check if all the strings can be made equal by repeatedly swapping any pair of characters of same or different strings from the given array. If found to be true, then print “YES”. Otherwise, print “NO”.

Examples:



Input: arr[] = { “acbdd”, “abcee” } 
Output: YES 
Explanation: 
Swapping arr[0][1] and arr[0][2] modifies arr[] to { “abcdd”, “abcee” } 
Swapping arr[0][3] and arr[1][4] modifies arr[] to { “abced”, “abced” } 
Therefore, the required output is “YES”.

Input: arr[] = { “abb”, “acc”, “abc” } 
Output: YES 
Explanation: 
Swapping arr[0][2] with arr[1][1] modifies arr[] to { “abc”, “abc”, “abc” }. 
Therefore, the required output is “YES”.



Approach: The idea is to count the frequency of each distinct character of all the strings and check if the frequency of each distinct character is divisible by N or not. If found to be true, then print “YES”. Otherwise, print “NO”. Follow the steps below to solve the problem:

Below is the implementation of the above approach:




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
bool isEqualStrings(string arr[], int N)
{
    // Stores length of string
    int M = arr[0].length();
 
    // Store frequency of each distinct
    // character of the strings
    int cntFreq[256] = { 0 };
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Iterate over the characters
        for (int j = 0; j < M; j++) {
 
            // Update frequency
            // of arr[i][j]
            cntFreq[arr[i][j] - 'a']++;
        }
    }
 
    // Traverse the array cntFreq[]
    for (int i = 0; i < 256; i++) {
 
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0) {
 
            return false;
        }
    }
 
    return true;
}
 
// Driver Code
int main()
{
    string arr[] = { "aab", "bbc", "cca" };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    if (isEqualStrings(arr, N)) {
 
        cout << "YES";
    }
    else {
 
        cout << "NO";
    }
 
    return 0;
}




// Java program to implement
// the above approach 
class GFG{
    
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
static boolean isEqualStrings(String[] arr, int N)
{
     
    // Stores length of string
    int M = arr[0].length();
  
    // Store frequency of each distinct
    // character of the strings
    int[] cntFreq = new int[256];
    for(int i = 0; i < N; i++)
    {
        cntFreq[i] = 0;
    }
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Iterate over the characters
        for(int j = 0; j < M; j++)
        {
             
            // Update frequency
            // of arr[i].charAt(j)
            cntFreq[arr[i].charAt(j) - 'a'] += 1;
        }
    }
  
    // Traverse the array cntFreq[]
    for(int i = 0; i < 256; i++)
    {
         
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
    
// Driver Code
public static void main(String[] args)
{
    String[] arr = { "aab", "bbc", "cca" };
    int N = arr.length;
     
    // Function Call
    if (isEqualStrings(arr, N))
    {
        System.out.println("YES");
    }
    else
    {
        System.out.println("NO");
    }
}
}
 
// This code is contributed by AnkThon




# Python3 program to implement
# the above approach
 
# Function to check if all strings can
# be made equal by swapping any pair of
# characters from the same or different
# strings
def isEqualStrings(arr, N):
 
    # Stores length of string
    M = len(arr[0])
 
    # Store frequency of each distinct
    # character of the strings
    cntFreq = [0] * 256
 
    # Traverse the array
    for i in range(N):
 
        # Iterate over the characters
        for j in range(M): 
             
            # Update frequency
            # of arr[i][j]
            cntFreq[ord(arr[i][j]) - ord('a')] += 1
             
    # Traverse the array cntFreq[]
    for i in range(256):
         
        # If cntFreq[i] is
        # divisible by N or not
        if (cntFreq[i] % N != 0):
            return False
         
    return True
 
# Driver Code
if __name__ == "__main__" :
     
    arr = [ "aab", "bbc", "cca" ]
    N = len(arr)
 
    # Function Call
    if isEqualStrings(arr, N):
        print("YES")
    else:
        print("NO")
     
# This code is contributed by jana_sayantan




// C# program to implement
// the above approach 
using System;
    
class GFG{
    
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
static bool isEqualStrings(string[] arr, int N)
{
     
    // Stores length of string
    int M = arr[0].Length;
  
    // Store frequency of each distinct
    // character of the strings
    int[] cntFreq = new int[256];
    for(int i = 0; i < N; i++)
    {
        cntFreq[i] = 0;
    }
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Iterate over the characters
        for(int j = 0; j < M; j++)
        {
             
            // Update frequency
            // of arr[i][j]
            cntFreq[arr[i][j] - 'a'] += 1;
        }
    }
  
    // Traverse the array cntFreq[]
    for(int i = 0; i < 256; i++)
    {
         
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
    
// Driver Code
public static void Main()
{
    string[] arr = { "aab", "bbc", "cca" };
    int N = arr.Length;
  
    // Function Call
    if (isEqualStrings(arr, N))
    {
        Console.WriteLine("YES");
    }
    else
    {
        Console.WriteLine("NO");
    }
}
}
 
// This code is contributed by susmitakundugoaldanga




<script>
 
// javascript program of the above approach
 
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
function isEqualStrings(arr, N)
{
     
    // Stores length of string
    let M = arr[0].length;
  
    // Store frequency of each distinct
    // character of the strings
    let cntFreq = new Array(256).fill(0);
    for(let i = 0; i < N; i++)
    {
        cntFreq[i] = 0;
    }
     
    // Traverse the array
    for(let i = 0; i < N; i++)
    {
         
        // Iterate over the characters
        for(let j = 0; j < M; j++)
        {
             
            // Update frequency
            // of arr[i].charAt(j)
            cntFreq[arr[i][j] - 'a'] += 1;
        }
    }
  
    // Traverse the array cntFreq[]
    for(let i = 0; i < 256; i++)
    {
         
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
 
    // Driver Code
     
    let arr = [ "aab", "bbc", "cca" ];
    let N = arr.length;
     
    // Function Call
    if (isEqualStrings(arr, N))
    {
        document.write("YES");
    }
    else
    {
        document.write("NO");
    }
 
// This code is contributed by target_2.
</script>

Output
YES

Time Complexity: O(N * M + 256), where M is the length of the string 
Auxiliary Space: O(256)

Approach 2: Dynamic Programming:

The given problem can be solved using a dynamic programming (DP) approach as well. The idea is to first check if all the strings have the same length or not. If not, then we cannot make them equal by swapping any pair of characters. Otherwise, we can proceed as follows:




#include <bits/stdc++.h>
using namespace std;
 
bool isEqualStrings(string arr[], int N) {
    int M = arr[0].length();
 
    // Create a frequency array for all characters
    // in the input strings
    int cntFreq[26] = { 0 };
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cntFreq[arr[i][j] - 'a']++;
        }
    }
 
    // Traverse the frequency array
    for (int i = 0; i < 26; i++) {
        // If frequency of any character is not a
        // multiple of n, return false
        if (cntFreq[i] % N != 0) {
            return false;
        }
    }
 
    // If all characters have a frequency that is a
    // multiple of n, return true
    return true;
}
 
int main() {
    string arr[] = { "aab", "bbc", "cca" };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    if (isEqualStrings(arr, N)) {
        cout << "YES";
    } else {
        cout << "NO";
    }
 
    return 0;
}




public class Main {
    public static boolean isEqualStrings(String[] arr, int N) {
        int M = arr[0].length();
 
        // Create a frequency array for all characters
        // in the input strings
        int[] cntFreq = new int[26];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                cntFreq[arr[i].charAt(j) - 'a']++;
            }
        }
 
        // Traverse the frequency array
        for (int i = 0; i < 26; i++) {
            // If frequency of any character is not a
            // multiple of n, return false
            if (cntFreq[i] % N != 0) {
                return false;
            }
        }
 
        // If all characters have a frequency that is a
        // multiple of n, return true
        return true;
    }
 
    public static void main(String[] args) {
        String[] arr = {"aab", "bbc", "cca"};
        int N = arr.length;
 
        if (isEqualStrings(arr, N)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}




def isEqualStrings(arr, N):
    M = len(arr[0])
 
    # Create a frequency array for all characters
    # in the input strings
    cntFreq = [0] * 26
    for i in range(N):
        for j in range(M):
            cntFreq[ord(arr[i][j]) - ord('a')] += 1
 
    # Traverse the frequency array
    for i in range(26):
        # If frequency of any character is not a
        # multiple of n, return false
        if cntFreq[i] % N != 0:
            return False
 
    # If all characters have a frequency that is a
    # multiple of n, return true
    return True
 
 
arr = ["aab", "bbc", "cca"]
N = len(arr)
 
if isEqualStrings(arr, N):
    print("YES")
else:
    print("NO")




using System;
 
class MainClass {
static bool IsEqualStrings(string[] arr, int N) {
int M = arr[0].Length;
      // Create a frequency array for all characters
    // in the input strings
    int[] cntFreq = new int[26];
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cntFreq[arr[i][j] - 'a']++;
        }
    }
 
    // Traverse the frequency array
    for (int i = 0; i < 26; i++) {
        // If frequency of any character is not a
        // multiple of n, return false
        if (cntFreq[i] % N != 0) {
            return false;
        }
    }
 
    // If all characters have a frequency that is a
    // multiple of n, return true
    return true;
}
 
public static void Main(string[] args) {
    string[] arr = { "aab", "bbc", "cca" };
    int N = arr.Length;
 
    if (IsEqualStrings(arr, N)) {
        Console.WriteLine("YES");
    } else {
        Console.WriteLine("NO");
    }
}
}




function isEqualStrings(arr, N) {
    // Calculate the length of the first string in the array
    let M = arr[0].length;
    // Initialize a frequency array cntFreq for all characters
    // in the input strings
    let cntFreq = new Array(26).fill(0);
    for (let i = 0; i < N; i++) {
        for (let j = 0; j < M; j++) {
            // Count the frequency of each character in each
            // string by incrementing the corresponding index in cntFreq
            cntFreq[arr[i][j].charCodeAt(0) - 'a'.charCodeAt(0)]++;
        }
    }
    // Loop through each character in cntFreq and check
    // if its frequency is a multiple of N. If any character's
    // frequency is not a multiple of N, return false.
    // If all characters have a frequency that is a multiple of N, return true.
    for (let i = 0; i < 26; i++) {
        if (cntFreq[i] % N !== 0) {
            return false;
        }
    }
    return true;
}
 
let arr = ["aab", "bbc", "cca"];
let N = arr.length;
if (isEqualStrings(arr, N)) {
    console.log("YES");
} else {
    console.log("NO");
}

Output
YES

Time Complexity: O(N * M), where M is the length of the string 
Auxiliary Space: O(1)


Article Tags :