# Generate all permutations of a string that follow given constraints

• Difficulty Level : Hard
• Last Updated : 09 May, 2022

Given a string, generate all permutations of it that do not contain ‘B’ after ‘A’, i.e., the string should not contain “AB” as a substring.

Examples:

Input : str = “ABC”
Output : ACB, BAC, BCA, CBA
Out of 6 permutations of “ABC”, 4 follow the given constraint and 2 (“ABC” and “CAB”) do not follow.

Input : str = “BCD”
Output : BCD, BDC, CDB, CBD, DCB, DBC

A simple solution is to generate all permutations. For every permutation, check if it follows the given constraint.

## C++

 `// Simple C++ program to print all permutations``// of a string that follow given constraint``#include ``using` `namespace` `std;` `void` `permute(string& str, ``int` `l, ``int` `r)``{` `    ``// Check if current permutation is``    ``// valid``    ``if` `(l == r) {``        ``if` `(str.find(``"AB"``) == string::npos)``            ``cout << str << ``" "``;``        ``return``;``    ``}` `    ``// Recursively generate all permutation``    ``for` `(``int` `i = l; i <= r; i++) {``        ``swap(str[l], str[i]);``        ``permute(str, l + 1, r);``        ``swap(str[l], str[i]);``    ``}``}` `// Driver Code``int` `main()``{``    ``string str = ``"ABC"``;``    ``permute(str, 0, str.length() - 1);``    ``return` `0;``}`

## Java

 `// Simple Java program to print all``// permutations of a String that``// follow given constraint``import` `java.util.*;` `class` `GFG{``    ` `static` `void` `permute(``char``[] str, ``int` `l, ``int` `r)``{``    ` `    ``// Check if current permutation is``    ``// valid``    ``if` `(l == r)``    ``{``        ``if` `(!String.valueOf(str).contains(``"AB"``))``            ``System.out.print(String.valueOf(str) + ``" "``);``        ``return``;``    ``}` `    ``// Recursively generate all permutation``    ``for``(``int` `i = l; i <= r; i++)``    ``{``        ``char` `tmp = str[l];``        ``str[l] = str[i];``        ``str[i] = tmp;``        ` `        ``permute(str, l + ``1``, r);``        ` `        ``tmp = str[l];``        ``str[l] = str[i];``        ``str[i] = tmp;``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String str = ``"ABC"``;``   ` `    ``permute(str.toCharArray(), ``0``,``            ``str.length() - ``1``);``}``}` `// This code is contributed by Amit Katiyar`

## Python

 `# Simple Python program to print all permutations``# of a string that follow given constraint`  `def` `permute(``str``, l, r):` `    ``# Check if current permutation is``    ``# valid``    ``if` `(l ``=``=` `r):``        ``if` `"AB"` `not` `in` `''.join(``str``):``            ``print``(''.join(``str``), end``=``" "``)``        ``return` `    ``# Recursively generate all permutation``    ``for` `i ``in` `range``(l, r ``+` `1``):``        ``str``[l], ``str``[i] ``=` `str``[i], ``str``[l]``        ``permute(``str``, l ``+` `1``, r)``        ``str``[l], ``str``[i] ``=` `str``[i], ``str``[l]`  `# Driver Code``str` `=` `"ABC"``permute(``list``(``str``), ``0``, ``len``(``str``) ``-` `1``)` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// Simple C# program to print all permutations``// of a string that follow given constraint``using` `System;``using` `System.Text;` `class` `GFG {` `    ``static` `void` `permute(StringBuilder str, ``int` `l, ``int` `r)``    ``{` `        ``// Check if current permutation is``        ``// valid``        ``if` `(l == r) {``            ``if` `(str.ToString().IndexOf(``"AB"``) == -1) {``                ``Console.Write(str.ToString() + ``" "``);``            ``}` `            ``return``;``        ``}` `        ``// Recursively generate all permutation``        ``for` `(``int` `i = l; i <= r; i++) {``            ``char` `tmp = str[l];``            ``str[l] = str[i];``            ``str[i] = tmp;` `            ``permute(str, l + 1, r);``            ``tmp = str[l];``            ``str[l] = str[i];``            ``str[i] = tmp;``        ``}``    ``}` `    ``// Driver code``    ``static` `void` `Main(``string``[] arg)``    ``{``        ``string` `str = ``"ABC"``;``        ``StringBuilder s = ``new` `StringBuilder(str);` `        ``permute(s, 0, str.Length - 1);``    ``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``
Output
`ACB BAC BCA CBA `

The above solution first generates all permutations, then for every permutation, it checks if it follows given constraint or not.

An efficient solution is to use Backtracking. We cut down the recursion tree whenever we see that substring “AB” is formed. How do we do this? we add a isSafe() function. Before doing a swap, we check if previous character is ‘A’ and current character is ‘B’.

Below is the implementation of the above code:

## C++

 `// Backtracking based CPP program to print all``// permutations of a string that follow given``// constraint``#include ``using` `namespace` `std;` `bool` `isSafe(string& str, ``int` `l, ``int` `i, ``int` `r)``{``    ``// If previous character was 'A' and character``    ``// is 'B', then do not proceed and cut down``    ``// the recursion tree.``    ``if` `(l != 0 && str[l - 1] == ``'A'` `&& str[i] == ``'B'``)``        ``return` `false``;` `    ``// This condition is explicitly required for``    ``// cases when last two characters are "BA". We``    ``// do not want them to swapped and become "AB"``    ``if` `(r == l + 1 && str[i] == ``'A'` `&& str[l] == ``'B'``        ``|| r == l + 1 && l == i && str[r] == ``'B'``               ``&& str[l] == ``'A'``)``        ``return` `false``;` `    ``return` `true``;``}` `void` `permute(string& str, ``int` `l, ``int` `r)``{``    ``// We reach here only when permutation``    ``// is valid``    ``if` `(l == r) {``        ``cout << str << ``" "``;``        ``return``;``    ``}` `    ``// Fix all characters one by one``    ``for` `(``int` `i = l; i <= r; i++) {` `        ``// Fix str[i] only if it is a``        ``// valid move.``        ``if` `(isSafe(str, l, i, r)) {``            ``swap(str[l], str[i]);``            ``permute(str, l + 1, r);``            ``swap(str[l], str[i]);``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``string str = ``"ABC"``;``  ` `    ``// Function call``    ``permute(str, 0, str.length() - 1);``    ``return` `0;``}`

## Java

 `// Backtracking based JAVA program``// to print all permutations of a``// string that follow given constraint` `public` `class` `GFG``{``    ``public` `boolean` `isSafe(String str,``                          ``int` `l,``                          ``int` `i,``                          ``int` `r)``    ``{``        ``// If previous character was 'A'``        ``// and  character is 'B', then ``        ``// do not proceed and cut down the``        ``// recursion tree.``        ``if` `(l != ``0` `&& str.charAt(l - ``1``) == ``'A'``            ``&& str.charAt(i) == ``'B'``)``            ``return` `false``;` `        ``// This condition is explicitly required``        ``// for cases when last two characters ``        ``// are "BA". We do not want them to``        ``// swapped and become "AB"``        ``if` `(r == l + ``1` `&& str.charAt(i) == ``'A'``                      ``&& str.charAt(l) == ``'B'``                      ``|| r == l + ``1` `&& l == i``                      ``&& str.charAt(r) == ``'B'``                      ``&& str.charAt(l) == ``'A'``)``            ``return` `false``;` `        ``return` `true``;``    ``}` `    ``/**``     ``* permutation function``     ``* @param str string to calculate``       ``permutation for``     ``* @param l starting index``     ``* @param r end index``     ``*/``    ``private` `void` `permute(String str,``                         ``int` `l, ``int` `r)``    ``{``        ``// We reach here only when permutation``        ``// is valid``        ``if` `(l == r)``            ``System.out.print(str + ``" "``);``        ``else``        ``{``            ``// Fix all characters one by one``            ``for` `(``int` `i = l; i <= r; i++)``            ``{``                ``// Fix str[i] only if it is a``                ``// valid move.``                ``if` `(isSafe(str, l, i, r))``                ``{``                    ``str = swap(str, l, i);``                    ``permute(str, l + ``1``, r);``                    ``str = swap(str, l, i);``                ``}``            ``}``        ``}``    ``}` `    ``/**``     ``* Swap Characters at position``     ``* @param a string value``     ``* @param i position 1``     ``* @param j position 2``     ``* @return swapped string``     ``*/``    ``public` `String swap(String a, ``int` `i, ``int` `j)``    ``{``        ``char` `temp;``        ``char``[] charArray = a.toCharArray();``        ``temp = charArray[i];``        ``charArray[i] = charArray[j];``        ``charArray[j] = temp;``        ``return` `String.valueOf(charArray);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``"ABC"``;``        ``int` `n = str.length();``        ``GFG permutation = ``new` `GFG();` `        ``// Function call``        ``permutation.permute(str, ``0``, n - ``1``);``    ``}``}`

## Python

 `# Backtracking based Python3 program to print all``# permutations of a string that follow given``# constraint`  `def` `isSafe(``str``, l, i, r):` `    ``# If previous character was 'A' and character``    ``# is 'B', then do not proceed and cut down``    ``# the recursion tree.``    ``if` `(l !``=` `0` `and` `str``[l ``-` `1``] ``=``=` `'A'` `and` `str``[i] ``=``=` `'B'``):``        ``return` `False` `    ``# This condition is explicitly required for``    ``# cases when last two characters are "BA". We``    ``# do not want them to swapped and become "AB"``    ``if` `(r ``=``=` `l ``+` `1` `and` `str``[i] ``=``=` `'A'` `and` `str``[l] ``=``=` `'B'``        ``or` `r ``=``=` `l ``+` `1` `and` `l ``=``=` `i ``and` `str``[r] ``=``=` `'B'``            ``and` `str``[l] ``=``=` `'A'``):``        ``return` `False` `    ``return` `True`  `def` `permute(``str``, l, r):` `    ``# We reach here only when permutation``    ``# is valid``    ``if` `(l ``=``=` `r):``        ``print``(``*``str``, sep``=``"``", end="` `")``        ``return` `    ``# Fix all characters one by one``    ``for` `i ``in` `range``(l, r ``+` `1``):` `        ``# Fix str[i] only if it is a``        ``# valid move.``        ``if` `(isSafe(``str``, l, i, r)):``            ``str``[l], ``str``[i] ``=` `str``[i], ``str``[l]``            ``permute(``str``, l ``+` `1``, r)``            ``str``[l], ``str``[i] ``=` `str``[i], ``str``[l]`  `# Driver Code``str` `=` `"ABC"` `# Function call``permute(``list``(``str``), ``0``, ``len``(``str``) ``-` `1``)` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// Backtracking based C# program to print all``// permutations of a string that follow given``// constraint``using` `System;` `public` `class` `GFG``{``    ``// Backtracking based C# program``    ``// to print all permutations of a``    ``// string that follow given constraint``    ``using` `System;``    ``using` `System.Text;` `    ``class` `GFG {` `        ``static` `bool` `isSafe(StringBuilder str,``                           ``int` `l, ``int` `i,``                           ``int` `r)``        ``{` `            ``// If previous character was 'A'``            ``// and character is 'B', then do not``            ``// proceed and cut down the recursion tree.``            ``if` `(l != 0 && str[l - 1] == ``'A'``                ``&& str[i] == ``'B'``)``                ``return` `false``;` `            ``// This condition is explicitly``            ``// required for cases when last two``            ``// characters are "BA". We do not want``            ``// them to swapped and become "AB"``            ``if` `(r == l + 1 && str[i] == ``'A'``                ``&& str[l] == ``'B'` `|| r == l + 1``                ``&& l == i && str[r] == ``'B'``                ``&& str[l] == ``'A'``)``                ``return` `false``;` `            ``return` `true``;``        ``}` `        ``static` `void` `permute(StringBuilder str,``                             ``int` `l, ``int` `r)``        ``{` `            ``// We reach here only when permutation``            ``// is valid``            ``if` `(l == r)``            ``{``                ``Console.Write(str + ``" "``);``                ``return``;``            ``}` `            ``// Fix all characters one by one``            ``for` `(``int` `i = l; i <= r; i++)``            ``{` `                ``// Fix str[i] only if it is a``                ``// valid move.``                ``if` `(isSafe(str, l, i, r))``                ``{``                    ``char` `temp = str[l];``                    ``str[l] = str[i];``                    ``str[i] = temp;``                    ``permute(str, l + 1, r);``                    ``temp = str[l];``                    ``str[l] = str[i];``                    ``str[i] = temp;``                ``}``            ``}``        ``}` `        ``// Driver code``        ``static` `void` `Main()``        ``{``            ``string` `str = ``"ABC"``;``            ``StringBuilder s = ``new` `StringBuilder(str);` `            ``// Function call``            ``permute(s, 0, str.Length - 1);``        ``}``    ``}` `    ``// This code is contributed by divyeshrabadiya07`
Output
`ACB BAC BCA CBA `

My Personal Notes arrow_drop_up