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[0]);     int arr2[] = { 2, 7, 2, 1, 2, 6 };     int m = sizeof(arr2) / sizeof(arr2[0]);     int K = 7;     is_possible(arr, arr2, n, m, K);       int brr[] = { 5, 5, 5 };     int n2 = sizeof(brr) / sizeof(brr[0]);     int brr2[] = { 4, 4, 4 };     int m2 = sizeof(brr2) / sizeof(brr2[0]);     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][0]     # and apply operation while     # arr[i] which is v[i][1] 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(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