Get The Maximum Score - Leetcode Solution

Problem Description:

You are given a list of integers nums. You start at score = 0 and can perform the following operations:

1. Pick any nums[i] and add it to your score.
2. Pick any nums[i] and subtract it from your score.
3. Pick any two adjacent elements nums[i] and nums[i+1] and replace them with their sum.

Return the maximum score you can get after performing all the above operations optimally.

Solution:

To solve the problem, we can follow the dynamic programming approach. We create a 2D dp table dp[len(nums)][len(nums)], where dp[i][j] represents the maximum possible score we can obtain by converting the sub-array from index i to index j optimally.

Initial State:

We start by filling the diagonal elements as dp[i][i] = nums[i], as choosing a single number without any operation gives us the maximum score in that case.

Transitions:

To find the maximum score for any subarray nums[i:j], we can perform the following operations:

1. Add operation: We can add nums[i] to the score and recurse on the subarray nums[i+1:j]. The maximum score we can obtain from this operation is nums[i] + dp[i+1][j].

2. Subtract operation: We can subtract nums[i] from the score and recurse on the subarray nums[i+1:j]. The maximum score we can obtain from this operation is -nums[i] + dp[i+1][j].

3. Combine operation: We can combine the adjacent numbers nums[i] and nums[i+1] and recurse on the subarray nums[i+2:j]. The maximum score we can obtain from this operation is nums[i]+nums[i+1]+dp[i+2][j].

We choose the maximum among these options to obtain the maximum score for the subarray nums[i:j]. We fill the dp table in the order of subarray length, i.e., we first fill all the dp[i][i+1] pairs, then dp[i][i+2], and so on until we fill dp[0][n-1].

Final State:

The final answer lies in the cell dp[0][n-1].

Here is a Python implementation of the solution:

def maxScore(nums):
    n = len(nums)
    dp = [[0] * n for _ in range(n)]

    # Initial State
    for i in range(n):
        dp[i][i] = nums[i]

    # Transitions
    for length in range(2, n + 1):
        for i in range(n - length + 1):
            j = i + length - 1
            
            # Add Operation
            option1 = nums[i] + dp[i + 1][j]
            
            # Subtract Operation
            option2 = -nums[i] + dp[i + 1][j]
            
            # Combine Operation
            option3 = nums[i] + nums[i + 1] + dp[i + 2][j]
            
            dp[i][j] = max(option1, option2, option3)

    # Final State
    return dp[0][n - 1]

Time Complexity:

The time complexity of the above solution is O(n^3), as we are iterating through all subarrays of the original array and performing constant time operations for each subarray. This solution can handle arrays of size up to 100, which is sufficient for the given constraints.

1