Generate all permutations of a string that follow given constraints - GeeksforGeeks

27 Jan, 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++
Java
Python
C#
// Simple C++ program to print all permutations// of a string that follow given constraint#include <bits/stdc++.h>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 Codeint main(){    string str = "ABC";    permute(str, 0, str.length() - 1);    return 0;}
// Simple Java program to print all// permutations of a String that// follow given constraintimport 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 Codepublic static void main(String[] args){    String str = "ABC";        permute(str.toCharArray(), 0,            str.length() - 1);}} // This code is contributed by Amit Katiyar
# 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 Codestr = "ABC"permute(list(str), 0, len(str) - 1) # This code is contributed by SHUBHAMSINGH10
// Simple C# program to print all permutations// of a string that follow given constraintusing 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
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++
Java
Python
C#
// Backtracking based CPP program to print all// permutations of a string that follow given// constraint#include <bits/stdc++.h>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 Codeint main(){    string str = "ABC";       // Function call    permute(str, 0, str.length() - 1);    return 0;}
// 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);    }}
# 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 Codestr = "ABC" # Function callpermute(list(str), 0, len(str) - 1) # This code is contributed by SHUBHAMSINGH10
// Backtracking based C# program to print all// permutations of a string that follow given// constraintusing 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
ACB BAC BCA CBA 
SHUBHAMSINGH10
nidhi_biet
JayaRamaVardhanGuvvala
rutvik_56
divyeshrabadiya07
MuskanKalra1
amit143katiyar
adnanirshad158
Backtracking
Combinatorial
Strings
Strings
Combinatorial
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Tug of War
Difference between Backtracking and Branch-N-Bound technique
Perfect Sum Problem
N-Queen Problem | Local Search using Hill climbing with random neighbour
Find shortest safe route in a path with landmines
Permutation and Combination in Python
itertools.combinations() module in Python to print all possible combinations
Factorial of a large number
Program to calculate value of nCr
Count ways to reach the nth stair using step 1, 2 or 3