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++
#include <bits/stdc++.h>
using namespace std;
void is_possible( int arr[], int brr[], int n, int m, int k)
{
vector<pair< int , int > > v;
for ( int i = 0; i < n; i++) {
v.push_back({ brr[i], arr[i] });
}
sort(v.begin(), v.end());
int i = 0;
int sum = k;
while (k > 0 && i < n) {
while ((v[i].second - sum) > 0) {
k = k - v[i].first;
if (k >= 0)
sum += k;
else
break ;
}
i++;
}
int ctr = 0;
for ( auto itr : v) {
if ((itr.second - sum) <= 0) {
ctr++;
}
}
if (ctr == n) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
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) {
List<Map.Entry<Integer, Integer>> v = new ArrayList<>();
for ( int i = 0 ; i < n; i++) {
v.add( new AbstractMap.SimpleEntry<>(brr[i], arr[i]));
}
Collections.sort(v, (o1, o2) -> o1.getKey().compareTo(o2.getKey()));
int i = 0 ;
int sum = k;
while (k > 0 && i < n) {
while ((v.get(i).getValue() - sum) > 0 ) {
k = k - v.get(i).getKey();
if (k >= 0 )
sum += k;
else
break ;
}
i++;
}
int ctr = 0 ;
for (Map.Entry<Integer, Integer> itr : v) {
if ((itr.getValue() - sum) <= 0 ) {
ctr++;
}
}
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);
}
}
|
Python3
def is_possible(arr, brr, n, m, k):
v = []
for i in range (n):
v.append((brr[i], arr[i]))
v.sort(key = lambda x: x[ 0 ])
i = 0
sum = k
while k > 0 and i < n:
while (v[i][ 1 ] - sum ) > 0 :
k = k - v[i][ 0 ]
if k > = 0 :
sum + = k
else :
break
i + = 1
ctr = 0
for i in range (n):
if (v[i][ 1 ] - sum ) < = 0 :
ctr + = 1
if ctr = = n:
print ( "YES" )
else :
print ( "NO" )
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)
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
public class Gfg
{
static void is_possible( int [] arr, int [] brr, int n, int m, int k)
{
List<Tuple< int , int >> v= new List<Tuple< int , int >>();
int i;
for (i = 0; i < n; i++) {
v.Add( new Tuple< int , int >(brr[i] , arr[i]));
}
v.Sort();
i = 0;
int sum = k;
while (k > 0 && i < n) {
while ((v[i].Item2 - sum) > 0) {
k = k - v[i].Item1;
if (k >= 0)
sum += k;
else
break ;
}
i++;
}
int ctr = 0;
for (i=0 ; i<v.Count; i++) {
if ((v[i].Item2 - sum) <= 0) {
ctr++;
}
}
if (ctr == n) {
Console.Write( "YES\n" );
}
else {
Console.Write( "NO\n" );
}
}
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);
}
}
|
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" );
}
}
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));
|
Time Complexity: O(NlogN), where N is the size of the array.
Auxiliary Space: O(N)
Related Articles:
Share your thoughts in the comments
Please Login to comment...