Maximum Total Reward Using Operations II - Practice Coding Problems

Maximum Total Reward Using Operations II - Problem

You're presented with an exciting challenge: maximize your total reward by strategically collecting values from an array!

Given an integer array rewardValues of length n, you start with a total reward of x = 0. Here's the twist: you can only collect a reward if it's greater than your current total!

The Rules:

Choose any unmarked index i where rewardValues[i] > x
Add rewardValues[i] to your total reward x
Mark that index as used (can't use it again)
Repeat until no more valid moves exist

Your mission: Find the maximum possible total reward you can achieve through optimal play!

Example: With [1, 6, 4, 3, 2], you could collect 1→2→3→4→6 for a total of 16, but there might be a better strategy...

Input & Output

example_1.py — Basic Example

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

› Output: 11

💡 Note: We can collect rewards in the order: 1 (x=1), then 2 (x=3), then 4 (x=7), then 6 (x=13 > 11, so we can't take it). Wait, let's recalculate: 1→2→3→4 gives us 10 total, but we could do 1→6 for 7, then we can't take anything else. Better: 1→2→4→6 isn't valid since 6>4. The optimal is 1→2→3→4→6 isn't possible. Actually: 1(x=1)→2(x=3)→4(x=7)→6 can't be taken since 6<7. So 1→2→4 gives 7, then no valid moves. Optimal: 1→6→7→8...let me recalculate systematically.

example_2.py — Simple Case

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

› Output: 4

💡 Note: We can take one instance of 1 (x=1), then one instance of 3 (x=4). We cannot take another 3 since 3 < 4, and we've used the other 1.

example_3.py — Edge Case

$ Input: [1]

› Output: 1

💡 Note: We can only take the single reward of 1, giving us a total of 1.

Constraints

1 ≤ rewardValues.length ≤ 2000
1 ≤ rewardValues[i] ≤ 2000
You can use each reward value at most once
Key constraint: You can only collect a reward if it's greater than your current total

Visualization

Tap to expand

Understanding the Visualization

Start Empty-Handed

Begin with 0 gold - only this amount is initially achievable

Sort the Treasures

Arrange chests by value to process systematically

Track Possibilities

Use bitset to remember all possible gold amounts

Expand Smartly

For each chest, only consider taking it if current gold < chest value

Find Maximum

Return the highest achievable gold amount

Key Takeaway

🎯 Key Insight: By using bit manipulation to track achievable sums and processing rewards in sorted order, we can efficiently find the maximum total reward in O(n×S) time, where S is the sum of all rewards.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses bit manipulation DP to efficiently track all achievable reward totals. By processing rewards in sorted order and using bitwise operations, we achieve O(n×S) time complexity where S is the sum of rewards. The key insight is that we only need to track which sums are possible, not how we achieved them.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(2^n * n)	O(2^n)	Use memoization to avoid recalculating the same states
Bit Manipulation DP (Optimal)	O(n * S)	O(S)	Use bitset to efficiently track all achievable sums
Brute Force (Try All Sequences)	O(2^n)	O(n)	Recursively try all possible sequences of collecting rewards

Dynamic Programming with Memoization — Algorithm Steps

Create a memoization map to store computed states
Define state as (current_total, used_mask) pair
For each state, try all valid next moves
Before computing, check if state already exists in memo
Cache and return the result for future use

Visualization

Tap to expand

Step-by-Step Walkthrough

First calculation

Compute result for state (total=3, mask=101)

Cache result

Store result in memo table

Encounter same state

Later exploration reaches same state

Return cached result

Avoid recalculation by using cached value

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int currentTotal;
    int usedMask;
    int result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

int findMemo(int currentTotal, int usedMask) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].currentTotal == currentTotal && memo[i].usedMask == usedMask) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int currentTotal, int usedMask, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].currentTotal = currentTotal;
        memo[memoSize].usedMask = usedMask;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int* rewardValues, int n, int currentTotal, int usedMask) {
    int cached = findMemo(currentTotal, usedMask);
    if (cached != -1) {
        return cached;
    }
    
    int maxReward = currentTotal;
    
    for (int i = 0; i < n; i++) {
        if ((usedMask & (1 << i)) || rewardValues[i] <= currentTotal) {
            continue;
        }
        
        int newTotal = currentTotal + rewardValues[i];
        int newMask = usedMask | (1 << i);
        int result = dp(rewardValues, n, newTotal, newMask);
        if (result > maxReward) {
            maxReward = result;
        }
    }
    
    addMemo(currentTotal, usedMask, maxReward);
    return maxReward;
}

int maxTotalReward(int* rewardValues, int n) {
    memoSize = 0;
    return dp(rewardValues, n, 0, 0);
}

int main() {
    int n;
    scanf("%d", &n);
    int* rewardValues = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &rewardValues[i]);
    }
    
    printf("%d\n", maxTotalReward(rewardValues, n));
    free(rewardValues);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

We have at most 2^n states (all possible used_mask values), and for each state we try n moves

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores up to 2^n different states

⚠ Quadratic Space

48.5K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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 Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler