Given an array arr[] of size N, the task is to check if it is possible to convert all array elements to 0s, by subtracting Ki from an array element, in the ith step. If it is possible to do so, then print “Yes“. Otherwise, print “No“.
Examples:
Input: N = 5, K = 2, arr[] = {8, 0, 3, 4, 80}
Output: Yes
Explanation:
One possible sequence of operations is as follows:
- Subtract 20 from arr[2]( = 3 ). Thereafter, the array modifies to, arr[] = {8, 0, 2, 4, 32}.
- Subtract 21 from arr[2]( = 2 ). Thereafter, the array modifies to, arr[] = {8, 0, 0, 4, 32}.
- Subtract 22 from arr[3]( = 4 ). Thereafter, the array modifies to, arr[] = {8, 0, 0, 0, 32}.
- Subtract 23 from arr[1]( = 8 ). Thereafter, the array modifies to, arr[] = {0, 0, 0, 0, 32}.
- Do not subtract 24 from any array element.
- Subtract 25 from arr[4]( = 32 ). Thereafter, the array modifies to, arr[] = {0, 0, 0, 0, 0}.
Input: N = 3, K = 2, arr[] = {0, 1, 3}
Output: No
Approach: Follow the steps below to solve the problem:
- Initialize a vector, say V, to store all powers of K possible.
- Also, initialize a map<int, int>, say MP, to store if a power of K has been used or not.
- Initialize a variable, say X as 1, to store the count of powers of K.
-
Iterate until X is less than INT_MAX and perform the following steps:
- Push the value of X into the vector.
- Multiply X by K.
- Iterate over the range [0, N – 1] using a variable i and perform the following steps:
- If i is less than N, then print “No”, as the array elements can not be made 0. Otherwise, print “Yes”.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to check whether all array // elements can be made zero or not string isMakeZero( int arr[], int N, int K)
{ // Stores if a power of K has
// already been subtracted or not
map< int , int > MP;
// Stores all the Kth power
vector< int > V;
int X = 1;
int i;
// Iterate until X is
// less than INT_MAX
while (X > 0 && X < INT_MAX) {
V.push_back(X);
X *= K;
}
// Traverse the array arr[]
for (i = 0; i < N; i++) {
// Iterate over the range [0, M]
for ( int j = V.size() - 1; j >= 0; j--) {
// If MP[V[j]] is 0 and V[j]
// is less than or equal to arr[i]
if (MP[V[j]] == 0 && V[j] <= arr[i]) {
arr[i] -= V[j];
MP[V[j]] = 1;
}
}
// If arr[i] is not 0
if (arr[i] != 0)
break ;
}
// If i is less than N
if (i < N)
return "No" ;
// Otherwise,
else
return "Yes" ;
} // Driver code int main()
{ int arr[] = { 8, 0, 3, 4, 80 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 2;
cout << isMakeZero(arr, N, K);
return 0;
} |
// Java program for the above approach import java.util.ArrayList;
import java.util.HashMap;
class GFG {
// Function to check whether all array
// elements can be made zero or not
static String isMakeZero( int arr[], int N, int K)
{
// Stores if a power of K has
// already been subtracted or not
HashMap<Integer, Integer> MP = new HashMap<Integer, Integer>();
// Stores all the Kth power
ArrayList<Integer> V = new ArrayList<Integer>();
int X = 1 ;
int i;
// Iterate until X is
// less than INT_MAX
while (X > 0 && X < Integer.MAX_VALUE) {
V.add(X);
X *= K;
}
// Traverse the array arr[]
for (i = 0 ; i < N; i++) {
// Iterate over the range [0, M]
for ( int j = V.size() - 1 ; j >= 0 ; j--) {
// If MP[V[j]] is 0 and V[j]
// is less than or equal to arr[i]
if (MP.containsKey(V.get(j)) == false && V.get(j) <= arr[i]) {
arr[i] -= V.get(j);
MP.put(V.get(j), 1 );
}
}
// If arr[i] is not 0
if (arr[i] != 0 )
break ;
}
// If i is less than N
if (i < N)
return "No" ;
// Otherwise,
else
return "Yes" ;
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 8 , 0 , 3 , 4 , 80 };
int N = arr.length;
int K = 2 ;
System.out.println(isMakeZero(arr, N, K));
}
} // This code is contributed by _saurabh_jaiswal. |
# Python Program for the above approach # Function to check whether all array # elements can be made zero or not def isMakeZero(arr, N, K):
# Stores if a power of K has
# already been subtracted or not
MP = {}
# Stores all the Kth power
V = []
X = 1
# Iterate until X is
# less than INT_MAX
while (X > 0 and X < 10 * * 20 ):
V.append(X)
X * = K
# Traverse the array arr[]
for i in range ( 0 , N, 1 ):
# Iterate over the range [0, M]
for j in range ( len (V) - 1 , - 1 , - 1 ):
# If MP[V[j]] is 0 and V[j]
# is less than or equal to arr[i]
if (V[j] not in MP and V[j] < = arr[i]):
arr[i] - = V[j]
MP[V[j]] = 1
# If arr[i] is not 0
if (arr[i] ! = 0 ):
break
# If i is less than N - 1
if (i < N - 1 ):
return "No"
# Otherwise,
else :
return "Yes"
# Driver code arr = [ 8 , 0 , 3 , 4 , 80 ]
N = len (arr)
K = 2
print (isMakeZero(arr, N, K))
# This code is contributed by _saurabh_jaiswal |
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG{
// Function to check whether all array
// elements can be made zero or not
static string isMakeZero( int [] arr, int N, int K)
{
// Stores if a power of K has
// already been subtracted or not
Dictionary< int , int > MP = new Dictionary< int , int >();
// Stores all the Kth power
List< int > V = new List< int >();
int X = 1;
int i;
// Iterate until X is
// less than INT_MAX
while (X > 0 && X < Int32.MaxValue) {
V.Add(X);
X *= K;
}
// Traverse the array arr[]
for (i = 0; i < N; i++) {
// Iterate over the range [0, M]
for ( int j = V.Count - 1; j >= 0; j--) {
// If MP[V[j]] is 0 and V[j]
// is less than or equal to arr[i]
if (MP.ContainsKey(V[j]) == false && V[j] <= arr[i]) {
arr[i] -= V[j];
MP[V[j]] = 1;
}
}
// If arr[i] is not 0
if (arr[i] != 0)
break ;
}
// If i is less than N
if (i < N)
return "No" ;
// Otherwise,
else
return "Yes" ;
}
// Driver Code public static void Main(String[] args)
{ int [] arr = { 8, 0, 3, 4, 80 };
int N = arr.Length;
int K = 2;
Console.WriteLine(isMakeZero(arr, N, K));
} } // This code is contributed by splevel62. |
<script> // JavaScript Program for the above approach
// Function to check whether all array
// elements can be made zero or not
function isMakeZero(arr, N, K) {
// Stores if a power of K has
// already been subtracted or not
let MP = new Map();
// Stores all the Kth power
let V = [];
let X = 1;
let i;
// Iterate until X is
// less than INT_MAX
while (X > 0 && X < Number.MAX_VALUE) {
V.push(X);
X *= K;
}
// Traverse the array arr[]
for (i = 0; i < N; i++) {
// Iterate over the range [0, M]
for (let j = V.length - 1; j >= 0; j--) {
// If MP[V[j]] is 0 and V[j]
// is less than or equal to arr[i]
if (MP.has(V[j]) == false && V[j] <= arr[i]) {
arr[i] -= V[j];
MP.set(V[j], 1);
}
}
// If arr[i] is not 0
if (arr[i] != 0)
break ;
}
// If i is less than N
if (i < N)
return "No" ;
// Otherwise,
else
return "Yes" ;
}
// Driver code
let arr = [8, 0, 3, 4, 80];
let N = arr.length;
let K = 2;
document.write(isMakeZero(arr, N, K));
// This code is contributed by Potta Lokesh
</script>
|
Yes
Time Complexity: O(N* logK(INT_MAX))
Auxiliary Space: O(logK(INT_MAX))