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 subsetInput: 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++ 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 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 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# 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 |
<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 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 ?> |
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:
#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;
} |
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
}
}
} |
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 |
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 |
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(); |
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.