Maximum Total Reward Using Operations I - Practice Coding Problems

Maximum Total Reward Using Operations I - Problem

Imagine you're a treasure hunter exploring a dungeon filled with reward chests of different values. You start with x = 0 gold coins, and there's a magical rule: you can only open a chest if its value is greater than your current total gold.

Given an integer array rewardValues representing the values of n chests, your goal is to maximize the total reward you can collect. Each chest can only be opened once, and you must choose the order strategically to unlock the highest possible total.

The Challenge: Once you collect a reward, your total increases, which might prevent you from opening smaller chests later. Plan your moves wisely!

Example: With chests [1, 1, 3, 3], you could collect 1 + 3 = 4 coins by opening the first chest (value 1) when x=0, then a chest with value 3 when x=1.

Input & Output

example_1.py — Basic Case

$ Input: [1,1,3,3]

› Output: 4

💡 Note: Start with x=0. Select first reward=1 (since 1>0), now x=1. Then select reward=3 (since 3>1), now x=4. Cannot select any more rewards as remaining values ≤ 4.

example_2.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: Start with x=0. Select the only reward=1 (since 1>0), achieving maximum total of 1.

example_3.py — Optimal Strategy Required

$ Input: [1,6,4,3,2]

› Output: 11

💡 Note: Optimal sequence: Select 1 (x=1), then 2 (x=3), then 4 (x=7), then skip smaller values and cannot select 6. Total = 7. Better: Select 1 (x=1), then 6 (x=7), then 4 cannot be selected. Actually optimal is: 1→2→3→4→6 is impossible. Correct optimal: 1→2→4→6 = 13, but 6>4 fails. Correct path: 1→2→3→6 = 12, but 6>3 works, so 1+2+3+6=12. Wait, let me recalculate: 1(x=1)→2(x=3)→4(x=7), now 6<7 so can't select 6. Actually: 1→6 works(x=7), then 4<7 fails, 3<7 fails, 2<7 fails. So just 7. But 1→2→4 gives 7, then no more. Try 1→2→3 gives 6, then 4<6 fails, 6=6 fails. Hmm, 1+2+3+nothing more working gives 6. Let me try 1+6=7, then nothing works. Or 2+3+4+6: start with 2(x=2), then 3(x=5), then 6>5 works(x=11), then 4<11 fails. So 2+3+6=11.

Constraints

1 ≤ rewardValues.length ≤ 2000
1 ≤ rewardValues[i] ≤ 2000
All elements in rewardValues are positive integers
You can only select a reward if its value is strictly greater than your current total

Visualization

Tap to expand

Understanding the Visualization

Start Empty-Handed

Begin with 0 coins - this is always achievable

Consider Each Treasure

For each reward, see which existing totals can be extended

Apply the Magic Rule

Only add a reward if it's greater than your current total

Track All Possibilities

Mark all new achievable totals in your treasure map

Find Maximum

Return the highest achievable treasure amount

Key Takeaway

🎯 Key Insight: Use dynamic programming to systematically explore all possible treasure combinations while respecting the magic rule that you can only collect rewards greater than your current total.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses dynamic programming to track all achievable reward totals. We maintain a boolean array dp where dp[i] indicates if total i is achievable. For each reward value, we update the DP table by extending existing achievable totals. The key insight is processing rewards in sorted order and iterating backwards to avoid conflicts. Time complexity: O(n × sum), Space: O(sum).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitset Optimization	O(n * sum)	O(sum)	Use dynamic programming with bitset to track achievable reward totals efficiently
Brute Force (Try All Combinations)	O(2^n)	O(n)	Recursively try all possible sequences of selecting rewards

Dynamic Programming with Bitset Optimization — Algorithm Steps

Sort rewards in ascending order for better efficiency
Initialize a bitset or boolean array to track achievable totals
Set dp[0] = true (we can achieve total 0 initially)
For each reward value, iterate through possible totals in descending order
If we can achieve total 'x' and reward > x, then we can achieve total x + reward
Return the maximum index where dp[i] is true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with dp[0] = true (can achieve total 0)

Process Rewards

For each reward, update achievable totals

State Transition

If dp[x] is true and reward > x, set dp[x + reward] = true

Find Maximum

Return the highest index where dp[i] = true

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int maximumTotalReward(int* rewardValues, int n) {
    if (n == 0) return 0;
    
    // Sort and remove duplicates
    qsort(rewardValues, n, sizeof(int), compare);
    
    int uniqueRewards[n];
    int uniqueCount = 1;
    uniqueRewards[0] = rewardValues[0];
    
    for (int i = 1; i < n; i++) {
        if (rewardValues[i] != rewardValues[i-1]) {
            uniqueRewards[uniqueCount++] = rewardValues[i];
        }
    }
    
    int maxSum = 0;
    for (int i = 0; i < uniqueCount; i++) {
        maxSum += uniqueRewards[i];
    }
    
    bool* dp = (bool*)calloc(maxSum + 1, sizeof(bool));
    dp[0] = true;
    
    for (int i = 0; i < uniqueCount; i++) {
        int reward = uniqueRewards[i];
        int limit = reward < maxSum - reward ? reward : maxSum - reward;
        
        for (int total = limit; total >= 0; total--) {
            if (dp[total]) {
                dp[total + reward] = true;
            }
        }
    }
    
    // Find maximum achievable total
    for (int i = maxSum; i >= 0; i--) {
        if (dp[i]) {
            free(dp);
            return i;
        }
    }
    
    free(dp);
    return 0;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int arr[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL && n < 100) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maximumTotalReward(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * sum)

We process each of n rewards, and for each reward we may update up to 'sum' possible totals

✓ Linear Growth

Space Complexity

O(sum)

We need space to track all possible reward totals up to the sum of all rewards

✓ Linear Space

31.2K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Bitset Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler