用总和 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是否已经存在于集合中。如果发现为真，则增加res ，清除set ，并重置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

Javascript

 
// Javascript Program to implement
// the above approach
 
// Function to count the maximum
// number of subarrays with sum K
function CtSubarr(arr, N, K)
{
 
    // Stores all the distinct
    // prefixSums obtained
    var st = new Set();
 
    // Stores the prefix sum
    // of the current subarray
    var prefixSum = 0;
 
    st.add(prefixSum);
 
    // Stores the count of
    // subarrays with sum K
    var res = 0;
 
    for (var i = 0; i < N; i++) {
        prefixSum += arr[i];
 
        // If a subarray with sum K
        // is already found
        if (st.has(prefixSum - K)) {
 
            // Increase count
            res += 1;
 
            // Reset prefix sum
            prefixSum = 0;
 
            // Clear the set
            st = new Set();
            st.add(0);
        }
 
        // Insert the prefix sum
        st.add(prefixSum);
    }
    return res;
}
 
// Driver Code
var arr = [-2, 6, 6, 3, 5, 4, 1, 2, 8];
var N = arr.length;
var K = 10;
document.write( CtSubarr(arr, N, K));
 
// This code is contributed by importantly.

输出：

3

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。