def findMaxLength(nums):
    # Replace 0 with -1 for transformation
    for i in range(len(nums)):
        if nums[i] == 0:
            nums[i] = -1

    cumulative_sum = 0
    max_length = 0
    sum_index_map = {}  # To store the first occurrence of each cumulative sum

    for i, num in enumerate(nums):
        cumulative_sum += num

        # Check if cumulative_sum is 0, which means subarray from index 0 to i is valid
        if cumulative_sum == 0:
            max_length = i + 1

        # If cumulative_sum has been seen before, update max_length accordingly
        if cumulative_sum in sum_index_map:
            max_length = max(max_length, i - sum_index_map[cumulative_sum])
        else:
            sum_index_map[cumulative_sum] = i

    return max_length

# Testing the function with provided examples
print(findMaxLength([0, 1]))    # Output: 2
print(findMaxLength([0, 1, 0])) # Output: 2

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        s = {0:-1}
        t = 0
        maxm = 0
        c1 = 0
        c0 = 0
        for i in range(len(nums)):
            if nums[i]:
                c1+=1
            else:
                c0+=1
            if c1-c0 not in s:
                s[c1-c0] = i
            else:
                maxm = max(maxm,i-s[c1-c0])
        return maxm

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = ListNode(0,head)
        p1 = dummy
        p2 = dummy.next
        while p2:
            if p2.val==val:
                p1.next = p2.next
                p2  = p2.next
            else:
                p1 = p1.next
                p2 = p2.next
        return dummy.next

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy = ListNode(-1,head)
        p1 = dummy
        p2 = dummy.next
        count = 0
        while p2:
            if count <n:
                p2 = p2.next
                count+=1
            else:
                p1 = p1.next
                p2 = p2.next
        if p1:
            p1.next = p1.next.next
        return dummy.next

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p1 = head
        p2 = head
        while p2 and p2.next:
            p1=p1.next
            p2 = p2.next.next
        return p1

nums = [3, 1, 6, 8]
queries = [1, 5]

Output:

[14, 10]

Explanation:

• For the first query (q = 1):

    • Decrease nums[0] 2 times: from 3 to 1.

    • Decrease nums[2] 5 times: from 6 to 1.

    • Decrease nums[3] 7 times: from 8 to 1.

    • Total operations = 2 + 5 + 7 = 14.

• For the second query (q = 5):

    • Increase nums[0] 2 times: from 3 to 5.

    • Increase nums[1] 4 times: from 1 to 5.

    • Decrease nums[2] 1 time: from 6 to 5.

    • Decrease nums[3] 3 times: from 8 to 5.

    • Total operations = 2 + 4 + 1 + 3 = 10.

---

Example 2:

Input:

nums = [2, 9, 6, 3]
queries = [10]

Output:

[20]

Explanation:

• Increase each element in the array to 10:

    • Operations for each element: 

        • 8 (from 2 to 10),

        • 1 (from 9 to 10),

        • 4 (from 6 to 10),

        • 7 (from 3 to 10).

    • Total operations = 8 + 1 + 4 + 7 = 20.

▎Constraints

• n = nums.length

• m = queries.length

• 1 ≤ n, m ≤ 10⁵

• 1 ≤ nums[i], queries[i] ≤ 10⁹

---