Maximum Total Reward Using Operations I

Maximum Total Reward Using Operations I - Problem

You are given an integer array rewardValues of length n, representing the values of rewards. Initially, your total reward x is 0, and all indices are unmarked.

You are allowed to perform the following operation any number of times:

Choose an unmarked index i from the range [0, n - 1].
If rewardValues[i] is greater than your current total reward x, then add rewardValues[i] to x (i.e., x = x + rewardValues[i]), and mark the index i.

Return an integer denoting the maximum total reward you can collect by performing the operations optimally.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Sort to [1,1,3,3]. Start with total=0. Select first 1 (1>0), total=1. Skip second 1 (1≤1). Select first 3 (3>1), total=4. Skip second 3 (3≤4). Maximum reward is 4.

Example 2 — All Selectable

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

› Output: 11

💡 Note: We can select rewards in optimal order. One optimal sequence: select 2 (total=2), then 3 (total=5), then 6 (total=11). Other values become unselectable. Maximum reward is 11.

Example 3 — Single Element

$ Input: rewardValues = [5]

› Output: 5

💡 Note: Only one element [5]. Since 5 > 0, we can select it. Maximum reward is 5.

Constraints

1 ≤ rewardValues.length ≤ 2000
1 ≤ rewardValues[i] ≤ 2000

Visualization

Tap to expand

Asked in

M Meta 15 a Amazon 12 M Microsoft 8

The key insight is to sort the rewards and use a greedy approach. Start with total reward 0, then iterate through sorted rewards and select each reward only if it's greater than the current total. This maximizes the number of rewards we can collect. Best approach is Greedy with Sorting: Time O(n log n), Space O(1).

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

Use recursion to explore every possible way of selecting rewards. For each unmarked reward greater than current total, try selecting it and recursively find the maximum from remaining choices.

Dynamic Programming with Memoization

⏱️ Time: O(n × 2ⁿ × S) Space: O(2ⁿ × S)

Optimize the recursive approach by caching results for states we've already computed. Each state is defined by the current reward total and the set of used indices.

Greedy with Sorting

⏱️ Time: O(n log n) Space: O(1)

Sort the rewards in ascending order, then greedily select the largest reward that is greater than the current total. This ensures we can continue selecting as many rewards as possible.

Brute Force Recursion — Algorithm Steps

Try selecting each valid reward
Recursively solve for remaining rewards
Return maximum across all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with reward 0, all indices unmarked

Try Each Valid Choice

For each reward > current total, try selecting it

Recursive Exploration

Recursively find maximum from each choice

Code -

solution.c — C

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

int backtrack(int currentReward, bool* used, int* rewardValues, int n) {
    int maxReward = currentReward;
    for (int i = 0; i < n; i++) {
        if (!used[i] && rewardValues[i] > currentReward) {
            used[i] = true;
            int result = backtrack(currentReward + rewardValues[i], used, rewardValues, n);
            if (result > maxReward) maxReward = result;
            used[i] = false;
        }
    }
    return maxReward;
}

int solution(int* rewardValues, int n) {
    bool* used = (bool*)calloc(n, sizeof(bool));
    int result = backtrack(0, used, rewardValues, n);
    free(used);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int rewardValues[1000];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '[' && token[0] != ']') {
            rewardValues[n++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    printf("%d\n", solution(rewardValues, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each reward can be selected or not selected, leading to 2^n possible combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels

⚡ Linearithmic Space

17.0K Views

Medium Frequency

~25 min Avg. Time

680 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

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler