Given an array arr[] of N integers and an integer K, the task is to find whether the given array elements can be made 0 if the given operation is applied exactly K times. In a single operation, the smallest element from the array will be subtracted from all the non-zero elements of the array.
Examples:
Input: arr[] = {1, 1, 2, 3}, K = 3
Output: Yes
K = 1 -> arr[] = {0, 0, 1, 2}
K = 2 -> arr[] = {0, 0, 0, 1}
K = 3 -> arr[] = {0, 0, 0, 0}
Input: arr[] = {11, 2, 3, 4}, K = 3
Output: No
The array requires 4 operations.
Approach:
- Major observation here is that the minimum number does not matter at each operation, suppose X is the minimum number then all the occurrences of X will be 0 in the current operation and other elements will reduce by X.
- We can conclude that all the identical elements will be 0 at the same operation.
- So, say in Q operations the entire array becomes 0, it is equal to the number of unique elements in the array.
- If Q = K then the answer is Yes else print No.
- Number of unique elements can be obtained using set.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function that returns true if the array // can be reduced to 0s with the given // operation performed given number of times bool check( int arr[], int N, int K)
{ // Set to store unique elements
set< int > unique;
// Add every element of the array
// to the set
for ( int i = 0; i < N; i++)
unique.insert(arr[i]);
// Count of all the unique elements
// in the array
if (unique.size() == K)
return true ;
return false ;
} // Driver code int main()
{ int arr[] = { 1, 1, 2, 3 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 3;
if (check(arr, N, K))
cout << "Yes" ;
else
cout << "No" ;
return 0;
} |
// Java implementation of the approach import java.util.*;
class GFG
{ // Function that returns true if the array // can be reduced to 0s with the given // operation performed given number of times static boolean check( int arr[], int N, int K)
{ // Set to store unique elements
HashSet<Integer> unique = new HashSet<Integer>();
// Add every element of the array
// to the set
for ( int i = 0 ; i < N; i++)
unique.add(arr[i]);
// Count of all the unique elements
// in the array
if (unique.size() == K)
return true ;
return false ;
} // Driver code public static void main(String[] args)
{ int arr[] = { 1 , 1 , 2 , 3 };
int N = arr.length;
int K = 3 ;
if (check(arr, N, K))
System.out.println( "Yes" );
else
System.out.println( "No" );
} } // This code has been contributed by 29AjayKumar |
# Python3 implementation of the approach # Function that returns true if the array # can be reduced to 0s with the given # operation performed given number of times def check(arr, N, K):
# Set to store unique elements
unique = dict ()
# Add every element of the array
# to the set
for i in range (N):
unique[arr[i]] = 1
# Count of all the unique elements
# in the array
if len (unique) = = K:
return True
return False
# Driver code arr = [ 1 , 1 , 2 , 3 ]
N = len (arr)
K = 3
if (check(arr, N, K) = = True ):
print ( "Yes" )
else :
print ( "No" )
# This code is contributed by mohit kumar |
// C# implementation of the approach using System;
using System.Collections.Generic;
class GFG
{ // Function that returns true if the array // can be reduced to 0s with the given // operation performed given number of times public static bool check( int [] arr, int N, int K)
{ // Set to store unique elements
HashSet< int > unique = new HashSet< int >();
// Add every element of the array
// to the set
for ( int i = 0; i < N; i++)
{
unique.Add(arr[i]);
}
// Count of all the unique elements
// in the array
if (unique.Count == K)
{
return true ;
}
return false ;
} // Driver code public static void Main( string [] args)
{ int [] arr = new int [] {1, 1, 2, 3};
int N = arr.Length;
int K = 3;
if (check(arr, N, K))
{
Console.WriteLine( "Yes" );
}
else
{
Console.WriteLine( "No" );
}
} } // This code is contributed by shrikanth13 |
<?php // PHP implementation of the approach // Function that returns true if the array // can be reduced to 0s with the given // operation performed given number of times function check( & $arr , $N , $K )
{ // Add in Set only unique elements
$unique = array_unique ( $arr );
// Count of all the unique elements
// in the array
if ( count ( $unique ) == $K )
return true;
return false;
} // Driver code $arr = array ( 1, 1, 2, 3 );
$N = count ( $arr );
$K = 3;
if (check( $arr , $N , $K ))
echo "Yes" ;
else echo "No" ;
// This code has been contributed // by Rajput-Ji ?> |
<script> // Javascript implementation of the approach // Function that returns true if the array // can be reduced to 0s with the given // operation performed given number of times function check(arr, N, K)
{ // Set to store unique elements
var unique = new Set();
// Add every element of the array
// to the set
for ( var i = 0; i < N; i++)
unique.add(arr[i]);
// Count of all the unique elements
// in the array
if (unique.size == K)
return true ;
return false ;
} // Driver code var arr = [1, 1, 2, 3];
var N = arr.length;
var K = 3;
if (check(arr, N, K))
document.write( "Yes" );
else document.write( "No" );
</script> |
Yes
Time Complexity: O(nlogn), where n is the size of the given array.
Auxiliary Space: O(n), where extra space of size n is used to create a set.