Solving Questions With Brainpower - Leetcode Solution

The "Solving Questions With Brainpower" problem on LeetCode asks you to find the maximum score you can achieve by solving a set of questions with different values and difficulties, while also taking into account the time it takes you to solve each question.

The problem provides you with an array of integers representing the values of the questions, another array of integers representing the difficulties of the questions, and an integer representing the maximum time you have to solve all the questions.

To solve this problem, you need to come up with a way to determine which questions to solve in order to maximize your score, while making sure you don't exceed the maximum time limit.

One approach to solving this problem is to use dynamic programming. You can create a 2D array dp[i][j] to represent the maximum score you can achieve by solving the first i questions in j amount of time.

To populate this array, you can iterate through all the questions and for each question i, check if you can solve it within the given time limit. If you can, you have two options:

1. Solve the question and add its value to your total score. In this case, the maximum score you can achieve is dp[i-1][j-difficulty[i-1]] + value[i-1], since you have solved one more question and spent time on it.
2. Don't solve the question and move on to the next one. In this case, the maximum score you can achieve is dp[i-1][j], since you have not spent any time on this question.

You can then take the maximum of these two options and assign it to dp[i][j]. This process can be summarized in the following formula:

dp[i][j] = max(dp[i-1][j-difficulty[i-1]] + value[i-1], dp[i-1][j])

After you have populated the entire dp array, the maximum score you can achieve is stored in dp[n][time], where n is the number of questions and time is the maximum time limit.

The time complexity of this solution is O(ntime), since you need to iterate through all the questions and for each question, you need to iterate through all the possible time limits. The space complexity is also O(ntime), since you need to store the entire dp array.

Here is the Python code to implement this solution:

def maxScore(values: List[int], difficulties: List[int], time: int) -> int: n = len(values) dp = [[0 for j in range(time+1)] for i in range(n+1)]

for i in range(1, n+1):
    for j in range(time+1):
        if difficulties[i-1] > j:
            dp[i][j] = dp[i-1][j]
        else:
            dp[i][j] = max(dp[i-1][j-difficulties[i-1]] + values[i-1], dp[i-1][j])

return dp[n][time]

1