# Value to be subtracted from array elements to make sum of all elements equals K

Given an integer K and an array height[] where height[i] denotes the height of the ith tree in a forest. The task is to make a cut of height X from the ground such that exactly K unit wood is collected. If it is not possible then print -1 else print X.

Examples:

Input: height[] = {1, 2, 1, 2}, K = 2
Output: 1
Make a cut at height 1, the updated array will be {1, 1, 1, 1} and
the collected wood will be {0, 1, 0, 1} i.e. 0 + 1 + 0 + 1 = 2.

Input: height = {1, 1, 2, 2}, K = 1
Output: -1

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: This problem can be solved using binary search.

• Sort the heights of the trees.
• The lowest height to make the cut is 0 and the highest is the maximum height among all the trees. So, set low = 0 and high = max(height[i]).
• Repeat the below steps while low ≤ high:
1. Set mid = low + ((high – low) / 2).
2. Count the amount of wood that can be collected if the cut is made at height mid and store it in a varible collected.
3. If collected = K then mid is the answer.
4. If collecetd > K then update low = mid + 1 as the cut needs to be made at a height higher than the current height
5. Else update high = mid – 1 as cuts need to made at a lower height.
• Print -1 if no such value of mid is found.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the amount of wood ` `// collected if the cut is made at height m ` `int` `woodCollected(``int` `height[], ``int` `n, ``int` `m) ` `{ ` `    ``int` `sum = 0; ` `    ``for` `(``int` `i = n - 1; i >= 0; i--) { ` `        ``if` `(height[i] - m <= 0) ` `            ``break``; ` `        ``sum += (height[i] - m); ` `    ``} ` ` `  `    ``return` `sum; ` `} ` ` `  `// Function that returns Height at ` `// which cut should be made ` `int` `collectKWood(``int` `height[], ``int` `n, ``int` `k) ` `{ ` `    ``// Sort the heights of the trees ` `    ``sort(height, height + n); ` ` `  `    ``// The minimum and the maximum ` `    ``// cut that can be made ` `    ``int` `low = 0, high = height[n - 1]; ` ` `  `    ``// Binary search to find the answer ` `    ``while` `(low <= high) { ` `        ``int` `mid = low + ((high - low) / 2); ` ` `  `        ``// The amount of wood collected ` `        ``// when cut is made at the mid ` `        ``int` `collected = woodCollected(height, n, mid); ` ` `  `        ``// If the current collected wood is ` `        ``// equal to the required amount ` `        ``if` `(collected == k) ` `            ``return` `mid; ` ` `  `        ``// If it is more than the required amount ` `        ``// then the cut needs to be made at a ` `        ``// height higher than the current height ` `        ``if` `(collected > k) ` `            ``low = mid + 1; ` ` `  `        ``// Else made the cut at a lower height ` `        ``else` `            ``high = mid - 1; ` `    ``} ` ` `  `    ``return` `-1; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `height[] = { 1, 2, 1, 2 }; ` `    ``int` `n = ``sizeof``(height) / ``sizeof``(height); ` `    ``int` `k = 2; ` ` `  `    ``cout << collectKWood(height, n, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `import` `java.util.Arrays;  ` ` `  `class` `GFG  ` `{ ` `    ``static` `int``[] height = ``new` `int``[]{ ``1``, ``2``, ``1``, ``2` `};  ` `     `  `    ``// Function to return the amount of wood  ` `    ``// collected if the cut is made at height m  ` `    ``public` `static` `int` `woodCollected(``int` `n, ``int` `m)  ` `    ``{  ` `        ``int` `sum = ``0``;  ` `        ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) ` `        ``{  ` `            ``if` `(height[i] - m <= ``0``)  ` `                ``break``;  ` `            ``sum += (height[i] - m);  ` `        ``}  ` `        ``return` `sum;  ` `    ``}  ` ` `  `    ``// Function that returns Height at  ` `    ``// which cut should be made  ` `    ``public` `static` `int` `collectKWood(``int` `n, ``int` `k)  ` `    ``{  ` `        ``// Sort the heights of the trees  ` `        ``Arrays.sort(height); ` ` `  `        ``// The minimum and the maximum  ` `        ``// cut that can be made  ` `        ``int` `low = ``0``, high = height[n - ``1``];  ` ` `  `        ``// Binary search to find the answer  ` `        ``while` `(low <= high) ` `        ``{  ` `            ``int` `mid = low + ((high - low) / ``2``);  ` ` `  `            ``// The amount of wood collected  ` `            ``// when cut is made at the mid  ` `            ``int` `collected = woodCollected(n, mid);  ` ` `  `            ``// If the current collected wood is  ` `            ``// equal to the required amount  ` `            ``if` `(collected == k)  ` `                ``return` `mid;  ` ` `  `            ``// If it is more than the required amount  ` `            ``// then the cut needs to be made at a  ` `            ``// height higher than the current height  ` `            ``if` `(collected > k)  ` `                ``low = mid + ``1``;  ` ` `  `            ``// Else made the cut at a lower height  ` `            ``else` `                ``high = mid - ``1``;  ` `        ``}  ` `        ``return` `-``1``;  ` `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String[] args) ` `    ``{  ` `        ``int` `k = ``2``;  ` `        ``int` `n = height.length; ` `        ``System.out.print(collectKWood(n,k));  ` `    ``}  ` `} ` ` `  `// This code is contributed by Sanjit_Prasad `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to return the amount of wood ` `# collected if the cut is made at height m ` `def` `woodCollected(height, n, m): ` `    ``sum` `=` `0` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``): ` `        ``if` `(height[i] ``-` `m <``=` `0``): ` `            ``break` `        ``sum` `+``=` `(height[i] ``-` `m) ` ` `  `    ``return` `sum` ` `  `# Function that returns Height at ` `# which cut should be made ` `def` `collectKWood(height, n, k): ` `     `  `    ``# Sort the heights of the trees ` `    ``height ``=` `sorted``(height) ` ` `  `    ``# The minimum and the maximum ` `    ``# cut that can be made ` `    ``low ``=` `0` `    ``high ``=` `height[n ``-` `1``] ` ` `  `    ``# Binary search to find the answer ` `    ``while` `(low <``=` `high): ` `        ``mid ``=` `low ``+` `((high ``-` `low) ``/``/` `2``) ` ` `  `        ``# The amount of wood collected ` `        ``# when cut is made at the mid ` `        ``collected ``=` `woodCollected(height, n, mid) ` ` `  `        ``# If the current collected wood is ` `        ``# equal to the required amount ` `        ``if` `(collected ``=``=` `k): ` `            ``return` `mid ` ` `  `        ``# If it is more than the required amount ` `        ``# then the cut needs to be made at a ` `        ``# height higher than the current height ` `        ``if` `(collected > k): ` `            ``low ``=` `mid ``+` `1` ` `  `        ``# Else made the cut at a lower height ` `        ``else``: ` `            ``high ``=` `mid ``-` `1` ` `  `    ``return` `-``1` ` `  `# Driver code ` `height ``=` `[``1``, ``2``, ``1``, ``2``] ` `n ``=` `len``(height) ` `k ``=` `2` ` `  `print``(collectKWood(height, n, k)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# implementation of the approach  ` `using` `System; ` `using` `System.Collections;  ` ` `  `class` `GFG  ` `{  ` `    ``static` `int``[] height = { 1, 2, 1, 2 };  ` `     `  `    ``// Function to return the amount of wood  ` `    ``// collected if the cut is made at height m  ` `    ``public` `static` `int` `woodCollected(``int` `n, ``int` `m)  ` `    ``{  ` `        ``int` `sum = 0;  ` `        ``for` `(``int` `i = n - 1; i >= 0; i--)  ` `        ``{  ` `            ``if` `(height[i] - m <= 0)  ` `                ``break``;  ` `            ``sum += (height[i] - m);  ` `        ``}  ` `        ``return` `sum;  ` `    ``}  ` ` `  `    ``// Function that returns Height at  ` `    ``// which cut should be made  ` `    ``public` `static` `int` `collectKWood(``int` `n, ``int` `k)  ` `    ``{  ` `        ``// Sort the heights of the trees  ` `        ``Array.Sort(height);  ` ` `  `        ``// The minimum and the maximum  ` `        ``// cut that can be made  ` `        ``int` `low = 0, high = height[n - 1];  ` ` `  `        ``// Binary search to find the answer  ` `        ``while` `(low <= high)  ` `        ``{  ` `            ``int` `mid = low + ((high - low) / 2);  ` ` `  `            ``// The amount of wood collected  ` `            ``// when cut is made at the mid  ` `            ``int` `collected = woodCollected(n, mid);  ` ` `  `            ``// If the current collected wood is  ` `            ``// equal to the required amount  ` `            ``if` `(collected == k)  ` `                ``return` `mid;  ` ` `  `            ``// If it is more than the required amount  ` `            ``// then the cut needs to be made at a  ` `            ``// height higher than the current height  ` `            ``if` `(collected > k)  ` `                ``low = mid + 1;  ` ` `  `            ``// Else made the cut at a lower height  ` `            ``else` `                ``high = mid - 1;  ` `        ``}  ` `        ``return` `-1;  ` `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `        ``int` `k = 2;  ` `        ``int` `n = height.Length;  ` `        ``Console.WriteLine(collectKWood(n,k));  ` `    ``}  ` `}  ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```1
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.