# Check if one string can be converted to another

• Difficulty Level : Hard
• Last Updated : 20 Dec, 2021

Given two strings str and str1, the task is to check whether one string can be converted to other by using the following operation:

• Convert all the presence of a character by a different character.

For example, if str = “abacd” and operation is to change character ‘a’ to ‘k’, then the resultant str = “kbkcd”
Examples:

Input: str = “abbcaa”; str1 = “bccdbb”
Output: Yes
Explanation: The mappings of the characters are:
c –> d
b –> c
a –> b
Input: str = “abbc”; str1 = “bcca”
Output: No
Explanation: The mapping of characters are:
a –> b
b –> c
c –> a
Here, due to the presence of a cycle, a specific order cannot be found.

Approach:

• According to the given operation, every unique character should map to a unique character may be same or different.
• This can easily be checked by a Hashmap.
• However, this fails in cases where there is a cycle in mapping and a specific order cannot be determined.
• One example of such case is Example 2 above.
• Therefore, for mapping, the first and final characters are stored as edges in a hashmap.
• For finding cycle with the edges, these edges are mapped one by one to a parent and are checked for cycle using Union and Find Algorithm.

Below is the implementation of the above approach.

## CPP

 `// C++ implementation of the above approach.` `#include ` `using` `namespace` `std;` `int` `parent;` `// Function for find` `// from Disjoint set algorithm` `int` `find(``int` `x)` `{` `    ``if` `(x != parent[x])` `        ``return` `parent[x] = find(parent[x]);` `    ``return` `x;` `}`   `// Function for the union` `// from Disjoint set algorithm` `void` `join(``int` `x, ``int` `y)` `{` `    ``int` `px = find(x);` `    ``int` `pz = find(y);` `    ``if` `(px != pz) {` `        ``parent[pz] = px;` `    ``}` `}` `// Function to check if one string` `// can be converted to another.` `bool` `convertible(string s1, string s2)` `{` `    ``// All the characters are checked whether` `    ``// it's either not replaced or replaced` `    ``// by a similar character using a map.` `    ``map<``int``, ``int``> mp;`   `    ``for` `(``int` `i = 0; i < s1.size(); i++) {` `        ``if` `(mp.find(s1[i] - ``'a'``) == mp.end()) {` `            ``mp[s1[i] - ``'a'``] = s2[i] - ``'a'``;` `        ``}` `        ``else` `{` `            ``if` `(mp[s1[i] - ``'a'``] != s2[i] - ``'a'``)` `                ``return` `false``;` `        ``}` `    ``}` `    ``// To check if there are cycles.` `    ``// If yes, then they are not convertible.` `    ``// Else, they are convertible.` `    ``for` `(``auto` `it : mp) {` `        ``if` `(it.first == it.second)` `            ``continue``;` `        ``else` `{` `            ``if` `(find(it.first) == find(it.second))` `                ``return` `false``;` `            ``else` `                ``join(it.first, it.second);` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Function to initialize parent array` `// for union and find algorithm.` `void` `initialize()` `{` `    ``for` `(``int` `i = 0; i < 26; i++) {` `        ``parent[i] = i;` `    ``}` `}` `// Driver code` `int` `main()` `{` `    ``// Your C++ Code` `    ``string s1, s2;` `    ``s1 = ``"abbcaa"``;` `    ``s2 = ``"bccdbb"``;` `    ``initialize();` `    ``if` `(convertible(s1, s2))` `        ``cout << ``"Yes"` `<< endl;` `    ``else` `        ``cout << ``"No"` `<< endl;` `    ``return` `0;` `}`

## Java

 `// Java implementation of the above approach.` `import` `java.util.*;`   `class` `GFG` `{` `    `  `static` `int` `[]parent = ``new` `int``[``26``];`   `// Function for find` `// from Disjoint set algorithm` `static` `int` `find(``int` `x)` `{` `    ``if` `(x != parent[x])` `        ``return` `parent[x] = find(parent[x]);` `    ``return` `x;` `}`   `// Function for the union` `// from Disjoint set algorithm` `static` `void` `join(``int` `x, ``int` `y)` `{` `    ``int` `px = find(x);` `    ``int` `pz = find(y);` `    ``if` `(px != pz)` `    ``{` `        ``parent[pz] = px;` `    ``}` `}` `// Function to check if one String` `// can be converted to another.` `static` `boolean` `convertible(String s1, String s2)` `{` `    ``// All the characters are checked whether` `    ``// it's either not replaced or replaced` `    ``// by a similar character using a map.` `    ``HashMap mp = ``new` `HashMap();`   `    ``for` `(``int` `i = ``0``; i < s1.length(); i++) ` `    ``{` `        ``if` `(!mp.containsKey(s1.charAt(i) - ``'a'``))` `        ``{` `            ``mp.put(s1.charAt(i) - ``'a'``, s2.charAt(i) - ``'a'``);` `        ``}` `        ``else` `        ``{` `            ``if` `(mp.get(s1.charAt(i) - ``'a'``) != s2.charAt(i) - ``'a'``)` `                ``return` `false``;` `        ``}` `    ``}` `    `  `    ``// To check if there are cycles.` `    ``// If yes, then they are not convertible.` `    ``// Else, they are convertible.` `    ``for` `(Map.Entry it : mp.entrySet())` `    ``{` `        ``if` `(it.getKey() == it.getValue())` `            ``continue``;` `        ``else` `        ``{` `            ``if` `(find(it.getKey()) == find(it.getValue()))` `                ``return` `false``;` `            ``else` `                ``join(it.getKey(), it.getValue());` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Function to initialize parent array` `// for union and find algorithm.` `static` `void` `initialize()` `{` `    ``for` `(``int` `i = ``0``; i < ``26``; i++) ` `    ``{` `        ``parent[i] = i;` `    ``}` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``String s1, s2;` `    ``s1 = ``"abbcaa"``;` `    ``s2 = ``"bccdbb"``;` `    ``initialize();` `    ``if` `(convertible(s1, s2))` `        ``System.out.print(``"Yes"` `+ ``"\n"``);` `    ``else` `        ``System.out.print(``"No"` `+ ``"\n"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the above approach.` `parent ``=` `[``0``] ``*` `256`   `# Function for find` `# from Disjoset algorithm` `def` `find(x):` `    ``if` `(x !``=` `parent[x]):` `        ``parent[x] ``=` `find(parent[x])` `        ``return` `parent[x]` `    ``return` `x`   `# Function for the union` `# from Disjoset algorithm` `def` `join(x, y):` `    ``px ``=` `find(x)` `    ``pz ``=` `find(y)` `    ``if` `(px !``=` `pz):` `        ``parent[pz] ``=` `px`   `# Function to check if one string` `# can be converted to another.` `def` `convertible(s1, s2):` `    `  `    ``# All the characters are checked whether` `    ``# it's either not replaced or replaced` `    ``# by a similar character using a map.` `    ``mp ``=` `dict``()`   `    ``for` `i ``in` `range``(``len``(s1)):` `        ``if` `(s1[i] ``in` `mp):` `            ``mp[s1[i]] ``=` `s2[i]` `        ``else``:` `            ``if` `s1[i] ``in` `mp ``and` `mp[s1[i]] !``=` `s2[i]:` `                ``return` `False` `    `  `    ``# To check if there are cycles.` `    ``# If yes, then they are not convertible.` `    ``# Else, they are convertible.` `    ``for` `it ``in` `mp:` `        ``if` `(it ``=``=` `mp[it]):` `            ``continue` `        ``else` `:` `            ``if` `(find(``ord``(it)) ``=``=` `find(``ord``(it))):` `                ``return` `False` `            ``else``:` `                ``join(``ord``(it), ``ord``(it))`   `    ``return` `True`   `# Function to initialize parent array` `# for union and find algorithm.` `def` `initialize():` `    ``for` `i ``in` `range``(``256``):` `        ``parent[i] ``=` `i`   `# Driver code` `s1 ``=` `"abbcaa"` `s2 ``=` `"bccdbb"` `initialize()` `if` `(convertible(s1, s2)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the above approach.` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `    `  `static` `int` `[]parent = ``new` `int``;`   `// Function for find` `// from Disjoint set algorithm` `static` `int` `find(``int` `x)` `{` `    ``if` `(x != parent[x])` `        ``return` `parent[x] = find(parent[x]);` `    ``return` `x;` `}`   `// Function for the union` `// from Disjoint set algorithm` `static` `void` `join``(``int` `x, ``int` `y)` `{` `    ``int` `px = find(x);` `    ``int` `pz = find(y);` `    ``if` `(px != pz)` `    ``{` `        ``parent[pz] = px;` `    ``}` `}`   `// Function to check if one String` `// can be converted to another.` `static` `bool` `convertible(String s1, String s2)` `{` `    ``// All the characters are checked whether` `    ``// it's either not replaced or replaced` `    ``// by a similar character using a map.` `    ``Dictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();`   `    ``for` `(``int` `i = 0; i < s1.Length; i++) ` `    ``{` `        ``if` `(!mp.ContainsKey(s1[i] - ``'a'``))` `        ``{` `            ``mp.Add(s1[i] - ``'a'``, s2[i] - ``'a'``);` `        ``}` `        ``else` `        ``{` `            ``if` `(mp[s1[i] - ``'a'``] != s2[i] - ``'a'``)` `                ``return` `false``;` `        ``}` `    ``}` `    `  `    ``// To check if there are cycles.` `    ``// If yes, then they are not convertible.` `    ``// Else, they are convertible.` `    ``foreach``(KeyValuePair<``int``, ``int``> it ``in` `mp)` `    ``{` `        ``if` `(it.Key == it.Value)` `            ``continue``;` `        ``else` `        ``{` `            ``if` `(find(it.Key) == find(it.Value))` `                ``return` `false``;` `            ``else` `                ``join``(it.Key, it.Value);` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Function to initialize parent array` `// for union and find algorithm.` `static` `void` `initialize()` `{` `    ``for` `(``int` `i = 0; i < 26; i++) ` `    ``{` `        ``parent[i] = i;` `    ``}` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``String s1, s2;` `    ``s1 = ``"abbcaa"``;` `    ``s2 = ``"bccdbb"``;` `    ``initialize();` `    ``if` `(convertible(s1, s2))` `        ``Console.Write(``"Yes"` `+ ``"\n"``);` `    ``else` `        ``Console.Write(``"No"` `+ ``"\n"``);` `}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N * logN), where N is the length of string s1.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :