Maximal Score After Applying K Operations - Leetcode Solution

The Maximal Score After Applying K Operations problem on LeetCode is a dynamic programming problem that requires us to find the maximum score we can get by applying K operations on a given array. Each operation involves selecting two adjacent elements from the array, multiplying the smaller number by 2, and replacing the larger number with the result. The problem statement can be found here: https://leetcode.com/problems/maximal-score-after-k-operations/

To solve this problem, we can use dynamic programming. We can define a 2D array dp, where dp[i][j] represents the maximum score that can be obtained by applying j operations on the subarray nums[0:i]. We can fill the dp array in a bottom-up manner, starting from dp[1][1]. Here's how we can fill the dp array:

1. Initialize dp[i][1] for all i from 2 to n, where n is the length of the array nums. dp[i][1] represents the maximum score that can be obtained by applying 1 operation on the subarray nums[0:i]. To compute dp[i][1], we can iterate over all possible pairs of adjacent elements in the subarray nums[0:i] and perform the operation on each pair. We can then take the maximum score among all the possible pairs.

2. For j > 1, we can compute dp[i][j] by iterating over all possible pairs of adjacent elements in the subarray nums[0:i] and performing the operation on each pair, and then combining the result with dp[k][j-1], where k < i. We can take the maximum score among all the possible pairs and combine it with dp[k][j-1] to get dp[i][j].

The final answer is the maximum score that can be obtained by applying K operations on the entire array, i.e., dp[n][K].

Here's the Python code to implement the above approach:

class Solution:
    def maxScore(self, nums: List[int], k: int) -> int:
        n = len(nums)
        dp = [[0] * (k+1) for _ in range(n+1)]
        
        # Step 1
        for i in range(2, n+1):
            max_score = 0
            for j in range(i-1):
                score = (j+1) * (i-j-1) * 2 + dp[j][1]
                max_score = max(max_score, score)
            dp[i][1] = max_score
        
        # Step 2
        for j in range(2, k+1):
            for i in range(j, n+1):
                max_score = 0
                for l in range(j-1, i):
                    score = dp[l][j-1] + (i-l) * (l-(j-2)) * 2
                    max_score = max(max_score, score)
                dp[i][j] = max_score
        
        return dp[n][k]

1