1658. Minimum Operations to Reduce X to Zero - Explanation

class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        n = len(nums)
        res = n + 1
        suffixSum = prefixSum = 0

        for i in range(n - 1, -1, -1):
            suffixSum += nums[i]
            if suffixSum == x:
                res = min(res, n - i)

        for i in range(n):
            prefixSum += nums[i]
            suffixSum = 0
            if prefixSum == x:
                res = min(res, i + 1)

            for j in range(n - 1, i, -1):
                suffixSum += nums[j]
                if prefixSum + suffixSum == x:
                    res = min(res, i + 1 + n - j)

        return -1 if res == n + 1 else res

class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        n = len(nums)
        prefixSum = [0] * (n + 1)
        for i in range(n):
            prefixSum[i + 1] = prefixSum[i] + nums[i]

        if x > prefixSum[n]:
            return -1

        def binarySearch(target, m):
            l, r = 1, m
            index = n + 1

            while l <= r:
                mid = (l + r) >> 1
                if prefixSum[mid] >= target:
                    if prefixSum[mid] == target:
                        index = mid
                    r = mid - 1
                else:
                    l = mid + 1

            return index

        res = binarySearch(x, n)
        suffixSum = 0
        for i in range(n - 1, 0, -1):
            suffixSum += nums[i]
            if suffixSum == x:
                res = min(res, n - i)
                break
            if suffixSum > x: break
            res = min(res, binarySearch(x - suffixSum, i) + n - i)

        return -1 if res == n + 1 else res

class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        total = sum(nums)
        if total == x:
            return len(nums)

        target = total - x
        if target < 0:
            return -1

        res = -1
        prefixSum = 0
        prefixMap = {0: -1}  # prefixSum -> index

        for i, num in enumerate(nums):
            prefixSum += num
            if prefixSum - target in prefixMap:
                res = max(res, i - prefixMap[prefixSum - target])
            prefixMap[prefixSum] = i

        return len(nums) - res if res != -1 else -1

class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        target = sum(nums) - x
        cur_sum = 0
        max_window = -1
        l = 0

        for r in range(len(nums)):
            cur_sum += nums[r]

            while l <= r and cur_sum > target:
                cur_sum -= nums[l]
                l += 1

            if cur_sum == target:
                max_window = max(max_window, r - l + 1)

        return -1 if max_window == -1 else len(nums) - max_window