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 = 236Input: 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++ Program to implement // the above approach #include <bits/stdc++.h> 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 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<Integer> 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<Integer> v = new Vector<Integer>();
// 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 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# 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 |
<script> // Javascript Program to implement the above approach
// Function to find the
// lexicographically largest
// String possible
function 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.push(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();
// 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
function generateString(a, sum)
{
let v = [];
// Function call
lexi_largest_String(a, 25, sum, v);
// Stores the String
let s = "" ;
for (let j = 0; j < v.length; j++)
s += String.fromCharCode(v[j] + 'a' .charCodeAt());
// Print the lexicographically
// largest String formed
document.write(s + "</br>" );
}
// Cost of adding each alphabet
let 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
let sum = 236;
generateString(a, sum);
</script> |
zzzze
Time Complexity: O(226)
Auxiliary Space: O(N)