Naive Solution (Brute Force)

A brute-force solution would involve exploring all possible combinations of solving or skipping questions. This can be done using recursion. For each question, we have two choices: solve it and skip the next brainpower questions, or skip it and move to the next question. We would then return the maximum points earned among all possible combinations.

Code (Python):

def max_points_brute_force(questions):
    def solve(index):
        if index >= len(questions):
            return 0

        # Option 1: Solve the current question
        points, brainpower = questions[index]
        solve_next = solve(index + brainpower + 1)  # Skip brainpower questions
        solve_current = points + solve_next

        # Option 2: Skip the current question
        skip_current = solve(index + 1)

        return max(solve_current, skip_current)

    return solve(0)


# Example usage
questions = [[3, 2], [4, 3], [4, 4], [2, 5]]
print(max_points_brute_force(questions))  # Output: 5

Time Complexity: O(2ⁿ), where n is the number of questions. This is because, in the worst case, we explore every possible combination of solving or skipping each question.

Space Complexity: O(n), due to the recursion depth.

This brute force solution will likely exceed the time limit for larger inputs.

Optimal Solution (Dynamic Programming)

We can optimize the solution using dynamic programming. Let dp[i] be the maximum points we can earn starting from question i. We can build dp from the end of the questions array to the beginning. The state transition will be:

dp[i] = max(points[i] + dp[i + brainpower[i] + 1], dp[i + 1])

where points[i] and brainpower[i] are the points and brainpower associated with the i-th question. If i + brainpower[i] + 1 goes beyond the array bounds, we consider it as 0.

Code (Python):

def max_points_dp(questions):
    n = len(questions)
    dp = [0] * (n + 1)

    for i in range(n - 1, -1, -1):
        points, brainpower = questions[i]
        next_question = i + brainpower + 1
        solve_current = points + (dp[next_question] if next_question <= n else 0)
        skip_current = dp[i + 1]
        dp[i] = max(solve_current, skip_current)

    return dp[0]


# Example usage
questions = [[3, 2], [4, 3], [4, 4], [2, 5]]
print(max_points_dp(questions))  # Output: 5

questions = [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
print(max_points_dp(questions)) # Output: 7

Time Complexity: O(n), where n is the number of questions. We iterate through the questions array once.

Space Complexity: O(n), to store the dp array.

Edge Cases

• Empty Input: If the input questions array is empty, the function should return 0.
• Large Brainpower: If brainpower is large enough that solving a question takes us past the end of the array, we simply don't add anything for further questions, which is handled correctly by the dp implementation.
• Single Question: If there is only one question, the answer is simply the point value of that question.