# Solving Leetcode Interviews in Seconds with AI: Maximum Number of Non-Overlapping Subarrays With Sum Equals Target


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1546" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an array nums and an integer target, return the maximum number of non-empty non-overlapping subarrays such that the sum of values in each subarray is equal to target.   Example 1:  Input: nums = [1,1,1,1,1], target = 2 Output: 2 Explanation: There are 2 non-overlapping subarrays [1,1,1,1,1] with sum equals to target(2).  Example 2:  Input: nums = [-1,3,5,1,4,2,-9], target = 6 Output: 2 Explanation: There are 3 subarrays with sum equal to 6. ([5,1], [4,2], [3,5,1,4,2,-9]) but only the first 2 are non-overlapping.    Constraints:  1 <= nums.length <= 105 -104 <= nums[i] <= 104 0 <= target <= 106  

	# Explanation
	Here's the approach to solve this problem:

*   **Prefix Sum and Hash Map:** Use a hash map to store the prefix sums of the array and their corresponding indices. This allows us to efficiently check if a subarray with the target sum exists.

*   **Greedy Approach:** Iterate through the array and keep track of the current sum. When the current sum minus the target is found in the hash map, it signifies a subarray with the target sum. Increment the count of subarrays and update the starting index for the next non-overlapping subarray.

*   **Optimization:** Reset the current sum to zero and update the starting index to the element after the identified subarray to ensure non-overlapping subarrays.

*   **Complexity:** Time Complexity: O(n), Space Complexity: O(n)

	
	# Code
	```python
	def maxNonOverlapping(nums, target):
    """
    Finds the maximum number of non-overlapping subarrays that sum to target.

    Args:
        nums (list[int]): The input array of integers.
        target (int): The target sum.

    Returns:
        int: The maximum number of non-overlapping subarrays with sum equal to target.
    """

    count = 0
    curr_sum = 0
    seen = {0: -1}  # Initialize with sum 0 at index -1
    last_index = -1 # Index of last included element
    
    for i in range(len(nums)):
        curr_sum += nums[i]
        
        if (curr_sum - target) in seen:
            start_index = seen[curr_sum - target]
            
            if start_index < last_index:
                continue

            count += 1
            last_index = i #Include this element

        seen[curr_sum] = i

    return count
	```