Minimum Difference In Sums After Removal Of Elements - Leetcode Solution

Problem statement:

Given an array of integers nums, split it into two non-empty subarrays left and right, such that:

• The absolute difference between the sums of left and right subarrays is as small as possible.
• Return the minimum possible difference between the sums of the two subarrays after splitting the array.

Example 1:

Input: nums = [1,2,3,4,5] Output: 1 Explanation: We can split the array into [1,2,4] and [3,5], and the absolute difference between their sums is minimal.

Example 2:

Input: nums = [6,2,3,4,5,1] Output: 1 Explanation: We can split the array into [6,2,4] and [3,5,1], and the absolute difference between their sums is minimal.

Example 3:

Input: nums = [1,2,3,4,6] Output: 1 Explanation: We can split the array into [1,2,4] and [3,6], and the absolute difference between their sums is minimal.

Solution:

To solve the minimum difference in sums after removal of elements problem, we can use dynamic programming. We can create a 2D array dp, where dp[i][j] represents the minimum possible difference between the sums of two subarrays in the range [0, i] using j elements from the left subarray.

Initially, we can fill the first row and column of the dp array. dp[i][0] represents the sum of all elements in the range [0, i], and dp[0][j] represents the jth element in the array.

Next, we can iterate through the remaining cells of the dp array. For each cell dp[i][j], we can either include the (i+1)th element in the left subarray or exclude it. If we include it, we can update the dp value as follows:

dp[i][j] = min(dp[i][j], abs(dp[i-1][j-1] - nums[i]))

If we exclude the (i+1)th element, we can update the dp value as follows:

dp[i][j] = min(dp[i][j], dp[i-1][j])

After filling the dp array, we can return dp[n-1][m], where n is the length of the nums array and m is n/2.

Time Complexity:

The time complexity of the above solution is O(n^2), where n is the length of the nums array.

Space Complexity:

The space complexity of the above solution is also O(n^2), where n is the length of the nums array.

Code:

class Solution:
    def minimumDifference(self, nums: List[int]) -> int:
        n = len(nums)
        m = n//2
        dp = [[float('inf')]*(m+1) for _ in range(n)]
        tot = nums[0]
        dp[0][0] = 0
        for i in range(1, n):
            tot += nums[i]
            dp[i][0] = tot
        
        for i in range(1, n):
            for j in range(1, m+1):
                if j > i:
                    break
                dp[i][j] = min(dp[i][j], abs(dp[i-1][j-1] - nums[i]))
                dp[i][j] = min(dp[i][j], dp[i-1][j])
        
        return dp[n-1][m]

1