Related Articles
Minimum string such that every adjacent character of given string is still adjacent
• Last Updated : 16 Dec, 2020

Given a string S, the task is to find the minimum length string such that every adjacent character of the string remains adjacent in the minimum length string.

Examples:

Input: S = “acabpba”
Output: pbac
Explanation:
The given string can be converted to “pbac” in which,
every adjacent character remains adjacent.

Input: S = “abcdea”
Output: Impossible
Explanation:
It is impossible to find such string.

Approach: The idea is to prepare a graph like structure in which every adjacent nodes of the graph denotes the adjacent character of the string. There can be two cases in which such type of string is not possible –

• If a character contains three or more adjacent characters.
• If two characters do not have only one adjacent character, except in the case of string of length 1.

If the above conditions for a string are true, then simply traverse the graph with Depth First Search Traversal and the path of this traversal will be the minimum length string. Source vertex for the DFS will be any one of the characters with only one adjacent character.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the``// minimum length string such that``// adjacent characters of the string``// remains adjacent in the string` `#include ``using` `namespace` `std;` `class` `graph {``    ``int` `arr;``    ``vector<``int``> alpha;``    ``vector<``int``> answer;` `public``:``    ``// Constructor for the graph``    ``graph()``    ``{``        ``// Initialize the matrix by -1``        ``for` `(``int` `i = 0; i < 26; i++) {``            ``for` `(``int` `j = 0; j < 2; j++)``                ``arr[i][j] = -1;``        ``}` `        ``// Initialize the alphabet array``        ``alpha = vector<``int``>(26);``    ``}` `    ``// Function to do Depth first``    ``// search Traversal``    ``void` `dfs(``int` `v)``    ``{``        ``// Pushing current character``        ``answer.push_back(v);` `        ``alpha[v] = 1;` `        ``for` `(``int` `i = 0; i < 2; i++) {``            ``if` `(alpha[arr[v][i]] == 1``                ``|| arr[v][i] == -1)``                ``continue``;` `            ``dfs(arr[v][i]);``        ``}``    ``}` `    ``// Function to find the minimum``    ``// length string``    ``void` `minString(string str)``    ``{``        ``// Condition if given string``        ``// length is 1``        ``if` `(str.length() == 1) {``            ``cout << str << ``"\n"``;``            ``return``;``        ``}` `        ``bool` `flag = ``true``;` `        ``// Loop to find the adjacency``        ``// list of the given string``        ``for` `(``int` `i = 0; i < str.length() - 1;``             ``i++) {``            ``int` `j = str[i] - ``'a'``;``            ``int` `k = str[i + 1] - ``'a'``;` `            ``// Condition if character``            ``// already present``            ``if` `(arr[j] == k``                ``|| arr[j] == k) {``            ``}``            ``else` `if` `(arr[j] == -1)``                ``arr[j] = k;``            ``else` `if` `(arr[j] == -1)``                ``arr[j] = k;` `            ``// Condition if a character``            ``// have more than two different``            ``// adjacent characters``            ``else` `{``                ``flag = ``false``;``                ``break``;``            ``}` `            ``if` `(arr[k] == j``                ``|| arr[k] == j) {``            ``}``            ``else` `if` `(arr[k] == -1)``                ``arr[k] = j;``            ``else` `if` `(arr[k] == -1)``                ``arr[k] = j;` `            ``// Condition if a character``            ``// have more than two different``            ``// adjacent characters``            ``else` `{``                ``flag = ``false``;``                ``break``;``            ``}``        ``}` `        ``// Variable to check string contain``        ``// two end characters or not``        ``bool` `contain_ends = ``false``;` `        ``int` `count = 0;``        ``int` `index;` `        ``for` `(``int` `i = 0; i < 26; i++) {` `            ``// Condition if a character has``            ``// only one type of adjacent``            ``// character``            ``if` `((arr[i] == -1``                 ``&& arr[i] != -1)``                ``|| (arr[i] == -1``                    ``&& arr[i] != -1)) {``                ``count++;``                ``index = i;``            ``}` `            ``// Condition if the given string``            ``// has exactly two characters``            ``// having only one type of adjacent``            ``// character``            ``if` `(count == 2)``                ``contain_ends = ``true``;` `            ``if` `(count == 3)``                ``contain_ends = ``false``;``        ``}` `        ``if` `(contain_ends == ``false``            ``|| flag == ``false``) {``            ``cout << ``"Impossible"``                 ``<< ``"\n"``;``            ``return``;``        ``}` `        ``// Depth first Search Traversal``        ``// on one of the possible end``        ``// character of the string``        ``dfs(index);` `        ``// Loop to print the answer``        ``for` `(``int` `i = 0; i < answer.size();``             ``i++) {``            ``char` `ch = answer[i] + ``'a'``;``            ``cout << ch;``        ``}``    ``}``};` `// Driver Code``int` `main()``{``    ``string s = ``"acabpba"``;` `    ``graph g;``    ``g.minString(s);` `    ``return` `0;``}`

## Java

 `// Java implementation to find the``// minimum length string such that``// adjacent characters of the string``// remains adjacent in the string``import` `java.util.ArrayList;` `class` `Graph{``    ` `int``[][] arr;``ArrayList alpha;``ArrayList answer;` `// Constructor for the Graph``public` `Graph()``{``    ``arr = ``new` `int``[``26``][``2``];``    ` `    ``// Initialize the matrix by -1``    ``for``(``int` `i = ``0``; i < ``26``; i++)``    ``{``        ``for``(``int` `j = ``0``; j < ``2``; j++)``            ``arr[i][j] = -``1``;``    ``}` `    ``// Initialize the alphabet array``    ``alpha = ``new` `ArrayList<>();``    ``for``(``int` `i = ``0``; i < ``26``; i++)``    ``{``        ``alpha.add(``0``);``    ``}` `    ``answer = ``new` `ArrayList<>();``}` `// Function to do Depth first``// search Traversal``void` `dfs(``int` `v)``{``    ` `    ``// Pushing current character``    ``answer.add(v);` `    ``alpha.set(v, ``1``);` `    ``for``(``int` `i = ``0``; i < ``2``; i++)``    ``{``        ``if` `(arr[v][i] == -``1` `||``            ``alpha.get(arr[v][i]) == ``1``)``            ``continue``;` `        ``dfs(arr[v][i]);``    ``}``}` `// Function to find the minimum``// length string``void` `minString(String str)``{``    ` `    ``// Condition if given string``    ``// length is 1``    ``if` `(str.length() == ``1``)``    ``{``        ``System.out.println(str);``        ``return``;``    ``}` `    ``boolean` `flag = ``true``;` `    ``// Loop to find the adjacency``    ``// list of the given string``    ``for``(``int` `i = ``0``; i < str.length() - ``1``; i++)``    ``{``        ``int` `j = str.charAt(i) - ``'a'``;``        ``int` `k = str.charAt(i + ``1``) - ``'a'``;` `        ``// Condition if character``        ``// already present``        ``if` `(arr[j][``0``] == k || arr[j][``1``] == k)``        ``{}``        ``else` `if` `(arr[j][``0``] == -``1``)``            ``arr[j][``0``] = k;``        ``else` `if` `(arr[j][``1``] == -``1``)``            ``arr[j][``1``] = k;` `        ``// Condition if a character``        ``// have more than two different``        ``// adjacent characters``        ``else``        ``{``            ``flag = ``false``;``            ``break``;``        ``}` `        ``if` `(arr[k][``0``] == j || arr[k][``1``] == j)``        ``{}``        ``else` `if` `(arr[k][``0``] == -``1``)``            ``arr[k][``0``] = j;``        ``else` `if` `(arr[k][``1``] == -``1``)``            ``arr[k][``1``] = j;` `        ``// Condition if a character``        ``// have more than two different``        ``// adjacent characters``        ``else``        ``{``            ``flag = ``false``;``            ``break``;``        ``}``    ``}` `    ``// Variable to check string contain``    ``// two end characters or not``    ``boolean` `contain_ends = ``false``;` `    ``int` `count = ``0``;``    ``int` `index = ``0``;` `    ``for``(``int` `i = ``0``; i < ``26``; i++)``    ``{``        ` `        ``// Condition if a character has``        ``// only one type of adjacent``        ``// character``        ``if` `((arr[i][``0``] == -``1` `&& arr[i][``1``] != -``1``) ||``            ``(arr[i][``1``] == -``1` `&& arr[i][``0``] != -``1``))``        ``{``            ``count++;``            ``index = i;``        ``}` `        ``// Condition if the given string``        ``// has exactly two characters``        ``// having only one type of adjacent``        ``// character``        ``if` `(count == ``2``)``            ``contain_ends = ``true``;` `        ``if` `(count == ``3``)``            ``contain_ends = ``false``;``    ``}` `    ``if` `(contain_ends == ``false` `|| flag == ``false``)``    ``{``        ``System.out.println(``"Impossible"``);``        ``return``;``    ``}` `    ``// Depth first Search Traversal``    ``// on one of the possible end``    ``// character of the string``    ``dfs(index);` `    ``// Loop to print the answer``    ``for``(``int` `i = ``0``; i < answer.size(); i++)``    ``{``        ``char` `ch = (``char``)(answer.get(i) + ``'a'``);``        ``System.out.print(ch);``    ``}``}``}` `class` `GFG{` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String s = ``"acabpba"``;` `    ``Graph graph = ``new` `Graph();``    ``graph.minString(s);``}``}` `// This code is contributed by sanjeev2552`

## Python3

 `# Python implementation to find the``# minimum length string such that``# adjacent characters of the string``# remains adjacent in the string` `# Initialize the matrix by -1``arr ``=` `[[``-``1` `for` `i ``in` `range``(``2``)] ``for` `j ``in` `range``(``26``)]` `# Initialize the alphabet array``alpha ``=` `[``0` `for` `i ``in` `range``(``26``)]``answer ``=` `[]` `# Function to do Depth first``# search Traversal``def` `dfs(v):``    ``global` `arr``    ``global` `alpha``    ``global` `answer` `    ``# Pushing current character``    ``answer.append(v)``    ``alpha[v] ``=` `1` `    ``for` `i ``in` `range``(``2``):``        ``if``(alpha[arr[v][i]] ``=``=` `1` `or` `arr[v][i] ``=``=` `-``1``):``            ``continue``        ``dfs(arr[v][i])` `# Function to find the minimum``# length string``def` `minString(``Str``):``  ` `    ``# Condition if given string``    ``# length is 1``    ``if``(``len``(``Str``) ``=``=` `1``):``        ``print``(``Str``)``        ``return` `    ``flag ``=` `True``    ``temp ``=` `0``    ` `    ``# Loop to find the adjacency``    ``# list of the given string``    ``for` `i ``in` `range``(``0``,``len``(``Str``) ``-` `1``):``        ``j ``=` `ord``(``Str``[i]) ``-` `ord``(``'a'``)` `        ``k ``=` `ord``(``Str``[i ``+` `1``]) ``-` `ord``(``'a'``)` `        ``# Condition if character``        ``# already present we can do nothing``        ``if``(arr[j][``0``] ``=``=` `k ``or` `arr[j][``1``] ``=``=` `k):``            ``temp ``=` `1` `        ``elif``(arr[j][``0``] ``=``=` `-``1``):``            ``arr[j][``0``] ``=` `k``        ``elif``(arr[j][``1``] ``=``=` `-``1``):``            ``arr[j][``1``] ``=` `k``            ` `        ``# Condition if a character``        ``# have more than two different``        ``# adjacent characters``        ``else``:``            ``flag ``=` `alse``            ``break` `        ``if``(arr[k][``0``] ``=``=` `j ``or` `arr[k][``1``] ``=``=` `j):``            ``temp ``=` `0``        ``elif``(arr[k][``0``] ``=``=` `-``1``):``            ``arr[k][``0``] ``=` `j``        ``elif``(arr[k][``1``] ``=``=` `-``1``):``            ``arr[k][``1``] ``=` `j``        ` `        ``# Condition if a character``        ``# have more than two different``        ``# adjacent characters``        ``else``:``            ``flag ``=` `False``            ``break` `    ``# Variable to check string contain``    ``# two end characters or not``    ``contain_ends ``=` `False` `    ``count ``=` `0``    ``index ``=` `0` `    ``for` `i ``in` `range``(``26``):``      ` `        ``# Condition if a character has``        ``# only one type of adjacent``        ``# character``        ``if``((arr[i][``0``] ``=``=` `-``1` `and` `arr[i][``1``] !``=` `-``1``) ``or` `(arr[i][``1``] ``=``=` `-``1` `and` `arr[i][``0``] !``=` `-``1``)):``            ``count ``+``=` `1``            ``index ``=` `i` `        ``# Condition if the given string``        ``# has exactly two characters``        ``# having only one type of adjacent``        ``# character``        ``if``(count ``=``=` `2``):``            ``contain_ends ``=` `True``        ``if``(count ``=``=` `3``):``            ``contain_ends ``=` `False` `    ``if``(contain_ends ``=``=` `False` `or` `flag ``=``=` `False``):``        ``print``(``"Impossible"``)``        ``return` `    ``# Depth first Search Traversal``    ``# on one of the possible end``    ``# character of the string``    ``dfs(index)` `    ``# Loop to print the answer``    ``for` `i ``in` `range``(``len``(answer)):``        ``ch ``=` `chr``(answer[i] ``+` `ord``(``'a'``))``        ``print``(ch, end ``=` `"")` `# Driver Code``s ``=` `"acabpba"``minString(s)` `# This code is contributed by avanitrachhadiya2155`
Output:
`pbac`

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.

My Personal Notes arrow_drop_up