Find if there is any subset of size K with 0 sum in an array of -1 and +1

Given an integer K and an array arr containing only 1 and -1, the task is to find if there is any subset of size K sum of whose elements is 0.

Examples:

Input: arr[] = {1, -1, 1}, K = 2 
Output: Yes 
{1, -1} is a valid subset

Input: arr[] = {1, 1, -1, -1, 1}, K = 5 
Output: No 

Approach:

• In order for the sum to be 0, there has to be equal number of 1 and -1 in the subset.
• If K is odd then no subset will satisfy the given condition.
• Else if K is even then we need to choose exactly (K / 2) 1’s and (K / 2) -1’s in order to form the subset so that the sum of all of it’s elements is 0
• So, if K is even and number of 1’s ≥ K / 2 and number of -1’s ≥ K / 2 then print Yes else print No.

Below is the implementation of the above approach: 

C++

// C++ program to find if there is a subset of size
// k with sum 0 in an array of -1 and +1
#include <bits/stdc++.h>
using namespace std;

// Function to return the number of 1's in the array
int countOnes(int n, int a[])
{
    int i, count = 0;
    for (i = 0; i < n; i++)
        if (a[i] == 1)
            count++;
    return count;
}

bool isSubset(int arr[], int n, int k)
{
    int countPos1 = countOnes(n, arr);
    int countNeg1 = n - countPos1;

    // If K is even and there are
    // at least K/2 1's and -1's
    return (k % 2 == 0 && countPos1 >= k / 2 &&
                          countNeg1 >= k / 2);
}

// Driver Program to test above function
int main()
{
    int a[] = { 1, 1, -1, -1, 1 };
    int n = sizeof(a) / sizeof(a[0]);
    int k = 5;
    if (isSubset(a, n, k))
      cout << "Yes";
    else
      cout << "No";
    return 0;
}

Java

// Java program to find if there is a subset of size
// k with sum 0 in an array of -1 and +1

import java.io.*;

class GFG {


// Function to return the number of 1's in the array
static int countOnes(int n, int a[])
{
    int i, count = 0;
    for (i = 0; i < n; i++)
        if (a[i] == 1)
            count++;
    return count;
}

static boolean isSubset(int arr[], int n, int k)
{
    int countPos1 = countOnes(n, arr);
    int countNeg1 = n - countPos1;

    // If K is even and there are
    // at least K/2 1's and -1's
    return (k % 2 == 0 && countPos1 >= k / 2 &&
                        countNeg1 >= k / 2);
}

// Driver Program to test above function
public static void main (String[] args) {
        int []a = { 1, 1, -1, -1, 1 };
    int n = a.length;
    int k = 5;
    if (isSubset(a, n, k))
     System.out.println( "Yes");
    else
    System.out.println( "No");
    }
}
// This code is contributed by shs

Python3

# Python3 program to find if there is
# a subset of size k with sum 0 in an
# array of -1 and +1

# Function to return the number of
# 1's in the array
def countOnes(n, a):

    count = 0
    for i in range(0, n):
        if a[i] == 1:
            count += 1
    return count

def isSubset(arr, n, k):

    countPos1 = countOnes(n, arr)
    countNeg1 = n - countPos1

    # If K is even and there are
    # at least K/2 1's and -1's
    return (k % 2 == 0 and countPos1 >= k // 2 and
                           countNeg1 >= k // 2)

# Driver Code
if __name__ == "__main__":

    a = [1, 1, -1, -1, 1]
    n = len(a)
    k = 5

    if isSubset(a, n, k) == True:
        print("Yes")
    else:
        print("No")

# This code is contributed
# by Rituraj Jain

C#

// C# program to find if there is
// a subset of size k with sum 0
// in an array of -1 and +1
using System;

class GFG
{

// Function to return the number
// of 1's in the array
static int countOnes(int n, int []a)
{
    int i, count = 0;
    for (i = 0; i < n; i++)
        if (a[i] == 1)
            count++;
    return count;
}

static bool isSubset(int []arr,
                     int n, int k)
{
    int countPos1 = countOnes(n, arr);
    int countNeg1 = n - countPos1;

    // If K is even and there are
    // at least K/2 1's and -1's
    return (k % 2 == 0 && countPos1 >= k / 2 &&
                          countNeg1 >= k / 2);
}

// Driver Code
public static void Main ()
{
    int []a = { 1, 1, -1, -1, 1 };
    int n = a.Length;
    int k = 5;
    if (isSubset(a, n, k))
        Console.WriteLine( "Yes");
    else
        Console.WriteLine( "No");
}
}

// This code is contributed by shs

Javascript

<script>

// Javascript program to find if there is a subset of size
// k with sum 0 in an array of -1 and +1

// Function to return the number of 1's in the array
function countOnes(n, a)
{
    var i, count = 0;
    for (i = 0; i < n; i++)
        if (a[i] == 1)
            count++;
    return count;
}

function isSubset(arr, n, k)
{
    var countPos1 = countOnes(n, arr);
    var countNeg1 = n - countPos1;

    // If K is even and there are
    // at least K/2 1's and -1's
    return (k % 2 == 0 && countPos1 >= k / 2 &&
                          countNeg1 >= k / 2);
}

// Driver Program to test above function
var a = [1, 1, -1, -1, 1];
var n = a.length;
var k = 5;
if (isSubset(a, n, k))
  document.write( "Yes");
else
  document.write( "No");

// This code is contributed by famously.
</script>

PHP

<?php
// PHP program to find if there
// is a subset of size k with
// sum 0 in an array of -1 and +1

// Function to return the number
// of 1's in the array
function countOnes($n, $a)
{
    $count = 0;
    for ($i = 0; $i < $n; $i++)
        if ($a[$i] == 1)
            $count++;
    return $count;
}

function isSubset($arr, $n, $k)
{
    $countPos1 = countOnes($n, $arr);
    $countNeg1 = $n - $countPos1;

    // If K is even and there are
    // at least K/2 1's and -1's
    return ($k % 2 == 0 && $countPos1 >= $k / 2 &&
                           $countNeg1 >= $k / 2);
}

// Driver Code
$a = array(1, 1, -1, -1, 1);
$n = sizeof($a);
$k = 5;

if (isSubset($a, $n, $k))
    echo "Yes";
else
    echo "No";

// This code is contributed
// by Akanksha Rai
?>

Output

No

Time Complexity: O(n)

Approach:

• Approach to solve this problem could be to use a sliding window technique and keep track of the sum of the elements in the window. 
• We can start by initializing two pointers, left and right, and a variable sum to 0. 
• Then we can move the right pointer to the right until the window size is K. 
• If the sum of the elements in the window is 0, we can return true as we have found a subset of size K with sum 0. 
• Otherwise, we can move the left pointer to the right and subtract the element at the left pointer from the sum, and continue this process until we have found a subset of size K with sum 0 or until the window size is less than K.

Below is the implementation of the above approach:

C++

#include <bits/stdc++.h>
using namespace std;

bool isSubset(int arr[], int n, int k) {
    int left = 0, right = 0, sum = 0;
    while (right < n) {
        sum += arr[right];
        if (right - left + 1 == k) {
            if (sum == 0) {
                return true;
            }
            sum -= arr[left];
            left++;
        }
        right++;
    }
    return false;
}

int main() {
    int a[] = {1, 1, -1, -1, 1};
    int n = sizeof(a) / sizeof(a[0]);
    int k = 5;
    if (isSubset(a, n, k)) {
        cout << "Yes";
    } else {
        cout << "No";
    }
    return 0;
}

Java

public class Main {
    public static boolean isSubset(int[] arr, int n, int k) {
        int left = 0, right = 0, sum = 0;
        while (right < n) {
          // Add the current element to the sum
            sum += arr[right];
            if (right - left + 1 == k) {  // If the window size is equal to k
                if (sum == 0) {  // If the sum of the window elements is 0
                    return true;  // The subset with sum 0 is found
                }
                sum -= arr[left];  // Subtract the leftmost element from the sum
                left++;  // Slide the window to the right by incrementing left
            }
            right++;  // Slide the window to the right by incrementing right
        }
        return false;  // No subset with sum 0 found
    }

    public static void main(String[] args) {
        int[] a = {1, 1, -1, -1, 1};
        int n = a.length;
        int k = 5;
        if (isSubset(a, n, k)) {
            System.out.println("Yes");  // Subset with sum 0 is found
        } else {
            System.out.println("No");  // Subset with sum 0 is not found
        }
    }
}

Python3

def isSubset(arr, n, k):
    left, right, total_sum = 0, 0, 0
    while right < n:
        # Add the current element to the sum
        total_sum += arr[right]
        if right - left + 1 == k:  # If the window size is equal to k
            if total_sum == 0:  # If the sum of the window elements is 0
                return True  # The subset with sum 0 is found
            # Subtract the leftmost element from the sum
            total_sum -= arr[left]
            left += 1  # Slide the window to the right by incrementing left
        right += 1  # Slide the window to the right by incrementing right
    return False  # No subset with sum 0 found


def main():
    a = [1, 1, -1, -1, 1]
    n = len(a)
    k = 5
    if isSubset(a, n, k):
        print("Yes")  # Subset with sum 0 is found
    else:
        print("No")  # Subset with sum 0 is not found


if __name__ == "__main__":
    main()
# This code is contributed by akshitaguprzj3

C#

using System;

public class GFG {
    public static bool IsSubset(int[] arr, int n, int k)
    {
        int left = 0, right = 0, sum = 0;
        while (right < n) {
            // Add the current element to the sum
            sum += arr[right];
            if (right - left + 1
                == k) // If the window size is equal to k
            {
                if (sum == 0) // If the sum of the window
                              // elements is 0
                {
                    return true; // The subset with sum 0 is
                                 // found
                }
                sum -= arr[left]; // Subtract the leftmost
                                  // element from the sum
                left++; // Slide the window to the right by
                        // incrementing left
            }
            right++; // Slide the window to the right by
                     // incrementing right
        }
        return false; // No subset with sum 0 found
    }

    public static void Main(string[] args)
    {
        int[] a = { 1, 1, -1, -1, 1 };
        int n = a.Length;
        int k = 5;
        if (IsSubset(a, n, k)) {
            Console.WriteLine(
                "Yes"); // Subset with sum 0 is found
        }
        else {
            Console.WriteLine(
                "No"); // Subset with sum 0 is not found
        }
    }
}

// This code is contributed by akshitaguprzj3

Javascript

function isSubset(arr, n, k) {
    let left = 0;
    let right = 0;
    let sum = 0;

    while (right < n) {
        // Add the current element to the sum
        sum += arr[right];

        if (right - left + 1 === k) {
            // If the window size is equal to k
            if (sum === 0) {
                // If the sum of the window elements is 0
                return true; // The subset with sum 0 is found
            }
            sum -= arr[left];
            // Subtract the leftmost element from the sum
            left++;
            // Slide the window to the right by incrementing left
        }
        right++;
        // Slide the window to the right by incrementing right
    }

    return false; // No subset with sum 0 found
}

// Main function
function main() {
    const a = [1, 1, -1, -1, 1];
    const n = a.length;
    const k = 5;

    if (isSubset(a, n, k)) {
        console.log("Yes"); // Subset with sum 0 is found
    } else {
        console.log("No"); // Subset with sum 0 is not found
    }
}

main();

Output

No

Time Complexity: O(N), where N is the size of the input array, as we iterate over the array at most twice. 
Space Complexity: O(1), as we only use a constant amount of extra space to store the pointers and the sum variable.