# Program to find total mutation group of genes in C++

Suppose we have a list of strings called genes where each element has the same length and each element contains characters "A", "C", "G" and/or "T". Now there are some rules −

• When two strings s1 and s2 are the same string except for one character, then s1 and s2 are in the same mutation group.

• When two strings s1 and s2 are in a group and s2 and s3 are in a group, then s1 and s3 are in the same group.

We have to find the total number of mutation groups we can generate.

So, if the input is like genes = ["ACGT", "ACGC", "ACTT", "TTTT", "TGTT"], then the output will be 2, as There are two mutation groups: ["ACGT", "ACGC", "ACTT"] and ["TTTT", "TTTG"]

To solve this, we will follow these steps −

• Define one map called parent

• Define a function getPar(), this will take a,

• if parent[a] is same as a, then:

• return a

• parent[a] = getPar(parent[a])

• return parent[a]

• Define a function unite(), this will take a, b,

• parA := getPar(a), parB := getPar(b)

• if parA is not equal to parB, then:

• parent[parA] := parB

• return true

• return false

• Define a function ok(), this will take a, b,

• cnt := 0

• for initialize i := 0, when i < size of a, update (increase i by 1), do:

• cnt := cnt + (1 when a[i] is not same as b[i], otherwise 0)

• return true when cnt is 1, otherwise false

• From the main method do the following −

• sort the array v

• Define one set s by taking elements from v

• ret := size of v

• for each element it in v, do

• parent[it] := it

• for each element it in v, do

• for initialize j := 0, when j < size of it, update (increase j by 1), do:

• temp := it

• for each character x in [A, C, G, T]

• if x is not equal to it[j], then:

• temp[j] := x

• if temp is present in s, then:

• if unite(temp, it), then:

• return ret

Let us see the following implementation to get better understanding −

## Example

Live Demo

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
map <string, string> parent;
string getPar(string& a){
if(parent[a] == a)
return a;
return parent[a] = getPar(parent[a]);
}
bool unite(string& a, string& b){
string parA = getPar(a);
string parB = getPar(b);
if(parA != parB){
parent[parA] = parB;
return true;
}
return false;
}
bool ok(string &a, string& b){
int cnt = 0;
for(int i = 0; i < a.size(); i++){
cnt += a[i] != b[i];
}
return cnt == 1;
}
int solve(vector<string> v) {
sort(v.begin(), v.end());
set <string> s(v.begin(), v.end());

int ret = v.size();
for(auto& it : v){
parent[it]= it;
}
for(auto& it : v){
for(int j = 0; j < it.size(); j++){
string temp = it;
for(char x : {'A', 'C', 'G', 'T'}){
if(x != it[j]){
temp[j] = x;
if(s.count(temp)){
if(unite(temp, it)) ret--;
}
}
}
}
}
return ret;
}
};
main(){
vector<string> v = {"ACGT", "ACGC", "ACTT", "TTTT", "TGTT"};
Solution(ob);
cout << ob.solve(v);
}



## Input

{"ACGT", "ACGC", "ACTT", "TTTT", "TGTT"}

## Output

2