# Lexicographically largest string possible for a given cost of appending characters

Given an integer W and an array a[] of size 26 where ai denotes the cost of using the ith alphabet, the task is to find lexicographically the largest string that can be generated for a cost, W.

Examples:

Input: W = 236, a[] = {1, 1, 2, 33, 4, 6, 9, 7, 36, 32, 58, 32, 28, 904, 22, 255, 47, 69, 558, 544, 21, 36, 48, 85, 48, 58}
Output: zzzze
Explanation:
4 * (cost of z) + cost of e = 4 * 58 + 4 = 232 + 4 = 236

Input: W = 6674, a[] = {252, 288, 578, 746, 295, 884, 198, 655, 503, 868, 942, 506, 718, 498, 727, 338, 43, 768, 783, 312, 369, 712, 230, 106, 102, 554}
Output: zzzzzzzzzzzyyyyqqqq
Explanation:
11 * (cost of z) + 4 * (cost of y) + 4 * (cost of q) = 11 * 554 + 4 * 102 + 4 * 43 = 6094 + 408 + 172 = 6674

Approach: The idea is to iterate over the array a[] from the characters ‘z‘ to ‘a‘ alphabets. Now, find a combination in a[] where the sum is equal to W. The same repeated number may be chosen from a[] an unlimited number of times. Then, use recursion and backtracking to solve the problem. Follow the steps below to solve the problem:

• For the subproblem sum = 0 at any instant, print the string obtained as the cost of the characters stored in the array till now sums up to W and since the string has been generated appending characters starting from ‘z‘, the string thus formed is the lexicographically the largest string.
• Otherwise, if the sum is negative or index < 0, return false for these subproblems.
• Otherwise, find lexicographically the largest string possible by including as well as excluding the current character in the resultant string.
• Print lexicographically the largest string obtained by completing the above steps.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the ` `// lexicographically largest ` `// String possible` `bool` `lexi_largest_String(``int` `a[], ``int` `i, ` `                         ``int` `sum, vector<``int``> &v)` `{` `  ``// If sum is less than 0` `  ``if` `(sum < 0)` `    ``return` `false``;`   `  ``// If sum is equal to 0` `  ``if` `(sum == 0)` `    ``return` `true``;`   `  ``// If sum is less than 0` `  ``if` `(i < 0)` `    ``return` `false``;`   `  ``// Add current character` `  ``v.push_back(i);`   `  ``// Check if selecting current` `  ``// character generates ` `  ``// lexicographically largest String` `  ``if` `(lexi_largest_String(a, i, ` `                          ``sum - a[i], v))` `    ``return` `true``;`   `  ``// Backtrack if solution ` `  ``// not found` `  ``auto` `it = v.end();` `  ``it--;` `  ``v.erase(it);`   `  ``// Find the lexicographically` `  ``// largest String excluding` `  ``// the current character` `  ``return` `lexi_largest_String(a, i - 1, ` `                             ``sum, v);` `}` ` `  `// Function to print the ` `// lexicographically largest ` `// String generated` `void` `generateString(``int` `a[], ``int` `sum)` `{` `  ``vector<``int``> v;`   `  ``// Function call` `  ``lexi_largest_String(a, 25, ` `                      ``sum, v);`   `  ``// Stores the String` `  ``string s = ``""``;`   `  ``for` `(``int` `j = 0; j < v.size(); j++)` `    ``s += (``char``)(v[j] + ``'a'``);`   `  ``// Print the lexicographically` `  ``// largest String formed` `  ``cout << s << endl;` `}`   `// Driver code ` `int` `main()` `{` `  ``// Cost of adding each ` `  ``// alphabet` `  ``int` `a[] = {1, 1, 2, 33, 4, 6, 9,` `             ``7, 36, 32, 58, 32, 28, ` `             ``904, 22, 255, 47, 69, ` `             ``558, 544, 21, 36, 48, ` `             ``85, 48, 58};`   `  ``// Cost of generating` `  ``// the String` `  ``int` `sum = 236;`   `  ``generateString(a, sum);  ` `  ``return` `0;` `}`   `// This code is contributed by divyeshrabadiya07`

## Java

 `// Java Program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to find the ` `// lexicographically largest ` `// String possible` `static` `boolean` `lexi_largest_String(``int` `a[], ``int` `i,` `                                   ``int` `sum, ` `                                   ``Vector v)` `{` `  ``// If sum is less than 0` `  ``if` `(sum < ``0``)` `    ``return` `false``;`   `  ``// If sum is equal to 0` `  ``if` `(sum == ``0``)` `    ``return` `true``;`   `  ``// If sum is less than 0` `  ``if` `(i < ``0``)` `    ``return` `false``;`   `  ``// Add current character` `  ``v.add(i);`   `  ``// Check if selecting current` `  ``// character generates ` `  ``// lexicographically largest String` `  ``if` `(lexi_largest_String(a, i, sum - ` `                          ``a[i], v))` `    ``return` `true``;`   `  ``// Backtrack if solution ` `  ``// not found` `  ``v.remove(v.size() - ``1``);`   `  ``// Find the lexicographically` `  ``// largest String excluding` `  ``// the current character` `  ``return` `lexi_largest_String(a, i - ``1``,` `                             ``sum, v);` `}`   `// Function to print the ` `// lexicographically largest ` `// String generated` `static` `void` `generateString(``int` `a[], ` `                           ``int` `sum)` `{` `  ``Vector v = ``new` `Vector();`   `  ``// Function call` `  ``lexi_largest_String(a, ``25``, sum, v);`   `  ``// Stores the String` `  ``String s = ``""``;`   `  ``for` `(``int` `j = ``0``; j < v.size(); j++)` `    ``s += (``char``)(v.get(j) + ``'a'``);`   `  ``// Print the lexicographically` `  ``// largest String formed` `  ``System.out.print(s + ``"\n"``);` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `  ``// Cost of adding each alphabet` `  ``int` `a[] = {``1``, ``1``, ``2``, ``33``, ``4``, ``6``, ``9``,` `             ``7``, ``36``, ``32``, ``58``, ``32``, ``28``, ` `             ``904``, ``22``, ``255``, ``47``, ``69``, ` `             ``558``, ``544``, ``21``, ``36``, ``48``, ` `             ``85``, ``48``, ``58``};`   `  ``// Cost of generating` `  ``// the String` `  ``int` `sum = ``236``;`   `  ``generateString(a, sum);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find the lexicographically` `# largest string possible` `def` `lexi_largest_string(a, i, ``sum``, v):`   `    ``# If sum is less than 0` `    ``if` `(``sum` `< ``0``):` `        ``return` `False`   `    ``# If sum is equal to 0` `    ``if` `(``sum` `=``=` `0``):` `        ``return` `True`   `    ``# If sum is less than 0` `    ``if` `(i < ``0``):` `        ``return` `False`   `    ``# Add current character` `    ``v.append(i)`   `    ``# Check if selecting current character` `    ``# generates lexicographically` `    ``# largest string` `    ``if``(lexi_largest_string(a, i, ` `                           ``sum` `-` `a[i], v)):` `        ``return` `True`   `    ``# Backtrack if solution not found` `    ``v.pop(``-``1``)`   `    ``# Find the lexicographically` `    ``# largest string excluding` `    ``# the current character` `    ``return` `lexi_largest_string(a, i ``-` `1``,` `                               ``sum``, v)`   `# Function to print the lexicographically` `# largest string generated` `def` `generateString(a, ``sum``):`   `    ``v ``=` `[]`   `    ``# Function call` `    ``lexi_largest_string(a, ``25``, ``sum` `, v)`   `    ``# Stores the string` `    ``s ``=` `""`   `    ``for` `j ``in` `range``(``len``(v)):` `        ``s ``+``=` `chr``(v[j] ``+` `ord``(``'a'``))`   `    ``# Print the lexicographically` `    ``# largest string formed` `    ``print``(s)`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``a ``=` `[ ``1``, ``1``, ``2``, ``33``, ``4``, ``6``, ``9``,` `          ``7``, ``36``, ``32``, ``58``, ``32``, ``28``,` `          ``904``, ``22``, ``255``, ``47``, ``69``,` `          ``558``, ``544``, ``21``, ``36``, ``48``,` `          ``85``, ``48``, ``58` `]`   `    ``# Cost of generating` `    ``# the string` `    ``sum` `=` `236`   `    ``generateString(a, ``sum``)`   `# This code is contributed by Shivam Singh`

## C#

 `// C# Program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{`   `// Function to find the ` `// lexicographically largest ` `// String possible` `static` `bool` `lexi_largest_String(``int` `[]a, ``int` `i, ` `                                ``int` `sum, List<``int``> v)` `{` `  ``// If sum is less than 0` `  ``if` `(sum < 0)` `    ``return` `false``;`   `  ``// If sum is equal to 0` `  ``if` `(sum == 0)` `    ``return` `true``;`   `  ``// If sum is less than 0` `  ``if` `(i < 0)` `    ``return` `false``;`   `  ``// Add current character` `  ``v.Add(i);`   `  ``// Check if selecting current` `  ``// character generates ` `  ``// lexicographically largest String` `  ``if` `(lexi_largest_String(a, i, sum - ` `                          ``a[i], v))` `    ``return` `true``;`   `  ``// Backtrack if solution ` `  ``// not found` `  ``v.RemoveAt(v.Count - 1);`   `  ``// Find the lexicographically` `  ``// largest String excluding` `  ``// the current character` `  ``return` `lexi_largest_String(a, i - 1,` `                             ``sum, v);` `}`   `// Function to print the ` `// lexicographically largest ` `// String generated` `static` `void` `generateString(``int` `[]a, ` `                           ``int` `sum)` `{` `  ``List<``int``> v = ``new` `List<``int``>();`   `  ``// Function call` `  ``lexi_largest_String(a, 25, sum, v);`   `  ``// Stores the String` `  ``String s = ``""``;`   `  ``for` `(``int` `j = 0; j < v.Count; j++)` `    ``s += (``char``)(v[j] + ``'a'``);`   `  ``// Print the lexicographically` `  ``// largest String formed` `  ``Console.Write(s + ``"\n"``);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Cost of adding each alphabet` `  ``int` `[]a = {1, 1, 2, 33, 4, 6, 9,` `             ``7, 36, 32, 58, 32, 28, ` `             ``904, 22, 255, 47, 69, ` `             ``558, 544, 21, 36, 48, ` `             ``85, 48, 58};`   `  ``// Cost of generating` `  ``// the String` `  ``int` `sum = 236;`   `  ``generateString(a, sum);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`zzzze`

Time Complexity: O(226)
Auxiliary Space: O(N)