用总和K最大化非重叠子数组的数量

给定一个数组arr []和一个整数K ，任务是打印总和等于K的不重叠子数组的最大数量。

例子：

Input: arr[] = {-2, 6, 6, 3, 5, 4, 1, 2, 8}, K = 10
Output: 3
Explanation: All possible non-overlapping subarrays with sum K(= 10) are {-2, 6, 6}, {5, 4, 1}, {2, 8}. Therefore, the required count is 3.

Input: arr[] = {1, 1, 1}, K = 2
Output: 1

方法：可以使用前缀和的概念来解决该问题。 请按照以下步骤解决问题：

1. 初始化一个集合以存储直到当前元素为止获得的所有前缀和。
2. 初始化变量prefixSum和res ，以存储当前子数组的前缀和以及分别等于K的子数组的计数。
3. 遍历数组，并针对每个数组元素，通过向其添加当前元素来更新prefixSum 。现在，检查值prefixSum – K是否已存在于集合中。如果确定为true，则增加res ，清除设置，然后重新设置prefixSum的值。
4. 重复上述步骤，直到遍历整个数组。最后，打印res的值。

C++14

// C++ Program to implement
// the above approach
  
#include 
using namespace std;
  
// Function to count the maximum
// number of subarrays with sum K
int CtSubarr(int arr[], int N, int K)
{
  
    // Stores all the distinct
    // prefixSums obtained
    unordered_set st;
  
    // Stores the prefix sum
    // of the current subarray
    int prefixSum = 0;
  
    st.insert(prefixSum);
  
    // Stores the count of
    // subarrays with sum K
    int res = 0;
  
    for (int i = 0; i < N; i++) {
        prefixSum += arr[i];
  
        // If a subarray with sum K
        // is already found
        if (st.count(prefixSum - K)) {
  
            // Increase count
            res += 1;
  
            // Reset prefix sum
            prefixSum = 0;
  
            // Clear the set
            st.clear();
            st.insert(0);
        }
  
        // Insert the prefix sum
        st.insert(prefixSum);
    }
    return res;
}
  
// Driver Code
int main()
{
    int arr[] = { -2, 6, 6, 3, 5, 4, 1, 2, 8 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 10;
    cout << CtSubarr(arr, N, K);
}

Java

// Java Program to implement
// the above approach
import java.util.*;
class GFG{
    // Function to count the maximum
    // number of subarrays with sum K
    static int CtSubarr(int[] arr, 
                        int N, int K)
    {
        // Stores all the distinct
        // prefixSums obtained
        Set st = new HashSet();
  
        // Stores the prefix sum
        // of the current subarray
        int prefixSum = 0;
  
        st.add(prefixSum);
  
        // Stores the count of
        // subarrays with sum K
        int res = 0;
  
        for (int i = 0; i < N; i++) 
        {
            prefixSum += arr[i];
  
            // If a subarray with sum K
            // is already found
            if (st.contains(prefixSum - K)) 
            {
                // Increase count
                res += 1;
  
                // Reset prefix sum
                prefixSum = 0;
  
                // Clear the set
                st.clear();
                st.add(0);
            }
  
            // Insert the prefix sum
            st.add(prefixSum);
        }
        return res;
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = {-2, 6, 6, 3, 
                     5, 4, 1, 2, 8};
        int N = arr.length;
        int K = 10;
        System.out.println(CtSubarr(arr, N, K));
    }
}
  
// This code is contributed by Chitranayal

Python3

# Python3 program to implement
# the above approach
  
# Function to count the maximum 
# number of subarrays with sum K
def CtSubarr(arr, N, K):
  
    # Stores all the distinct
    # prefixSums obtained
    st = set()
  
    # Stores the prefix sum
    # of the current subarray
    prefixSum = 0
  
    st.add(prefixSum)
  
    # Stores the count of
    # subarrays with sum K
    res = 0
  
    for i in range(N):
        prefixSum += arr[i]
  
        # If a subarray with sum K
        # is already found
        if((prefixSum - K) in st):
  
            # Increase count
            res += 1
  
            # Reset prefix sum
            prefixSum = 0
  
            # Clear the set
            st.clear()
            st.add(0)
  
        # Insert the prefix sum
        st.add(prefixSum)
  
    return res
  
# Driver Code
arr = [ -2, 6, 6, 3, 5, 4, 1, 2, 8 ]
N = len(arr)
K = 10
  
# Function call
print(CtSubarr(arr, N, K))
  
# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
  
class GFG{
      
// Function to count the maximum
// number of subarrays with sum K
static int CtSubarr(int[] arr, 
                    int N, int K)
{
      
    // Stores all the distinct
    // prefixSums obtained
    HashSet st = new HashSet();
  
    // Stores the prefix sum
    // of the current subarray
    int prefixSum = 0;
  
    st.Add(prefixSum);
  
    // Stores the count of
    // subarrays with sum K
    int res = 0;
  
    for(int i = 0; i < N; i++) 
    {
        prefixSum += arr[i];
  
        // If a subarray with sum K
        // is already found
        if (st.Contains(prefixSum - K)) 
        {
              
            // Increase count
            res += 1;
  
            // Reset prefix sum
            prefixSum = 0;
  
            // Clear the set
            st.Clear();
            st.Add(0);
        }
  
        // Insert the prefix sum
        st.Add(prefixSum);
    }
    return res;
}
  
// Driver Code
public static void Main(String[] args)
{
    int []arr = { -2, 6, 6, 3, 
                   5, 4, 1, 2, 8};
    int N = arr.Length;
    int K = 10;
      
    Console.WriteLine(CtSubarr(arr, N, K));
}
}
  
// This code is contributed by 29AjayKumar

输出：

3

时间复杂度： O(N)
辅助空间： O(N)