Form Largest Integer With Digits That Add up to Target

Form Largest Integer With Digits That Add up to Target - Problem

Given an array of integers cost and an integer target, return the maximum integer you can paint under the following rules:

The cost of painting a digit (i + 1) is given by cost[i] (0-indexed).
The total cost used must be equal to target.
The integer does not have 0 digits.

Since the answer may be very large, return it as a string. If there is no way to paint any integer given the condition, return "0".

Input & Output

Example 1 — Basic Case

$ Input: cost = [4,3,2,5,6,7,2,5,5], target = 7

› Output: "772"

💡 Note: We can paint digit 7 twice (cost 2 each) and digit 2 once (cost 3), giving total cost 2+2+3=7. The digits 7,7,2 arranged in descending order give us 772.

Example 2 — No Solution

$ Input: cost = [7,6,5,5,5,6,8,7,8], target = 5

› Output: "5"

💡 Note: The minimum cost is 5 (for digits 3, 4, or 5). With target=5, we can afford exactly one digit. The largest digit that costs 5 is digit 5, so the result is "5".

Example 3 — Multiple Digits

$ Input: cost = [2,4,6,2,4,6,4,4,4], target = 5

› Output: "0"

💡 Note: Digits 1 and 4 cost 2 each. We could paint two of them for cost 4, leaving 1 remaining cost, but no digit costs 1. We could paint one digit costing 2, leaving 3 remaining, but no digit costs exactly 3. No combination of digits sums to exactly 5, so no solution exists.

Constraints

cost.length == 9
1 ≤ cost[i] ≤ 5000
1 ≤ target ≤ 5000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to maximize the number of digits first, then greedily construct the largest number. Use Dynamic Programming to find the maximum digits achievable, then Greedy Construction to build the lexicographically largest number. Best approach: Two-Phase DP. Time: O(target + digits²), Space: O(target)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Memoized Recursion

⏱️ Time: O(target × 9) Space: O(target)

Use memoization to store results of subproblems, significantly reducing redundant recursive calls.

Recursive Backtracking

⏱️ Time: O(9^target) Space: O(target)

Explore every possible way to spend the target cost by trying each digit recursively. Keep track of the best result found so far.

Two-Phase Dynamic Programming

⏱️ Time: O(target + digits²) Space: O(target)

Use DP to find maximum number of digits achievable with exact target cost, then greedily construct the lexicographically largest number.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_TARGET 5001
#define MAX_RESULT_LEN 10000

static char memo[MAX_TARGET][MAX_RESULT_LEN];
static bool computed[MAX_TARGET];
static int cost[9];

void dp(int remaining, char* result) {
    if (computed[remaining]) {
        strcpy(result, memo[remaining]);
        return;
    }
    
    if (remaining == 0) {
        strcpy(result, "");
        strcpy(memo[remaining], result);
        computed[remaining] = true;
        return;
    }
    
    if (remaining < 0) {
        strcpy(result, "INVALID");
        return;
    }
    
    strcpy(result, "INVALID");
    
    for (int digit = 1; digit <= 9; digit++) {
        if (cost[digit - 1] <= remaining) {
            char subResult[MAX_RESULT_LEN];
            dp(remaining - cost[digit - 1], subResult);
            
            if (strcmp(subResult, "INVALID") != 0) {
                char current[MAX_RESULT_LEN];
                sprintf(current, "%d%s", digit, subResult);
                
                if (strcmp(result, "INVALID") == 0 || 
                    strlen(current) > strlen(result) ||
                    (strlen(current) == strlen(result) && strcmp(current, result) > 0)) {
                    strcpy(result, current);
                }
            }
        }
    }
    
    strcpy(memo[remaining], result);
    computed[remaining] = true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse cost array
    int costSize = 0;
    const char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        cost[costSize++] = (int)strtol(p, (char**)&p, 10);
    }
    
    fgets(line, sizeof(line), stdin);
    int target = atoi(line);
    
    memset(computed, false, sizeof(computed));
    
    char result[MAX_RESULT_LEN];
    dp(target, result);
    
    if (strcmp(result, "INVALID") == 0) {
        printf("0\n");
    } else {
        printf("%s\n", result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen