Related Articles
Check if Array elements can be maximized upto M by adding all elements from another array
• Last Updated : 15 Feb, 2021

Given a positive integer M and two arrays arr[] and value[] of N and K positive integers respectively, the task is to add every element in value[] to an element in arr[] such that after all the additions are performed, the maximum element in the array is at most M. If it is possible to do so, then print “Yes”. Otherwise, print “No”.
Examples:

Input: arr[] = {5, 9, 3, 8, 7}, value[] = {1, 2, 3, 4}, M = 9
Output: Yes
Explanation:
Add 1 & 3 to arr maximizing it to 9.
Add 2 & 4 to arr maximizes it to 9.
Hence, the final arr becomes {9, 9, 9, 8, 7}.
Input: arr[] = {5, 8, 3, 8, 7}, value[] = {1, 2, 3, 4}, M = 8
Output: No
Explanation:
Adding 1 to arr, 3 to arr and 4 to arr, the array is modified to {8, 8, 7, 8, 8}.
The current maximum element in arr[] is 8.
Hence, only 2 needs to be added from value[] to any element of arr[].
But, on adding 2 to any element in arr[], the maximum element in the array exceeds 8.

Naive Approach:
The simplest approach is to choose any K elements from the given array arr[] and add the K values in the value[] array with these K values chosen. These K values can be added to the K chosen numbers of the array arr[] in K! ways (in the worst case).
Time Complexity: O( NPK )
Efficient Approach:
Follow the steps below to solve the problem:

1. Sort the elements in value[] array in decreasing order.
2. Store all the elements of arr[] in the min priority queue.
3. Now extract the minimum element(say X) from the priority queue and add the elements from the array value[] to X.
4. While adding value from the the array value[] to X exceeds M, then insert the element X into priority queue and repeat the above step for the next minimum value in the priority queue.
5. If all the elements in value[] are added to some elements in arr[] then “Yes”, else print “No”.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the``// above approach` `#include ``using` `namespace` `std;` `// Function which checks if all``// additions are possible``void` `solve(``int` `ar[], ``int` `values[],``        ``int` `N, ``int` `K, ``int` `M)``{` `    ``// Sorting values[] in``    ``// decreasing order``    ``sort(values, values + K,``        ``greater<``int``>());` `    ``// Minimum priority queue which``    ``// contains all the elements``    ``// of array arr[]``    ``priority_queue<``int``, vector<``int``>,``                ``greater<``int``> >``        ``pq;` `    ``for` `(``int` `x = 0; x < N; x++) {``        ``pq.push(ar[x]);``    ``}` `    ``// poss stores whether all the``    ``// additions are possible``    ``bool` `poss = ``true``;``    ``for` `(``int` `x = 0; x < K; x++) {` `        ``// Minium value in the``        ``// priority queue``        ``int` `mini = pq.top();``        ``pq.pop();``        ``int` `val = mini + values[x];` `        ``// If on addition it exceeds``        ``// M then not possible``        ``if` `(val > M) {``            ``poss = ``false``;``            ``break``;``        ``}``        ``pq.push(val);``    ``}` `    ``// If all elements are added``    ``if` `(poss) {``        ``cout << ``"Yes"` `<< endl;``    ``}``    ``else` `{``        ``cout << ``"No"` `<< endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `ar[] = { 5, 9, 3, 8, 7 };``    ``int` `N = 5;` `    ``int` `values[] = { 1, 2, 3, 4 };``    ``int` `K = 4;` `    ``int` `M = 9;` `    ``solve(ar, values, N, K, M);``    ``return` `0;``}`

## Java

 `// Java program to implement the``// above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{``           ` `// Function which checks if all``// additions are possible``static` `void` `solve(Integer ar[], Integer values[],``                  ``int` `N, ``int` `K, ``int` `M)``{``    ` `    ``// Sorting values[] in``    ``// decreasing order``    ``Arrays.sort(values, (a, b) -> b - a);` `    ``// Minimum priority queue which``    ``// contains all the elements``    ``// of array arr[]``    ``PriorityQueue pq = ``new` `PriorityQueue<>();``    ` `    ``for``(``int` `x = ``0``; x < N; x++)``    ``{``        ``pq.add(ar[x]);``    ``}``    ` `    ``// poss stores whether all the``    ``// additions are possible``    ``boolean` `poss = ``true``;``    ``for``(``int` `x = ``0``; x < K; x++)``    ``{``        ` `        ``// Minium value in the``        ``// priority queue``        ``int` `mini = pq.peek();``        ``pq.poll();``        ` `        ``int` `val = mini + values[x];``        ` `        ``// If on addition it exceeds``        ``// M then not possible``        ``if` `(val > M)``        ``{``            ``poss = ``false``;``            ``break``;``        ``}``        ``pq.add(val);``    ``}``    ` `    ``// If all elements are added``    ``if` `(poss)``    ``{``        ``System.out.println(``"Yes"``);``    ``}``    ``else``    ``{``        ``System.out.println(``"No"``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``Integer ar[] = { ``5``, ``9``, ``3``, ``8``, ``7` `};``    ``int` `N = ``5``;``    ` `    ``Integer values[] = { ``1``, ``2``, ``3``, ``4` `};``    ``int` `K = ``4``;``    ` `    ``int` `M = ``9``;``    ` `    ``solve(ar, values, N, K, M);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement the``# above approach``from` `queue ``import` `PriorityQueue` `# Function which checks if all``# additions are possible``def` `solve(ar, values, N, K, M):``     ` `    ``# Sorting values[] in``    ``# decreasing order``    ``values.sort(reverse ``=` `True``)``     ` `    ``# Minimum priority queue which``    ``# contains all the elements``    ``# of array arr[]``    ``pq ``=` `PriorityQueue()``    ` `    ``for` `x ``in` `range``(N):``    ` `        ``pq.put(ar[x]);``      ` `    ``# poss stores whether all the``    ``# additions are possible``    ``poss ``=` `True``;``    ` `    ``for` `x ``in` `range``(K):``         ` `        ``# Minium value in the``        ``# priority queue``        ``mini ``=` `pq.get();``         ` `        ``val ``=` `mini ``+` `values[x];``         ` `        ``# If on addition it exceeds``        ``# M then not possible``        ``if` `(val > M):``          ``poss ``=` `False``;``          ``break``;``        ` `        ``pq.put(val);``    ` `    ``# If all elements are added``    ``if` `(poss):``        ``print``(``"Yes"``);``    ``else``:``        ``print``(``"No"``);` `# Driver Code``if` `__name__``=``=``'__main__'``:` `    ``ar ``=` `[ ``5``, ``9``, ``3``, ``8``, ``7` `]``    ``N ``=` `5``;``     ` `    ``values ``=` `[ ``1``, ``2``, ``3``, ``4` `]``    ` `    ``K ``=` `4``;``     ` `    ``M ``=` `9``;``     ` `    ``solve(ar, values, N, K, M);` `# This code is contributed by rutvik_56`

## C#

 `// C# Program to implement the``// above approach ``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``    ` `    ``// Function which checks if all``    ``// additions are possible``    ``static` `void` `solve(``int``[] ar, ``int``[] values,``            ``int` `N, ``int` `K, ``int` `M)``    ``{``     ` `        ``// Sorting values[] in``        ``// decreasing order``        ``Array.Sort(values);``        ``Array.Reverse(values);``     ` `        ``// Minimum priority queue which``        ``// contains all the elements``        ``// of array arr[]``        ``List<``int``> pq = ``new` `List<``int``>();``     ` `        ``for` `(``int` `x = 0; x < N; x++)``        ``{``            ``pq.Add(ar[x]);``        ``}``        ` `        ``pq.Sort();``     ` `        ``// poss stores whether all the``        ``// additions are possible``        ``bool` `poss = ``true``;``        ``for` `(``int` `x = 0; x < K; x++)``        ``{``     ` `            ``// Minium value in the``            ``// priority queue``            ``int` `mini = pq;``            ``pq.RemoveAt(0);``            ``int` `val = mini + values[x];``     ` `            ``// If on addition it exceeds``            ``// M then not possible``            ``if` `(val > M)``            ``{``                ``poss = ``false``;``                ``break``;``            ``}``            ``pq.Add(val);``            ``pq.Sort();``        ``}``     ` `        ``// If all elements are added``        ``if` `(poss)``        ``{``            ``Console.WriteLine(``"Yes"``);``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"No"``);``        ``}``    ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int``[] ar = { 5, 9, 3, 8, 7 };``    ``int` `N = 5;`` ` `    ``int``[] values = { 1, 2, 3, 4 };``    ``int` `K = 4;`` ` `    ``int` `M = 9;`` ` `    ``solve(ar, values, N, K, M);``  ``}``}` `// This code is contributed by divyeshrabadiya07.`
Output:
`Yes`

Time Complexity: O((N+K)*log(N))
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up