GeeksforGeeks App
Open App
Browser
Continue

# Check if all strings of an array can be made same by interchanging characters

Given an array arr[] of size N consisting of equal length strings, the task is to check if it is possible to make all strings of the array can be equal or not by swapping any character of one string with any character of the same string or another string.
Note: Perform the operation 0 or more times.

Examples:

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

Approach: The problem can be solved by counting the frequency of each character of the given array and check if it is divisible by N or not. Follow the steps below to solve the problem:

1. Initialize an array, hash[256]={0} to store the frequency of characters.
2. Traverse hash[] array and check if the frequency of all characters is divisible by N or not.
3. If the frequency of all characters is divisible by N, then print Yes.
4. Otherwise, print No.

Below is the implementation of the above approach:

## 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

 ``

Output:

`Yes`

Time Complexity: O(N)
Auxiliary Space: O(1), since no extra space has been taken.

Approach 2: Dynamic Programming:

Here’s a dynamic programming approach to check if all strings are equal after swap operations. We can model this problem as a graph problem, where each string is a node in the graph, and there is an edge between two nodes if and only if we can transform one string into the other by swapping two characters.

Here is the steps to above procedure:

• We can use a dynamic programming approach to compute the connected components of the graph. We can represent each connected component as a set of integers, where each integer corresponds to a node in the graph. We can compute the connected components of the graph using depth-first search or breadth-first search.
• Once we have computed the connected components of the graph, we can check if each connected component satisfies the condition that all strings are equal after swap operations. To do this, we can count the frequency of each character in the first string of the connected component, and then check if the frequency of each character is the same in all strings in the connected component.

Here’s the code implementation of this approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to check if all strings``// are equal after swap operations``bool` `checkEqual(string arr[], ``int` `N)``{``    ``// Stores the length of string``    ``int` `M = arr[0].length();``    ` `    ``// Construct the graph``    ``vector<``int``> adj[N];``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = i+1; j < N; j++) {``            ``int` `cnt = 0;``            ``for` `(``int` `k = 0; k < M; k++) {``                ``if` `(arr[i][k] != arr[j][k]) {``                    ``cnt++;``                ``}``                ``if` `(cnt > 2) {``                    ``break``;``                ``}``            ``}``            ``if` `(cnt == 2) {``                ``adj[i].push_back(j);``                ``adj[j].push_back(i);``            ``}``        ``}``    ``}``    ` `    ``// Compute the connected components``    ``vector> components;``    ``vector<``bool``> visited(N, ``false``);``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(!visited[i]) {``            ``set<``int``> component;``            ``queue<``int``> q;``            ``q.push(i);``            ``visited[i] = ``true``;``            ``while` `(!q.empty()) {``                ``int` `u = q.front();``                ``q.pop();``                ``component.insert(u);``                ``for` `(``int` `v : adj[u]) {``                    ``if` `(!visited[v]) {``                        ``q.push(v);``                        ``visited[v] = ``true``;``                    ``}``                ``}``            ``}``            ``components.push_back(component);``        ``}``    ``}``    ` `    ``// Check if each connected component satisfies the condition``    ``for` `(set<``int``> component : components) {``        ``int` `freq[256] = {0};``        ``for` `(``int` `u : component) {``            ``for` `(``int` `k = 0; k < M; k++) {``                ``freq[arr[u][k]]++;``            ``}``        ``}``        ``for` `(``int` `i = 0; i < 256; i++) {``            ``if` `(freq[i] % component.size() != 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;``}`

## Python3

 `from` `collections ``import` `deque` `# Function to check if all strings are equal after swap operations``def` `checkEqual(arr, N):``    ``# Stores the length of string``    ``M ``=` `len``(arr[``0``])` `    ``# Construct the graph``    ``adj ``=` `[[] ``for` `_ ``in` `range``(N)]``    ``for` `i ``in` `range``(N):``        ``for` `j ``in` `range``(i``+``1``, N):``            ``cnt ``=` `0``            ``for` `k ``in` `range``(M):``                ``if` `arr[i][k] !``=` `arr[j][k]:``                    ``cnt ``+``=` `1``                ``if` `cnt > ``2``:``                    ``break``            ``if` `cnt ``=``=` `2``:``                ``adj[i].append(j)``                ``adj[j].append(i)` `    ``# Compute the connected components``    ``components ``=` `[]``    ``visited ``=` `[``False``]``*``N``    ``for` `i ``in` `range``(N):``        ``if` `not` `visited[i]:``            ``component ``=` `set``()``            ``q ``=` `deque()``            ``q.append(i)``            ``visited[i] ``=` `True``            ``while` `q:``                ``u ``=` `q.popleft()``                ``component.add(u)``                ``for` `v ``in` `adj[u]:``                    ``if` `not` `visited[v]:``                        ``q.append(v)``                        ``visited[v] ``=` `True``            ``components.append(component)` `    ``# Check if each connected component satisfies the condition``    ``for` `component ``in` `components:``        ``freq ``=` `[``0``]``*``256``        ``for` `u ``in` `component:``            ``for` `k ``in` `range``(M):``                ``freq[``ord``(arr[u][k])] ``+``=` `1``        ``for` `i ``in` `range``(``256``):``            ``if` `freq[i] ``%` `len``(component) !``=` `0``:``                ``return` `False` `    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``"fdd"``, ``"fhh"``]``    ``N ``=` `len``(arr)` `    ``if` `checkEqual(arr, N):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)`

Output:

`Yes`

Time Complexity: O(N*M^2)
Auxiliary Space: O(1), since no extra space has been taken.

My Personal Notes arrow_drop_up