Partition Array Such That Maximum Difference Is K - Leetcode Solution

Problem Statement:

Given an array nums containing n elements, you have to partition it into two non-empty subarrays such that the absolute difference between the sums of the two subarrays is exactly k.

Return a non-empty array containing any two integers that represent the indices of the first element and last element respectively of the left subarray. If there are multiple answers, print any of them.

It is guaranteed that at least one such partition exists.

Example:

Input: nums = [1, 2, 3, 4, 5], k = 2 Output: [2, 3] Explanation: Partition the array into [1, 2, 3] and [4, 5], so that |6 - 4| = 2.

Solution:

Approach:

• Traverse the given array to calculate the prefix sum.
• Traverse the prefix sums array to store each prefix sum and its index in a map.
• As the difference between two subarrays k, let's consider sum1 and sum2 such that sum1 - sum2 = k.
• Traverse the prefix sums array to check if the value sum1 - k or sum1 + k exists in the map. If it exists, we have found a valid partition.

Let's see an implementation in Python:

class Solution: def maxDiff(self, nums: List[int], k: int) -> List[int]: prefix_sum = [0] * len(nums) prefix_sum[0] = nums[0] for i in range(1, len(nums)): prefix_sum[i] = prefix_sum[i - 1] + nums[i] prefix_sum_map = {} for i in range(len(prefix_sum)): prefix_sum_map[prefix_sum[i]] = i for i in range(len(prefix_sum)): if prefix_sum[i] - k in prefix_sum_map and prefix_sum_map[prefix_sum[i] - k] < i: return [prefix_sum_map[prefix_sum[i] - k] + 1, i] if prefix_sum[i] + k in prefix_sum_map and prefix_sum_map[prefix_sum[i] + k] < i: return [prefix_sum_map[prefix_sum[i] + k] + 1, i] return [-1, -1]

Time Complexity: O(nlogn), where n is the length of the input array.

The time complexity of calculating prefix sum is O(n), and the time complexity of checking if the value sum1 - k or sum1 + k exists in the map is O(logn). We will traverse the prefix sums array twice. Therefore, the time complexity of the algorithm is O(nlogn).

Space Complexity: O(n), where n is the length of the input array.

We will create a prefix sums array of size n and a map of size n. Therefore, the space complexity of the algorithm is O(n).

1