Solving Questions With Brainpower

Solving Questions With Brainpower - Problem

You are given a 0-indexed 2D integer array questions where questions[i] = [points_i, brainpower_i].

The array describes the questions of an exam, where you have to process the questions in order (i.e., starting from question 0) and make a decision whether to solve or skip each question. Solving question i will earn you points_i points but you will be unable to solve each of the next brainpower_i questions. If you skip question i, you get to make the decision on the next question.

Example: Given questions = [[3, 2], [4, 3], [4, 4], [2, 5]]:

If question 0 is solved, you will earn 3 points but you will be unable to solve questions 1 and 2.
If instead, question 0 is skipped and question 1 is solved, you will earn 4 points but you will be unable to solve questions 2 and 3.

Return the maximum points you can earn for the exam.

Input & Output

Example 1 — Basic Decision Making

$ Input: questions = [[3,2],[4,3],[4,4],[2,5]]

› Output: 5

💡 Note: Maximum points by solving question 0 (3 points, skip questions 1,2) then solving question 3 (2 points) for total 3+2=5 points.

Example 2 — All Skip vs Solve Dilemma

$ Input: questions = [[1,1],[2,2],[3,3],[4,4],[5,5]]

› Output: 7

💡 Note: Optimal strategy: solve questions at indices 1 (2 points, skip question 2,3) and 4 (5 points) for total 2+5=7 points

Example 3 — Single Question

$ Input: questions = [[21,5]]

› Output: 21

💡 Note: Only one question available, solve it for 21 points

Constraints

1 ≤ questions.length ≤ 10⁵
questions[i].length == 2
1 ≤ points_i, brainpower_i ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 M Microsoft 6

The key insight is to work backwards from the end, deciding whether to solve or skip each question based on future optimal scores. The optimal approach uses bottom-up dynamic programming with dp[i] representing maximum points from position i onwards. Time: O(n), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Work backwards from the last question to the first. For each position, calculate the maximum points we can earn from that position onwards. The answer is dp[0].

Brute Force Recursion

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

For each question, recursively try both options: solve it (gain points but skip next brainpower questions) or skip it (move to next question). Return maximum of both choices.

Top-Down Dynamic Programming (Memoization)

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

Same recursive approach as brute force but store results of each subproblem in a cache. When we encounter the same starting index again, return the cached result instead of recalculating.

Bottom-Up Dynamic Programming — Algorithm Steps

Create dp array where dp[i] = maximum points from question i onwards
Initialize dp[n] = 0 (base case: no questions left)
Fill dp array backwards: dp[i] = max(points[i] + dp[i + brainpower[i] + 1], dp[i + 1])
Return dp[0]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP array with base case dp[n] = 0

Fill Backwards

For each position, choose max(solve, skip)

Result

dp[0] contains maximum points from start

Code -

solution.c — C

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

long long solution(int questions[][2], int n) {
    long long* dp = calloc(n + 1, sizeof(long long)); // dp[i] = max points from question i onwards
    
    // Work backwards from the end
    for (int i = n - 1; i >= 0; i--) {
        int points = questions[i][0];
        int brainpower = questions[i][1];
        int nextQuestion = (i + brainpower + 1 < n) ? i + brainpower + 1 : n;
        
        // Option 1: Solve current question
        long long solveScore = points + dp[nextQuestion];
        
        // Option 2: Skip current question
        long long skipScore = dp[i + 1];
        
        dp[i] = solveScore > skipScore ? solveScore : skipScore;
    }
    
    long long result = dp[0];
    free(dp);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array manually
    int questions[100000][2];
    int n = 0;
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            questions[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            questions[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    long long result = solution(questions, n);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array from end to beginning

✓ Linear Growth

Space Complexity

O(n)

DP array stores maximum points for each starting position

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler