Given two strings **s1** and **s2** of same length, the task is to count the minimum number of pairs of characters **(c1, c2)** such that by transforming **c1 to c2** or **c2 to c1** any number of times in any string make both the strings same.

**Examples:**

Input:s1 = “abb”, s2 = “dad”

Output:2

Transform ‘a’ -> ‘d’, ‘b’ -> ‘a’ and ‘b’ -> ‘a’ -> ‘d’ in s1.

We can not take (a, d), (b, a), (b, d) as pairs because

(b, d) can be achieved by following transformation ‘b’ -> ‘a’ -> ‘d’

Input:s1 = “drpepper”, s2 = “cocacola”

Output:7

**Approach:** This Problem can be solved by using Graphs or Disjoint Sets. Build an empty graph G and iterate through the strings. Add an edge in graph G only if one of the following conditions is met:

- Both
**s1[i]**and**s2[i]**are not in G. **s1[i]**is in G but**s2[i]**is not in G.**s2[i]**is in G but**s1[i]**is not in G.- There is no path from
**s1[i]**to**s2[i]**.

The minimum number of pairs will be the count of edges in the final graph G.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function which will check if there is ` `// a path between a and b by using BFS ` `bool` `checkPath(` `char` `a, ` `char` `b, ` ` ` `map<` `char` `, vector<` `char` `>> &G) ` `{ ` ` ` `map<` `char` `, ` `bool` `> visited; ` ` ` `deque<` `char` `> queue; ` ` ` `queue.push_back(a); ` ` ` `visited[a] = ` `true` `; ` ` ` ` ` `while` `(!queue.empty()) ` ` ` `{ ` ` ` `int` `n = queue.front(); ` ` ` `queue.pop_front(); ` ` ` ` ` `if` `(n == b) ` `return` `true` `; ` ` ` `for` `(` `auto` `i : G[n]) ` ` ` `{ ` ` ` `if` `(visited[i] == ` `false` `) ` ` ` `{ ` ` ` `queue.push_back(i); ` ` ` `visited[i] = ` `true` `; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `return` `false` `; ` `} ` ` ` `// Function to return the ` `// minimum number of pairs ` `int` `countPairs(string s1, string s2, ` ` ` `map<` `char` `, vector<` `char` `>> &G, ` `int` `x) ` `{ ` ` ` ` ` `// To store the count of pairs ` ` ` `int` `count = 0; ` ` ` ` ` `// Iterating through the strings ` ` ` `for` `(` `int` `i = 0; i < x; i++) ` ` ` `{ ` ` ` `char` `a = s1[i]; ` ` ` `char` `b = s2[i]; ` ` ` ` ` `// Check if we can add an edge in the graph ` ` ` `if` `(G.find(a) != G.end() and ` ` ` `G.find(b) == G.end() and a != b) ` ` ` `{ ` ` ` `G[a].push_back(b); ` ` ` `G[b].push_back(a); ` ` ` `count++; ` ` ` `} ` ` ` `else` `if` `(G.find(b) != G.end() and ` ` ` `G.find(a) == G.end() and a != b) ` ` ` `{ ` ` ` `G[b].push_back(a); ` ` ` `G[a].push_back(b); ` ` ` `count++; ` ` ` `} ` ` ` `else` `if` `(G.find(a) == G.end() and ` ` ` `G.find(b) == G.end() and a != b) ` ` ` `{ ` ` ` `G[a].push_back(b); ` ` ` `G[b].push_back(a); ` ` ` `count++; ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `if` `(!checkPath(a, b, G) and a != b) ` ` ` `{ ` ` ` `G[a].push_back(b); ` ` ` `G[b].push_back(a); ` ` ` `count++; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// Return the count of pairs ` ` ` `return` `count; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `string s1 = ` `"abb"` `, s2 = ` `"dad"` `; ` ` ` `int` `x = s1.length(); ` ` ` `map<` `char` `, vector<` `char` `>> G; ` ` ` `cout << countPairs(s1, s2, G, x) << endl; ` ` ` ` ` `return` `0; ` `} ` ` ` `// This code is contributed by ` `// sanjeev2552 ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` `from` `collections ` `import` `defaultdict, deque ` ` ` `# Function which will check if there is ` `# a path between a and b by using BFS ` `def` `Check_Path(a, b, G): ` ` ` `visited ` `=` `defaultdict(` `bool` `) ` ` ` `queue ` `=` `deque() ` ` ` `queue.append(a) ` ` ` `visited[a]` `=` `True` ` ` `while` `queue: ` ` ` `n ` `=` `queue.popleft() ` ` ` `if` `n ` `=` `=` `b: ` ` ` `return` `True` ` ` `for` `i ` `in` `list` `(G[n]): ` ` ` `if` `visited[i]` `=` `=` `False` `: ` ` ` `queue.append(i) ` ` ` `visited[i]` `=` `True` ` ` `return` `False` ` ` `# Function to return the minimum number of pairs ` `def` `countPairs(s1, s2, G): ` ` ` `name ` `=` `defaultdict(` `bool` `) ` ` ` ` ` `# To store the count of pairs ` ` ` `count ` `=` `0` ` ` ` ` `# Iterating through the strings ` ` ` `for` `i ` `in` `range` `(x): ` ` ` `a ` `=` `s1[i] ` ` ` `b ` `=` `s2[i] ` ` ` ` ` `# Check if we can add an edge in the graph ` ` ` `if` `a ` `in` `G ` `and` `b ` `not` `in` `G ` `and` `a !` `=` `b: ` ` ` `G[a].append(b) ` ` ` `G[b].append(a) ` ` ` `count` `+` `=` `1` ` ` `elif` `b ` `in` `G ` `and` `a ` `not` `in` `G ` `and` `a !` `=` `b: ` ` ` `G[b].append(a) ` ` ` `G[a].append(b) ` ` ` `count` `+` `=` `1` ` ` `elif` `a ` `not` `in` `G ` `and` `b ` `not` `in` `G ` `and` `a !` `=` `b: ` ` ` `G[a].append(b) ` ` ` `G[b].append(a) ` ` ` `count` `+` `=` `1` ` ` `else` `: ` ` ` `if` `not` `Check_Path(a, b, G) ` `and` `a !` `=` `b: ` ` ` `G[a].append(b) ` ` ` `G[b].append(a) ` ` ` `count` `+` `=` `1` ` ` ` ` `# Return the count of pairs ` ` ` `return` `count ` ` ` `# Driver code ` `if` `__name__` `=` `=` `"__main__"` `: ` ` ` `s1 ` `=` `"abb"` ` ` `s2 ` `=` `"dad"` ` ` `x ` `=` `len` `(s1) ` ` ` `G ` `=` `defaultdict(` `list` `) ` ` ` `print` `(countPairs(s1, s2, G)) ` |

*chevron_right*

*filter_none*

**Output:**

2

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Minimum number of operations required to make two strings equal
- Minimum number of given operations required to make two strings equal
- Find the minimum number of preprocess moves required to make two strings equal
- Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
- Minimum number of swaps required to make the string K periodic
- Minimum changes required to make all element in an array equal
- Minimum edges required to add to make Euler Circuit
- Minimum deletions required to make GCD of the array equal to 1
- Minimum removals required to make ranges non-overlapping
- Minimum operation required to make a balanced sequence
- Minimum characters required to make a password strong
- Minimum deletions required to make frequency of each letter unique
- Minimum increment/decrement operations required to make Median as X
- Minimum swaps required to make a binary string alternating
- Minimum array insertions required to make consecutive difference <= K
- Minimum operations required to make the string satisfy the given condition
- Minimum operations required to make every element greater than or equal to K
- Minimum swaps required to make a binary string divisible by 2^k
- Minimum edges required to make a Directed Graph Strongly Connected
- Minimum Count of Bit flips required to make a Binary String Palindromic

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.