Open In App

Minimum cost to generate any permutation of the given string

Last Updated : 23 Nov, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given string str of size N consisting of the first N alphabets and a matrix mat[] of size N*N where mat[i][j] represents the cost of placing ith character of the alphabet before the jth character in the string. The task is to find the minimum cost to generate any permutation of the given string.

Examples: 

Input:str = “abcde”, mat[][]= {{0, 5, 1, 5, 3}, {4, 0, 9, 4, 2}, {7, 9, 0, 10, 7}, {1, 2, 8, 0, 2}, {3, 9, 7, 7, 0}} 
Output:
Explanation: 
Permutation ‘dbeac’ can be generated at a minimum cost of 8. 
Cost of placing d = 0 (since there is no prev character) 
Cost of placing b after d = mat[4][2] = 2 
Cost of placing e after b = mat[2][5] = 2 
Cost of placing a after e = mat[5][1] = 3 
Cost of placing c after a = mat[1][3] = 1 
Total cost = 2 + 2 + 3 + 1 = 8 

Input: str = “abcde”, mat[][] = {{0, 9, 4, 8, 10}, {7, 0, 9, 5, 5}, {2, 8, 0, 4, 1}, {4, 10, 5, 0, 5}, {4, 3, 4, 7, 0 }} 
Output: 13 

Naive Approach: The naive idea is to generate all possible permutations of the given string and find the cost of every permutation. Then print the minimum cost among all possible costs.

Time Complexity: O(N*N!) 
Auxiliary Space: O(N!)

Efficient Approach: To optimize the above approach the idea is to use Dynamic Programming with Bit Masking. Observe that all the characters are distinct and there are only 26 alphabets possible. So use a mask to store the presence of each character. Below are the steps: 

  1. Iterate through all characters of the string and place each character at each position if it is available i.e., the bit is set in the mask.
  2. Then, place the character in the current position and calculate the cost of placing the character.
  3. Move to the next position by flipping the bit of the current character.
  4. At each iteration, the mask represents the number of available characters for the current position.
  5. After completing the above steps, print the minimum cost among all the costs calculated.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true
// if the current bit is set
bool check(int mask, int i)
{
    int c = (mask & (1 << i));
    return c != 0;
}
 
// Function to find the minimum cost
// to form any permutation of string s
int solve(vector<vector<int>> a, string s,
          int n, int prev, int mask,
          vector<vector<int>> dp)
{
     
    // Base Case
    if (mask == 0)
        return 0;
 
    // Return the precomputed state
    if (dp[mask][prev + 1] != -1)
        return dp[mask][prev + 1];
 
    int ans = 10000;
 
    // Iterate over the string and
    // check all possible characters
    // available for current position
    for(int i = 0; i < s.length(); i++)
    {
        int id = s[i] - 'a';
         
        // Check if character can be
        // placed at current position
        if (check(mask, id))
        {
             
            // As there is no previous
            // character so the cost
            // for 1st character is 0
            if (prev == -1)
            {
                ans = min(ans, solve(a, s, n, id,
                                     mask ^ (1 << id), dp));
            }
 
            // Find the cost of current
            // character and move to next
            // position
            else
            {
                ans = min(ans, a[prev][id] +
                          solve(a, s, n, id,
                                mask ^ (1 << id), dp));
            }
        }
    }
 
    // Store the answer for each
    // current state
    dp[mask][prev + 1] = ans;
    return ans;
}
 
// Function that generates any
// permutation of the given
// string with minimum cost
void generatePermutation(int mask, int n,
                         vector<vector<int>> a,
                         string s)
{
     
    // Initialize dp table
    vector<vector<int>> dp((1 << n) + 5 ,
           vector<int> (n + 5, -1));
 
    // Set all the bits of the
    // current character id
    for(int i = 0; i < s.length(); i++)
    {
        int id = s[i] - 'a';
        mask |= (1 << id);
    }
     
    // Minimum cost of generating
    // the permutation
    cout << solve(a, s, n, -1, mask, dp)
         << endl;
}
 
// Driver Code  
int main()
{
    int N = 5;
    string str = "abcde";
 
    vector<vector<int>> mat = { { 0, 5, 1, 5, 3 },
                                { 4, 0, 9, 4, 2 },
                                { 7, 9, 0, 10, 7 },
                                { 1, 2, 8, 0, 2 },
                                { 3, 9, 7, 7, 0 } };
 
    // Function Call
    generatePermutation(0, N, mat, str);
     
    return 0;
}
 
// This code is contributed by divyeshrabadiya07


Java




// Java program for the above approach
 
import java.util.*;
 
public class Main {
 
    // Function to find the minimum cost
    // to form any permutation of string s
    public static int solve(
        int a[][], String s, int n,
        int prev, int mask, int[][] dp)
    {
        // Base Case
        if (mask == 0)
            return 0;
 
        // Return the precomputed state
        if (dp[mask][prev + 1] != -1)
            return dp[mask][prev + 1];
 
        int ans = 10000;
 
        // Iterate over the string and
        // check all possible characters
        // available for current position
        for (int i = 0; i < s.length(); i++) {
 
            int id = s.charAt(i) - 'a';
 
            // Check if character can be
            // placed at current position
            if (check(mask, id)) {
 
                // As there is no previous
                // character so the cost
                // for 1st character is 0
                if (prev == -1) {
 
                    ans
                        = Math.min(ans,
                                   solve(
                                       a, s,
                                       n, id,
                                       mask ^ (1 << id),
                                       dp));
                }
 
                // Find the cost of current
                // character and move to next
                // position
                else {
                    ans = Math.min(
                        ans,
                        a[prev][id]
                            + solve(
                                  a, s,
                                  n, id,
                                  mask ^ (1 << id),
                                  dp));
                }
            }
        }
 
        // Store the answer for each
        // current state
        dp[mask][prev + 1] = ans;
        return ans;
    }
 
    // Function that returns true
    // if the current bit is set
    public static boolean
    check(int mask, int i)
    {
        int c = (mask & (1 << i));
        return c != 0;
    }
 
    // Function that generates any
    // permutation of the given
    // string with minimum cost
    static void generatePermutation(
        int mask, int n, int a[][],
        String s)
    {
 
        // Initialize dp table
        int dp[][] = new int[(1 << n) + 5][n + 5];
 
        for (int i[] : dp)
            Arrays.fill(i, -1);
 
        // Set all the bits of the
        // current character id
        for (int i = 0;
             i < s.length(); i++) {
 
            int id = s.charAt(i) - 'a';
            mask |= (1 << id);
        }
 
        // Minimum cost of generating
        // the permutation
        System.out.println(solve(
            a, s, n, -1, mask, dp));
    }
 
    // Driver Code
    public static void main(String args[])
    {
        int N = 5;
 
        String str = "abcde";
 
        int mat[][] = { { 0, 5, 1, 5, 3 },
                        { 4, 0, 9, 4, 2 },
                        { 7, 9, 0, 10, 7 },
                        { 1, 2, 8, 0, 2 },
                        { 3, 9, 7, 7, 0 } };
 
        // Function Call
        generatePermutation(0, N, mat, str);
    }
}


Python3




# Python3 program for the
# above approach
 
# Function to find the
# minimum cost to form
# any permutation of
# string s
def solve(a, s, n, prev,
          mask, dp):
    # Base Case
    if (mask == 0):
        return 0;
 
    # Return the precomputed state
    if (dp[mask][prev + 1] != -1):
        return dp[mask][prev + 1];
 
    ans = 10000;
 
    # Iterate over the string and
    # check all possible characters
    # available for current position
    for i in range(len(s)):
        id = ord(s[i]) - ord('a');
 
        # Check if character can be
        # placed at current position
        if (check(mask, id)):
 
            # As there is no previous
            # character so the cost
            # for 1st character is 0
            if (prev == -1):
                ans = min(ans,
                      solve(a, s,
                            n, id,
                            mask ^ (1 <<
                            id), dp));
 
 
            # Find the cost of current
            # character and move to next
            # position
            else:
                ans = min(ans, a[prev][id] +
                      solve(a, s, n,
                            id, mask ^
                            (1 << id), dp));
 
    # Store the answer for each
    # current state
    dp[mask][prev + 1] = ans;
    return ans;
 
 
# Function that returns
# True if the current
# bit is set
def check(mask, i):
   
    c = (mask & (1 << i));
    return c != 0;
 
# Function that generates any
# permutation of the given
# string with minimum cost
def generatePermutation(mask, n,
                        a, s):
 
    # Initialize dp table
    dp = [[-1 for i in range(n + 5)]
              for j in range((1 << n) + 5)]
 
    # Set all the bits of the
    # current character id
    for i in range(len(s)):
        id = ord(s[i]) - ord('a');
        mask |= (1 << id);
 
    # Minimum cost of generating
    # the permutation
    print(solve(a, s, n,
                -1, mask, dp));
 
# Driver Code
if __name__ == '__main__':
   
    N = 5;
    str = "abcde";
    mat = [[0, 5, 1, 5, 3],
           [4, 0, 9, 4, 2],
           [7, 9, 0, 10, 7],
           [1, 2, 8, 0, 2],
           [3, 9, 7, 7, 0]];
 
    # Function Call
    generatePermutation(0, N,
                        mat, str);
 
# This code is contributed by gauravrajput1


C#




// C# program for the
// above approach
using System;
class GFG{
 
// Function to find the minimum cost
// to form any permutation of string s
public static int solve(int[,]a, String s, int n,
                        int prev, int mask, int[,] dp)
{
  // Base Case
  if (mask == 0)
    return 0;
 
  // Return the precomputed state
  if (dp[mask,prev + 1] != -1)
    return dp[mask, prev + 1];
 
  int ans = 10000;
 
  // Iterate over the string and
  // check all possible characters
  // available for current position
  for (int i = 0;
           i < s.Length; i++)
  {
    int id = s[i] - 'a';
 
    // Check if character can be
    // placed at current position
    if (check(mask, id))
    {
      // As there is no previous
      // character so the cost
      // for 1st character is 0
      if (prev == -1)
      {
        ans = Math.Min(ans,
                       solve(a, s, n, id,
                             mask ^ (1 << id), dp));
      }
 
      // Find the cost of current
      // character and move to next
      // position
      else
      {
        ans = Math.Min(ans, a[prev,id] +
                       solve(a, s, n, id,
                             mask ^ (1 << id), dp));
      }
    }
  }
 
  // Store the answer for each
  // current state
  dp[mask, prev + 1] = ans;
  return ans;
}
 
// Function that returns true
// if the current bit is set
public static bool check(int mask, int i)
{
  int c = (mask & (1 << i));
  return c != 0;
}
 
// Function that generates any
// permutation of the given
// string with minimum cost
static void generatePermutation(int mask, int n,
                                int[,]a, String s)
{
  // Initialize dp table
  int [,]dp = new int[(1 << n) + 5,
                      n + 5];
 
  for(int i = 0;
          i < (1 << n) + 5; i++)
    for(int j = 0;
            j < n + 5; j++)
      dp[i, j] = -1;
   
  // Set all the bits of the
  // current character id
  for (int i = 0;
       i < s.Length; i++)
  {
    int id = s[i] - 'a';
    mask |= (1 << id);
  }
 
  // Minimum cost of generating
  // the permutation
  Console.WriteLine(solve(a, s, n,
                          -1, mask, dp));
}
 
// Driver Code
public static void Main(String []args)
{
  int N = 5;
  String str = "abcde";
  int [,]mat = {{0, 5, 1, 5, 3},
                {4, 0, 9, 4, 2},
                {7, 9, 0, 10, 7},
                {1, 2, 8, 0, 2},
                {3, 9, 7, 7, 0}};
 
  // Function Call
  generatePermutation(0, N, mat, str);
}
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
 
// Javascript program for the above approach
 
// Function that returns true
// if the current bit is set
function check(mask, i)
{
    var c = (mask & (1 << i));
    return c != 0;
}
 
// Function to find the minimum cost
// to form any permutation of string s
function solve(a, s,  n, prev, mask, dp)
{
     
    // Base Case
    if (mask == 0)
        return 0;
 
    // Return the precomputed state
    if (dp[mask][prev + 1] != -1)
        return dp[mask][prev + 1];
 
    var ans = 10000;
 
    // Iterate over the string and
    // check all possible characters
    // available for current position
    for(var i = 0; i < s.length; i++)
    {
        var id = s[i].charCodeAt(0) - 'a'.charCodeAt(0);
         
        // Check if character can be
        // placed at current position
        if (check(mask, id))
        {
             
            // As there is no previous
            // character so the cost
            // for 1st character is 0
            if (prev == -1)
            {
                ans = Math.min(ans, solve(a, s, n, id,
                                     mask ^ (1 << id), dp));
            }
 
            // Find the cost of current
            // character and move to next
            // position
            else
            {
                ans = Math.min(ans, a[prev][id] +
                          solve(a, s, n, id,
                                mask ^ (1 << id), dp));
            }
        }
    }
 
    // Store the answer for each
    // current state
    dp[mask][prev + 1] = ans;
    return ans;
}
 
// Function that generates any
// permutation of the given
// string with minimum cost
function generatePermutation(mask, n, a,  s)
{
     
    // Initialize dp table
    var dp = Array.from(Array((1 << n) + 5), ()=> Array(n + 5).fill(-1));
 
    // Set all the bits of the
    // current character id
    for(var i = 0; i < s.length; i++)
    {
        var id = s[i].charCodeAt(0) - 'a'.charCodeAt(0);
        mask |= (1 << id);
    }
     
    // Minimum cost of generating
    // the permutation
    document.write( solve(a, s, n, -1, mask, dp) + "<br>");
}
 
// Driver Code  
var N = 5;
var str = "abcde";
var mat = [ [ 0, 5, 1, 5, 3 ],
                            [ 4, 0, 9, 4, 2 ],
                            [ 7, 9, 0, 10, 7 ],
                            [ 1, 2, 8, 0, 2 ],
                            [ 3, 9, 7, 7, 0 ] ];
// Function Call
generatePermutation(0, N, mat, str);
 
// This code is contributed by noob2000.
</script>


Output

8















Time Complexity: O(N*2N
Auxiliary Space: O(N*2N)

Using Brute Force with Recursion in python:

Approach:

The idea is to generate all possible permutations of the given string and calculate the cost for each permutation. Finally, return the minimum cost among all the permutations.

The get_min_cost function takes two inputs, a string str and a 2D matrix mat that represents the cost of swapping each pair of characters. The function returns the minimum cost of swapping any pair of characters in the input string such that the resulting string is lexicographically sorted.

The function first generates all permutations of the input string using a recursive function permute, which takes the current permutation string s, left and right indices of the current permutation l and r respectively. The function generates permutations by swapping each character with every other character in the string, recursively calling itself for each swap until the left and right indices are the same, indicating that the string is fully permuted.

For each permutation, the function calculates the cost of swapping pairs of characters using the input matrix mat and returns the minimum cost of all permutations. The cost is calculated by iterating through each character in the permutation, and adding the cost of swapping it with the previous character. The cost of swapping two characters is obtained by indexing the matrix using the ASCII value of the characters.

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to permute the string and calculate all permutations
void permute(string s, int l, int r, vector<string>& perms) {
    if (l == r) {
        perms.push_back(s);
    } else {
        for (int i = l; i <= r; i++) {
            swap(s[l], s[i]);
            permute(s, l + 1, r, perms);
            swap(s[l], s[i]); // Backtrack to the original state
        }
    }
}
 
// Function to get the minimum cost
int get_min_cost(string str, vector<vector<int>>& mat) {
    int n = str.length();
  // vector of string to store the permutations
    vector<string> perms;
 
    permute(str, 0, n - 1, perms);
 
    // Calculate cost for each permutation and return the minimum cost
    int min_cost = INT_MAX;
    for (const string& perm : perms) {
        int cost = 0;
        for (int i = 1; i < n; i++) {
            int row = perm[i - 1] - 'a';
            int col = perm[i] - 'a';
            cost += mat[row][col];
        }
        if (cost < min_cost) {
            min_cost = cost;
        }
    }
 
    return min_cost;
}
//Driver code
int main() {
  //Test case input
    string str1 = "abcde";
    vector<vector<int>> mat1 = {{0, 5, 1, 5, 3},
                                 {4, 0, 9, 4, 2},
                                 {7, 9, 0, 10, 7},
                                 {1, 2, 8, 0, 2},
                                 {3, 9, 7, 7, 0}};
//Function call
    int result = get_min_cost(str1, mat1);
    cout << "Output: " << result << endl; // Output: 8
 
    return 0;
}


Java




import java.util.ArrayList;
import java.util.List;
 
public class StringPermutationMinCost {
    // Function to permute the string and calculate all permutations
    static void permute(String s, int l, int r, List<String> perms) {
        if (l == r) {
            perms.add(s);
        } else {
            for (int i = l; i <= r; i++) {
                s = swap(s, l, i);
                permute(s, l + 1, r, perms);
                s = swap(s, l, i); // Backtrack to the original state
            }
        }
    }
 
    // Helper function to swap characters in a string
    static String swap(String str, int i, int j) {
        char[] charArray = str.toCharArray();
        char temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        return new String(charArray);
    }
 
    // Function to get the minimum cost
    static int getMinCost(String str, int[][] mat) {
        int n = str.length();
        List<String> perms = new ArrayList<>();
 
        permute(str, 0, n - 1, perms);
 
        // Calculate cost for each permutation and return the minimum cost
        int minCost = Integer.MAX_VALUE;
        for (String perm : perms) {
            int cost = 0;
            for (int i = 1; i < n; i++) {
                int row = perm.charAt(i - 1) - 'a';
                int col = perm.charAt(i) - 'a';
                cost += mat[row][col];
            }
            if (cost < minCost) {
                minCost = cost;
            }
        }
 
        return minCost;
    }
 
    public static void main(String[] args) {
        // Test case input
        String str1 = "abcde";
        int[][] mat1 = {{0, 5, 1, 5, 3},
                        {4, 0, 9, 4, 2},
                        {7, 9, 0, 10, 7},
                        {1, 2, 8, 0, 2},
                        {3, 9, 7, 7, 0}};
 
        // Function call
        int result = getMinCost(str1, mat1);
        System.out.println(result); // Output: 8
    }
}


Python3




def get_min_cost(str, mat):
    n = len(str)
    perms = []
    # Generate all permutations of the string
    def permute(s, l, r):
        if l == r:
            perms.append(s.copy())
        else:
            for i in range(l, r+1):
                s[l], s[i] = s[i], s[l]
                permute(s, l+1, r)
                s[l], s[i] = s[i], s[l]
    permute(list(str), 0, n-1)
    # Calculate cost for each permutation and return the minimum cost
    min_cost = float('inf')
    for perm in perms:
        cost = 0
        for i in range(1, n):
            cost += mat[ord(perm[i-1])-97][ord(perm[i])-97]
        if cost < min_cost:
            min_cost = cost
    return min_cost
 
# Example usage
str1 = "abcde"
mat1 = [[0, 5, 1, 5, 3], [4, 0, 9, 4, 2], [7, 9, 0, 10, 7], [1, 2, 8, 0, 2], [3, 9, 7, 7, 0]]
print(get_min_cost(str1, mat1)) # Output: 8


C#




using System;
using System.Collections.Generic;
 
class GFG {
    // Function to permute the string and calculate all
    // permutations
    static void Permute(string s, int l, int r,
                        List<string> perms)
    {
        if (l == r) {
            perms.Add(s);
        }
        else {
            for (int i = l; i <= r; i++) {
                s = SwapChars(s, l, i);
                Permute(s, l + 1, r, perms);
                s = SwapChars(
                    s, l,
                    i); // Backtrack to the original state
            }
        }
    }
 
    // Helper function to swap characters in a string
    static string SwapChars(string s, int i, int j)
    {
        char[] charArray = s.ToCharArray();
        char temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        return new string(charArray);
    }
 
    // Function to get the minimum cost
    static int GetMinCost(string str, int[][] mat)
    {
        int n = str.Length;
        // list of strings to store the permutations
        List<string> perms = new List<string>();
 
        Permute(str, 0, n - 1, perms);
 
        // Calculate cost for each permutation and return
        // the minimum cost
        int minCost = int.MaxValue;
        foreach(string perm in perms)
        {
            int cost = 0;
            for (int i = 1; i < n; i++) {
                int row = perm[i - 1] - 'a';
                int col = perm[i] - 'a';
                cost += mat[row][col];
            }
            if (cost < minCost) {
                minCost = cost;
            }
        }
 
        return minCost;
    }
 
    // Driver code
    static void Main()
    {
        // Test case input
        string str1 = "abcde";
        int[][] mat1
            = new int[][] { new int[] { 0, 5, 1, 5, 3 },
                            new int[] { 4, 0, 9, 4, 2 },
                            new int[] { 7, 9, 0, 10, 7 },
                            new int[] { 1, 2, 8, 0, 2 },
                            new int[] { 3, 9, 7, 7, 0 } };
 
        // Function call
        int result = GetMinCost(str1, mat1);
        Console.WriteLine(result);
    }
}


Javascript




class GFG {
    // Function to permute the string and calculate all permutations
    static Permute(s, l, r, perms) {
        if (l === r) {
            perms.push(s);
        } else {
            for (let i = l; i <= r; i++) {
                s = this.SwapChars(s, l, i);
                this.Permute(s, l + 1, r, perms);
                s = this.SwapChars(s, l, i); // Backtrack to the original state
            }
        }
    }
 
    // Helper function to swap characters in a string
    static SwapChars(s, i, j) {
        const charArray = s.split('');
        const temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        return charArray.join('');
    }
 
    // Function to get the minimum cost
    static GetMinCost(str, mat) {
        const n = str.length;
        // List of strings to store the permutations
        const perms = [];
 
        this.Permute(str, 0, n - 1, perms);
 
        // Calculate cost for each permutation and return the minimum cost
        let minCost = Number.MAX_SAFE_INTEGER;
        perms.forEach(perm => {
            let cost = 0;
            for (let i = 1; i < n; i++) {
                const row = perm.charCodeAt(i - 1) - 'a'.charCodeAt(0);
                const col = perm.charCodeAt(i) - 'a'.charCodeAt(0);
                cost += mat[row][col];
            }
            if (cost < minCost) {
                minCost = cost;
            }
        });
 
        return minCost;
    }
 
    // Driver code
    static Main() {
        // Test case input
        const str1 = 'abcde';
        const mat1 = [
            [0, 5, 1, 5, 3],
            [4, 0, 9, 4, 2],
            [7, 9, 0, 10, 7],
            [1, 2, 8, 0, 2],
            [3, 9, 7, 7, 0],
        ];
 
        // Function call
        const result = this.GetMinCost(str1, mat1);
        console.log(result);
    }
}
 
// Call the Main method to run the code
GFG.Main();


Output

8















Time Complexity: O(n!), where n is the length of the string. (as we generate all permutations)
Space Complexity: O(n), where n is the length of the string. (as we store the current permutation in memory)

 

Approch 3 : Dynamic Programming 

The provided code solves the given problem using dynamic programming. Memorization is employed to prevent recomputations and store the status of the subproblems. The current state is sent to the main function “solve” as (mask, prev), where “mask” denotes the set of characters that are now accessible and “prev” denotes the character that was previously positioned. The string is then iterated over, and each conceivable character that could fit in the present location is checked. It repeatedly calls’solve’ with the updated state and computes the cost of inserting the current character based on the previous character and the cost matrix ‘a’ for each character that may be placed at the current position. The current state’s dp table then contains the character placement with the lowest cost out of all potential character placements.

 

Algorithm Steps of the given code are as follows:

1. Define a function check() to check if the current bit is set in the mask.
2. Define a recursive function solve() to find the minimum cost to generate any permutation of the given string.
3. In solve(), check for the base case where mask becomes 0, i.e., all the characters have been used.
4. In solve(), check if the current state has already been computed in the dp table, if yes, then return the precomputed value.
5. In solve(), iterate over the string and check all possible characters available for the current position.
6. In solve(), if the character can be placed at the current position, then check if there is no previous character, in which case the cost for the first character is 0.
7. In solve(), else find the cost of the current character and move to the next position.
8. In solve(), store the answer for each current state in the dp table.
9. Define a function generatePermutation() to generate any permutation of the given string with minimum cost.
10. In generatePermutation(), initialize the dp table and set all the bits of the current character id.
11. In generatePermutation(), call the solve() function with initial parameters and output the minimum cost.
12. In main(), define the input string and cost matrix and call the generatePermutation() function with the inputs.
13. End of the program.

C++




#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
 
int check(int mask, int i) {
    int c = (mask & (1 << i));
    return c != 0;
}
 
int solve(vector<vector<int>>& a, string s, int n, int prev, int mask, vector<vector<int>>& dp) {
    // Base Case
    if (mask == 0) {
        return 0;
    }
 
    // Return the precomputed state
    if (dp[mask][prev + 1] != -1) {
        return dp[mask][prev + 1];
    }
 
    int ans = 10000;
 
    // Iterate over the string and check all possible characters available for the current position
    for (int i = 0; i < s.length(); i++) {
        int id = s[i] - 'a';
 
        // Check if the character can be placed at the current position
        if (check(mask, id)) {
 
            // As there is no previous character so the cost for the 1st character is 0
            if (prev == -1) {
                ans = min(ans, solve(a, s, n, id, mask ^ (1 << id), dp));
            }
 
            // Find the cost of the current character and move to the next position
            else {
                ans = min(ans, a[prev][id] + solve(a, s, n, id, mask ^ (1 << id), dp));
            }
        }
    }
 
    // Store the answer for each current state
    dp[mask][prev + 1] = ans;
    return ans;
}
 
// Function that generates any permutation of the given string with the minimum cost
void generate_permutation(int mask, int n, vector<vector<int>>& a, string s) {
    // Initialize dp table
    vector<vector<int>> dp((1 << n) + 5, vector<int>(n + 5, -1));
 
    // Set all the bits of the current character id
    for (int i = 0; i < s.length(); i++) {
        int id = s[i] - 'a';
        mask |= (1 << id);
    }
 
    // Minimum cost of generating the permutation
    cout << solve(a, s, n, -1, mask, dp) << endl;
}
 
int main() {
    int N = 5;
    string str = "abcde";
 
    vector<vector<int>> mat = {
        {0, 5, 1, 5, 3},
        {4, 0, 9, 4, 2},
        {7, 9, 0, 10, 7},
        {1, 2, 8, 0, 2},
        {3, 9, 7, 7, 0}
    };
 
    // Function Call
    generate_permutation(0, N, mat, str);
 
    return 0;
}


Java




import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
 
public class MinimumCostPermutation {
    public static void main(String[] args) {
        int N = 5;
        String str = "abcde";
 
        List<List<Integer>> mat = Arrays.asList(
            Arrays.asList(0, 5, 1, 5, 3),
            Arrays.asList(4, 0, 9, 4, 2),
            Arrays.asList(7, 9, 0, 10, 7),
            Arrays.asList(1, 2, 8, 0, 2),
            Arrays.asList(3, 9, 7, 7, 0)
        );
 
        // Function Call
        generatePermutation(0, N, mat, str);
    }
 
    public static int check(int mask, int i) {
        int c = (mask & (1 << i));
        return c != 0 ? 1 : 0;
    }
 
    public static int solve(List<List<Integer>> a, String s, int n, int prev, int mask, List<List<Integer>> dp) {
        // Base Case
        if (mask == 0) {
            return 0;
        }
 
        // Return the precomputed state
        if (dp.get(mask).get(prev + 1) != -1) {
            return dp.get(mask).get(prev + 1);
        }
 
        int ans = 10000;
 
        // Iterate over the string and check all possible characters available for the current position
        for (int i = 0; i < s.length(); i++) {
            int id = s.charAt(i) - 'a';
 
            // Check if the character can be placed at the current position
            if (check(mask, id) == 1) {
 
                // As there is no previous character so the cost for the 1st character is 0
                if (prev == -1) {
                    ans = Math.min(ans, solve(a, s, n, id, mask ^ (1 << id), dp));
                }
 
                // Find the cost of the current character and move to the next position
                else {
                    ans = Math.min(ans, a.get(prev).get(id) + solve(a, s, n, id, mask ^ (1 << id), dp));
                }
            }
        }
 
        // Store the answer for each current state
        dp.get(mask).set(prev + 1, ans);
        return ans;
    }
 
    // Function that generates any permutation of the given string with the minimum cost
    public static void generatePermutation(int mask, int n, List<List<Integer>> a, String s) {
        // Initialize dp table
        List<List<Integer>> dp = new ArrayList<>();
        for (int i = 0; i < (1 << n) + 5; i++) {
            List<Integer> row = new ArrayList<>(Arrays.asList(new Integer[n + 5]));
            Collections.fill(row, -1);
            dp.add(row);
        }
 
        // Set all the bits of the current character id
        for (int i = 0; i < s.length(); i++) {
            int id = s.charAt(i) - 'a';
            mask |= (1 << id);
        }
 
        // Minimum cost of generating the permutation
        System.out.println(solve(a, s, n, -1, mask, dp));
    }
}


Python3




# python3 implementaton
def check(mask, i):
    c = (mask & (1 << i))
    return c != 0
 
def solve(a, s, n, prev, mask, dp):
    # Base Case
    if mask == 0:
        return 0
 
    # Return the precomputed state
    if dp[mask][prev + 1] != -1:
        return dp[mask][prev + 1]
 
    ans = 10000
 
    # Iterate over the string and check all possible characters available for current position
    for i in range(len(s)):
        id = ord(s[i]) - ord('a')
         
        # Check if character can be placed at current position
        if check(mask, id):
             
            # As there is no previous character so the cost for 1st character is 0
            if prev == -1:
                ans = min(ans, solve(a, s, n, id, mask ^ (1 << id), dp))
             
            # Find the cost of current character and move to next position
            else:
                ans = min(ans, a[prev][id] + solve(a, s, n, id, mask ^ (1 << id), dp))
 
    # Store the answer for each current state
    dp[mask][prev + 1] = ans
    return ans
 
# Function that generates any permutation of the given string with minimum cost
def generate_permutation(mask, n, a, s):
    # Initialize dp table
    dp = [[-1 for i in range(n + 5)] for j in range((1 << n) + 5)]
 
    # Set all the bits of the current character id
    for i in range(len(s)):
        id = ord(s[i]) - ord('a')
        mask |= (1 << id)
     
    # Minimum cost of generating the permutation
    print(solve(a, s, n, -1, mask, dp))
 
# Driver Code
if __name__ == '__main__':
    N = 5
    str = "abcde"
 
    mat = [[0, 5, 1, 5, 3],
           [4, 0, 9, 4, 2],
           [7, 9, 0, 10, 7],
           [1, 2, 8, 0, 2],
           [3, 9, 7, 7, 0]]
 
    # Function Call
    generate_permutation(0, N, mat, str)


C#




using System;
using System.Collections.Generic;
 
class Program
{
    static int Check(int mask, int i)
    {
        int c = (mask & (1 << i));
        return c != 0 ? 1 : 0;
    }
 
    static int Solve(List<List<int>> a, string s, int n, int prev, int mask, List<List<int>> dp)
    {
        // Base Case
        if (mask == 0)
        {
            return 0;
        }
 
        // Return the precomputed state
        if (dp[mask][prev + 1] != -1)
        {
            return dp[mask][prev + 1];
        }
 
        int ans = 10000;
 
        // Iterate over the string and check all possible characters available for the current position
        for (int i = 0; i < s.Length; i++)
        {
            int id = s[i] - 'a';
 
            // Check if the character can be placed at the current position
            if (Check(mask, id) == 1)
            {
                // As there is no previous character, so the cost for the 1st character is 0
                if (prev == -1)
                {
                    ans = Math.Min(ans, Solve(a, s, n, id, mask ^ (1 << id), dp));
                }
                // Find the cost of the current character and move to the next position
                else
                {
                    ans = Math.Min(ans, a[prev][id] + Solve(a, s, n, id, mask ^ (1 << id), dp));
                }
            }
        }
 
        // Store the answer for each current state
        dp[mask][prev + 1] = ans;
        return ans;
    }
 
    // Function that generates any permutation of the given string with the minimum cost
    static void GeneratePermutation(int mask, int n, List<List<int>> a, string s)
    {
        // Initialize dp table
        List<List<int>> dp = new List<List<int>>();
        for (int i = 0; i < (1 << n) + 5; i++)
        {
            dp.Add(new List<int>());
            for (int j = 0; j < n + 5; j++)
            {
                dp[i].Add(-1);
            }
        }
 
        // Set all the bits of the current character id
        for (int i = 0; i < s.Length; i++)
        {
            int id = s[i] - 'a';
            mask |= (1 << id);
        }
 
        // Minimum cost of generating the permutation
        Console.WriteLine(Solve(a, s, n, -1, mask, dp));
    }
 
    static void Main(string[] args)
    {
        int N = 5;
        string str = "abcde";
 
        List<List<int>> mat = new List<List<int>> {
            new List<int> {0, 5, 1, 5, 3},
            new List<int> {4, 0, 9, 4, 2},
            new List<int> {7, 9, 0, 10, 7},
            new List<int> {1, 2, 8, 0, 2},
            new List<int> {3, 9, 7, 7, 0}
        };
 
        // Function Call
        GeneratePermutation(0, N, mat, str);
    }
}


Javascript




function check(mask, i) {
    return (mask & (1 << i)) !== 0;
}
 
function solve(a, s, n, prev, mask, dp) {
    // Base Case
    if (mask === 0) {
        return 0;
    }
 
    // Return the precomputed state
    if (dp[mask][prev + 1] !== -1) {
        return dp[mask][prev + 1];
    }
 
    let ans = 10000;
 
    // Iterate over the string and check all possible characters
    // available for the current position
    for (let i = 0; i < s.length; i++) {
        let id = s.charCodeAt(i) - 'a'.charCodeAt(0);
 
        // Check if the character can be placed at the current position
        if (check(mask, id)) {
 
            // As there is no previous character so the cost for the 1st character is 0
            if (prev === -1) {
                ans = Math.min(ans, solve(a, s, n, id, mask ^ (1 << id), dp));
            }
 
            // Find the cost of the current character and move to the next position
            else {
                ans = Math.min(ans, a[prev][id] + solve(a, s, n, id, mask ^ (1 << id), dp));
            }
        }
    }
 
    // Store the answer for each current state
    dp[mask][prev + 1] = ans;
    return ans;
}
 
// Function that generates any permutation of the given string with the minimum cost
function generatePermutation(mask, n, a, s) {
    // Initialize dp table
    let dp = new Array((1 << n) + 5).fill(null).map(() => new Array(n + 5).fill(-1));
 
    // Set all the bits of the current character id
    for (let i = 0; i < s.length; i++) {
        let id = s.charCodeAt(i) - 'a'.charCodeAt(0);
        mask |= (1 << id);
    }
 
    // Minimum cost of generating the permutation
    console.log(solve(a, s, n, -1, mask, dp));
}
 
// Main function
function main() {
    let N = 5;
    let str = "abcde";
 
    let mat = [
        [0, 5, 1, 5, 3],
        [4, 0, 9, 4, 2],
        [7, 9, 0, 10, 7],
        [1, 2, 8, 0, 2],
        [3, 9, 7, 7, 0]
    ];
 
    // Function Call
    generatePermutation(0, N, mat, str);
}
 
// Invoke the main function
main();


Output

8
















Time Complexity :  O(N * 2^N), where N is the size of the string.

Space Auxilitary Complexity : O(2^N * N).



Similar Reads

Check if any permutation of a given string is lexicographically larger than the other given string
Given two strings str1 and str2 of same length N, the task is to check if there exists any permutation possible in any of the given strings, such that every character of one string is greater or equal to every character of the other string, at corresponding indices. Return true if permutation exists otherwise false. Example: Input: str1 = "adb", st
10 min read
Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given
Given a sorted array arr[] consisting of N positive integers such that arr[i] represent the days in which a worker will work and an array cost[] of size 3 representing the salary paid to the workers for 1 day, 7 days and 30 days respectively, the task is to find the minimum cost required to have a worker for all the given days in arr[]. Examples: I
23 min read
Minimum cost to delete characters from String A to remove any subsequence as String B
Given two strings A and B of size N and M respectively, where B is a sub-sequence of A and an array arr[] of size N, where arr[i] is the cost to delete ith character from string A. The task is to find the minimum cost to delete characters from A such that after deletion no subsequence of A is the same as B. Examples: Input: A = "abccd", B = "ccd",
20 min read
Minimum number of given operations required to convert a permutation into an identity permutation
Given a permutation P (P1, P2, P3, ... Pn) of first n natural numbers. Find the minimum number of operations to convert it into an identity permutation i.e. 1, 2, 3, ..., n where each operation is defined as: P[i] = P[P[P[i]]] [Tex]\forall [/Tex]i from 1 to n (1 based indexing). If there is no way to convert then print -1.Examples: Input: arr[] = {
11 min read
Minimum number of adjacent swaps required to convert a permutation to another permutation by given condition
Given a permutation P of size N, having values from 1 to N. the task is to find the minimum number of adjacent swaps required such that for all i in the range [1, N], P[i] does not equal i.Examples: Input: P = [1, 4, 3, 5, 2] Output: 2 Explanation: Here P = [1, 4, 3, 5, 2] at index 1, 2, 3, 4, 5. As we can see, P[1] = 1 and P[3] = 3. Hence, we need
7 min read
Minimize cost to sort an Array by swapping any pair of element (X, Y) with cost as (X + Y)
Given an array arr[] consisting of N integers, the task is to find the minimum cost to sort the given array arr[] in ascending order by swapping any pair of elements (X, Y) such that the cost of swapping is (X + Y). Examples: Input: arr[] = {3, 2, 1}Output: 4Explanation:Following are the swapping of array elements performed to sort the array: Swapp
13 min read
Minimize cost to connect the graph by connecting any pairs of vertices having cost at least 0
Given a disconnected graph G with N vertices and M edges and an array cost[] corresponding to each vertex, the task is to find the minimum cost to make the graph by connecting any pairs of vertices having the cost of vertices at least 0 and the cost of connecting those pair of vertices is the sum of the cost of individual vertices. If it is impossi
17 min read
Minimum cost to convert all elements of a K-size subarray to 0 from given Ternary Array with subarray sum as cost
Given an array arr[] of N integers, where each array element is either 0, 1, or 2, and an integer K, the task is to print the minimum cost needed to convert all the elements of the array to 0s by selecting a subarray of size K and converting any array element of the subarray to 0 in one operation with the cost equal to the sum of elements of the su
11 min read
Minimum Cost To set Digital Clock Timer with given movement and push cost
Given integers A, B and N. The task is to minimize the cost to set N seconds in a digital clock where time is represented in the following format: at most 99 minutes and 99 secondsat least 1 secondThe first two digits represent minutes and the last two minutes represent seconds.It prepends 0 if less than 4 digits are pressed to set time A is the co
14 min read
Check if any permutation of N equals any power of K
Given a positive integer N and K where [Tex]2 \leq N \leq 10^{18} [/Tex] and [Tex]2 \leq K \leq N [/Tex] . The task is to check whether any permutation of digits of N equals any power of K. If possible return "True" otherwise return "False".Examples: Input: N = 96889010407, K = 7 Output: True Explanation: 96889010407 = 713 Input : N = 123456789, K
6 min read