 Open in App
Not now

# Check if the Array elements can be made 0 with given conditions

• Last Updated : 27 Jan, 2023

Given two arrays arr[] and arr2[], and a value K, the task is to check whether the array arr[] can be made to all zeros such that in each operation all elements less than K are made to 0 else they are subtracted by K then the K gets decayed by the smallest value of the array arr2[] whose arr[i] is not zero.

Examples:

Input: arr[] = {18, 5, 13, 9, 10, 1}, arr2[] = {2, 7, 2, 1, 2, 6}, K = 7
Output: YES
Explanation: In the 1st operation : arr[] = {11, 0, 6, 2, 3, 0}, K = 7 – min(2, 7, 2, 1, 2, 6) = 6
In the 2nd operation: arr[] = {5, 0, 0, 0, 0, 0}, K = 6 – 2 = 4
In the 3rd operation: arr[]  = {1, 0, 0, 0, 0, 0} K = 4 – 2 = 2
In the 4th operation: arr[] = {0, 0, 0, 0, 0} all are made to 0 so answer is YES.

Input: arr[] = {5, 5, 5}, arr2[] = {4, 4, 4}, K = 4
Output: NO
Explanation: In the 1st operation: arr[] = {1, 1, 1, 1}, K = 0 K has already become 0 so no way to make the array elements to 0 so NO.

Approach: To solve the problem follow the below idea:

This problem can be solved greedily by maintaining a vector of pairs with {arr2[i], arr[i]} and sorting it based on the arr2[i]. After sorting we vary the values of arr[i] and K on each operation until K is not equal to 0.

Follow these steps to solve the above problem:

• Initialize a vector of pairs v to store the arr2[i] and arr[i].
• Sort the vector v based on the first element of the pair i.e arr2[i].
• Initialize the value to be reduced from arr[i] as sum = K
• Iterate while K > 0 and i < n and decay the value of K by v[i].first and apply operation while arr[i] which is v[i].second is > 0 also incrementing the sum by K
• Initialize ctr = 0 to check whether all the array elements of arr[] are made to 0
• If all are made to 0 print YES else print NO.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `// Function to check whether all the array` `// elements can be made to 0.` `void` `is_possible(``int` `arr[], ``int` `brr[], ``int` `n, ``int` `m, ``int` `k)` `{` `    ``// Initialize a vector of pairs v to` `    ``// store the brr[i] and arr[i]` `    ``vector > v;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``v.push_back({ brr[i], arr[i] });` `    ``}`   `    ``// Sort the vector v based on the first` `    ``// element of the pair i.e brr[i]` `    ``sort(v.begin(), v.end());`   `    ``int` `i = 0;`   `    ``// Initialize the value to be reduced` `    ``// from arr[i] as sum = k` `    ``int` `sum = k;`   `    ``// Iterate while k > 0 and i < n` `    ``// and decay the value of k by v[i].` `    ``// first and apply operation while` `    ``// arr[i] which is v[i].second is > 0` `    ``// also incrementing the sum by k` `    ``while` `(k > 0 && i < n) {` `        ``while` `((v[i].second - sum) > 0) {`   `            ``// Decay the value k` `            ``k = k - v[i].first;` `            ``if` `(k >= 0)` `                ``sum += k;` `            ``else` `                ``break``;` `        ``}` `        ``i++;` `    ``}`   `    ``// Initialize ctr =0 to check whether` `    ``// all the array elements of arr[]` `    ``// are made to 0` `    ``int` `ctr = 0;` `    ``for` `(``auto` `itr : v) {` `        ``if` `((itr.second - sum) <= 0) {` `            ``ctr++;` `        ``}` `    ``}`   `    ``// If all are made to 0 print YES` `    ``// else print NO` `    ``if` `(ctr == n) {` `        ``cout << ``"YES"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"NO"` `<< endl;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 18, 5, 13, 9, 10, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `arr2[] = { 2, 7, 2, 1, 2, 6 };` `    ``int` `m = ``sizeof``(arr2) / ``sizeof``(arr2);` `    ``int` `K = 7;` `    ``is_possible(arr, arr2, n, m, K);`   `    ``int` `brr[] = { 5, 5, 5 };` `    ``int` `n2 = ``sizeof``(brr) / ``sizeof``(brr);` `    ``int` `brr2[] = { 4, 4, 4 };` `    ``int` `m2 = ``sizeof``(brr2) / ``sizeof``(brr2);` `    ``int` `K2 = 4;` `    ``is_possible(brr, brr2, n2, m2, K2);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `class` `Main {` `    ``static` `void` `is_possible(``int``[] arr, ``int``[] brr, ``int` `n, ``int` `m, ``int` `k) {` `        ``// Initialize a vector of pairs v to` `        ``// store the brr[i] and arr[i]` `        ``List> v = ``new` `ArrayList<>();`   `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``v.add(``new` `AbstractMap.SimpleEntry<>(brr[i], arr[i]));` `        ``}`   `        ``// Sort the vector v based on the first` `        ``// element of the pair i.e brr[i]` `        ``Collections.sort(v, (o1, o2) -> o1.getKey().compareTo(o2.getKey()));`   `        ``int` `i = ``0``;`   `        ``// Initialize the value to be reduced` `        ``// from arr[i] as sum = k` `        ``int` `sum = k;`   `        ``// Iterate while k > 0 and i < n` `        ``// and decay the value of k by v[i].` `        ``// first and apply operation while` `        ``// arr[i] which is v[i].second is > 0` `        ``// also incrementing the sum by k` `        ``while` `(k > ``0` `&& i < n) {` `            ``while` `((v.get(i).getValue() - sum) > ``0``) {`   `                ``// Decay the value k` `                ``k = k - v.get(i).getKey();` `                ``if` `(k >= ``0``)` `                    ``sum += k;` `                ``else` `                    ``break``;` `            ``}` `            ``i++;` `        ``}`   `        ``// Initialize ctr =0 to check whether` `        ``// all the array elements of arr[]` `        ``// are made to 0` `        ``int` `ctr = ``0``;` `        ``for` `(Map.Entry itr : v) {` `            ``if` `((itr.getValue() - sum) <= ``0``) {` `                ``ctr++;` `            ``}` `        ``}`   `        ``// If all are made to 0 print YES` `        ``// else print NO` `        ``if` `(ctr == n) {` `            ``System.out.println(``"YES"``);` `        ``} ``else` `{` `            ``System.out.println(``"NO"``);` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = { ``18``, ``5``, ``13``, ``9``, ``10``, ``1` `};` `        ``int` `n = arr.length;` `        ``int``[] arr2 = { ``2``, ``7``, ``2``, ``1``, ``2``, ``6` `};` `        ``int` `m = arr2.length;` `        ``int` `K = ``7``;` `        ``is_possible(arr, arr2, n, m, K);`   `        ``int``[] brr = { ``5``, ``5``, ``5` `};` `        ``int` `n2 = brr.length;` `        ``int``[] brr2 = { ``4``, ``4``, ``4` `};` `        ``int` `m2 = brr2.length;` `        ``int` `K2 = ``4``;` `        ``is_possible(brr, brr2, n2, m2, K2);` `    ``}` `}` `//This is contributed by ishan0202`

## Python3

 `def` `is_possible(arr, brr, n, m, k):` `    ``# Initialize a list of tuples v to` `    ``# store the brr[i] and arr[i]` `    ``v ``=` `[]` `    ``for` `i ``in` `range``(n):` `        ``v.append((brr[i], arr[i]))`   `    ``# Sort the list v based on the first` `    ``# element of the tuple i.e brr[i]` `    ``v.sort(key``=``lambda` `x: x[``0``])`   `    ``i ``=` `0` `    ``# Initialize the value to be reduced` `    ``# from arr[i] as sum = k` `    ``sum` `=` `k`   `    ``# Iterate while k > 0 and i < n` `    ``# and decay the value of k by v[i]` `    ``# and apply operation while` `    ``# arr[i] which is v[i] is > 0` `    ``# also incrementing the sum by k` `    ``while` `k > ``0` `and` `i < n:` `        ``while` `(v[i][``1``] ``-` `sum``) > ``0``:` `            ``# Decay the value k` `            ``k ``=` `k ``-` `v[i][``0``]` `            ``if` `k >``=` `0``:` `                ``sum` `+``=` `k` `            ``else``:` `                ``break` `        ``i ``+``=` `1`   `    ``# Initialize ctr =0 to check whether` `    ``# all the array elements of arr[]` `    ``# are made to 0` `    ``ctr ``=` `0` `    ``for` `i ``in` `range``(n):` `        ``if` `(v[i][``1``] ``-` `sum``) <``=` `0``:` `            ``ctr ``+``=` `1`   `    ``# If all are made to 0 print YES` `    ``# else print NO` `    ``if` `ctr ``=``=` `n:` `        ``print``(``"YES"``)` `    ``else``:` `        ``print``(``"NO"``)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``18``, ``5``, ``13``, ``9``, ``10``, ``1``]` `    ``n ``=` `len``(arr)` `    ``arr2 ``=` `[``2``, ``7``, ``2``, ``1``, ``2``, ``6``]` `    ``m ``=` `len``(arr2)` `    ``K ``=` `7` `    ``is_possible(arr, arr2, n, m, K)`   `    ``brr ``=` `[``5``, ``5``, ``5``]` `    ``n2 ``=` `len``(brr)` `    ``brr2 ``=` `[``4``, ``4``, ``4``]` `    ``m2 ``=` `len``(brr2)` `    ``K2 ``=` `4` `    ``is_possible(brr, brr2, n2, m2, K2)` `#This is contributed by ishan0202`

## C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;` `using` `System.Text.RegularExpressions;`   `public` `class` `Gfg` `{` `    ``// Function to check whether all the array` `// elements can be made to 0.` `    ``static` `void` `is_possible(``int``[] arr, ``int``[] brr, ``int` `n, ``int` `m, ``int` `k)` `    ``{` `        ``// Initialize a vector of pairs v to` `        ``// store the brr[i] and arr[i]` `        ``List> v=``new` `List>();` `        ``int` `i;` `        ``for` `(i = 0; i < n; i++) {` `            ``v.Add(``new` `Tuple<``int``, ``int``>(brr[i] , arr[i]));` `        ``}` `    `  `        ``// Sort the vector v based on the first` `        ``// element of the pair i.e brr[i]` `        ``v.Sort();` `        ``i = 0;` `    `  `        ``// Initialize the value to be reduced` `        ``// from arr[i] as sum = k` `        ``int` `sum = k;` `    `  `        ``// Iterate while k > 0 and i < n` `        ``// and decay the value of k by v[i].` `        ``// first and apply operation while` `        ``// arr[i] which is v[i].second is > 0` `        ``// also incrementing the sum by k` `        ``while` `(k > 0 && i < n) {` `            ``while` `((v[i].Item2 - sum) > 0) {` `    `  `                ``// Decay the value k` `                ``k = k - v[i].Item1;` `                ``if` `(k >= 0)` `                    ``sum += k;` `                ``else` `                    ``break``;` `            ``}` `            ``i++;` `        ``}` `    `  `        ``// Initialize ctr =0 to check whether` `        ``// all the array elements of arr[]` `        ``// are made to 0` `        ``int` `ctr = 0;` `        ``for` `(i=0 ; i

## Javascript

 `function` `is_possible(arr, brr, n, m, k) {` `    ``var` `v = []` `    ``for` `(``var` `i = 0; i < n; i++) {` `        ``v.push({ brr: brr[i], arr: arr[i] });` `    ``}`   `    ``v.sort(``function` `(a, b) {` `        ``return` `a.brr - b.brr;` `    ``});`   `    ``var` `i = 0;` `    ``var` `sum = k;`   `    ``while` `(k > 0 && i < n) {` `        ``while` `((v[i].arr - sum) > 0) {` `            ``k = k - v[i].brr;` `            ``if` `(k >= 0)` `                ``sum += k;` `            ``else` `                ``break``;` `        ``}` `        ``i++;` `    ``}`   `    ``var` `ctr = 0;` `    ``for` `(``var` `itr of v) {` `        ``if` `((itr.arr - sum) <= 0) {` `            ``ctr++;` `        ``}` `    ``}`   `    ``if` `(ctr == n) {` `        ``console.log(``"YES"``);` `    ``}` `    ``else` `{` `        ``console.log(``"NO"``);` `    ``}` `}`   `// Driver Code` `console.log(is_possible([18, 5, 13, 9, 10, 1], [2, 7, 2, 1, 2, 6], 6, 6, 7));` `console.log(is_possible([5, 5, 5], [4, 4, 4], 3, 3, 4));`

Output

```YES
NO```

Time Complexity: O(NlogN), where N is the size of the array.
Auxiliary Space: O(N)

Related Articles:

My Personal Notes arrow_drop_up
Related Articles