Check if the given array can be reduced to zeros with the given operation performed given number of times

Last Updated : 28 May, 2022

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++

 `// C++ implementation of the approach` `#include ` `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

 `// 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 unique = ``new` `HashSet();`     `    ``// 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

 `# 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#

 `// 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

 ``

Javascript

 ``

Output:

`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.