 GFG App
Open App Browser
Continue

# Minimum cost to generate any permutation of the given string

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 = 2
Cost of placing e after b = mat = 2
Cost of placing a after e = mat = 3
Cost of placing c after a = mat = 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 ` `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> a, string s, ` `          ``int` `n, ``int` `prev, ``int` `mask, ` `          ``vector> 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> a, ` `                         ``string s)` `{` `    `  `    ``// Initialize dp table` `    ``vector> 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> 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

 ``

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.

## 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`

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.

## 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``)`

Output

```8
```

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

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

My Personal Notes arrow_drop_up