 Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 08 Jun, 2022

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:
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 Practice

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 height is the maximum height among all the trees. So, set low = 0 and high = max(height[i]).
• Repeat the steps below 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 variable collected.
3. If collected = K then mid is the answer.
4. If collected > 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 be 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`

## Javascript

 ``

Output:

`1`

Time Complexity: O(nlog(max_element in the array))

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles