# Count of minimum reductions required to get the required sum K

• Last Updated : 29 Dec, 2020

Given N pairs of integers and an integer K, the task is to find the minimum number of reductions required such that the sum of the first elements of each pair is ≤ K.Each reduction involves reducing the first value of a pair to its second value. If it is not possible to make the sum ≤ K, print -1.

Examples:
Input: N = 5, K = 32
10 6
6 4
8 5
9 8
5 2
Output:
Explanation:
Total Sum = 10 + 6 + 8 + 9 + 5 = 38 > K
Reducing 10 – > 6 and 8 – > 5 reduces the sum to 31( 6 + 6 + 5 + 9 + 5) which is less than K.

Input: N = 4, K = 25
10 5
20 9
12 10
4 2
Output: -1

Approach:
Follow the steps below to solve the problem:

1. Calculate the sum of the first element of every pair. If the sum is already ≤ K, print 0.
2. Sort the given pairs based on their difference.
3. Count the number of differences of pairs that need to be added in non-increasing order to get the sum to be less than K.
4. If the sum exceeds K after traversal of all pairs, print -1. Otherwise, print the count.

Below is the implementation of the above approach:

## C++

 `// C++ Program to find the count of``// minimum reductions required to``// get the required sum K``#include ``using` `namespace` `std;` `// Function to return the count``// of minimum reductions``int` `countReductions(``    ``vector >& v,``    ``int` `K)``{` `    ``int` `sum = 0;``    ``for` `(``auto` `i : v) {``        ``sum += i.first;``    ``}` `    ``// If the sum is already``    ``// less than K``    ``if` `(sum <= K) {``        ``return` `0;``    ``}` `    ``// Sort in non-increasing``    ``// order of difference``    ``sort(v.begin(), v.end(),``         ``[&](``             ``pair<``int``, ``int``> a,``             ``pair<``int``, ``int``> b) {``             ``return` `(a.first - a.second)``                    ``> (b.first - b.second);``         ``});` `    ``int` `i = 0;``    ``while` `(sum > K && i < v.size()) {``        ``sum -= (v[i].first``                ``- v[i].second);``        ``i++;``    ``}` `    ``if` `(sum <= K)``        ``return` `i;` `    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``int` `N = 4, K = 25;` `    ``vector > v(N);``    ``v = { 10, 5 };``    ``v = { 20, 9 };``    ``v = { 12, 10 };``    ``v = { 4, 2 };` `    ``// Function Call``    ``cout << countReductions(v, K)``         ``<< endl;``    ``return` `0;``}`

## Java

 `// Java program to find the count of``// minimum reductions required to``// get the required sum K``import` `java.util.*;` `class` `GFG{``    ` `// Function to return the count``// of minimum reductions``static` `int` `countReductions(ArrayList<``int``[]> v,``                           ``int` `K)``{``    ``int` `sum = ``0``;``    ``for``(``int``[] i : v)``    ``{``        ``sum += i[``0``];``    ``}` `    ``// If the sum is already``    ``// less than K``    ``if` `(sum <= K)``    ``{``        ``return` `0``;``    ``}` `    ``// Sort in non-increasing``    ``// order of difference``    ``Collections.sort(v, (a, b) -> Math.abs(b[``0``] - b[``1``]) -``                                  ``Math.abs(a[``0``] - a[``1``]));` `    ``int` `i = ``0``;``    ``while` `(sum > K && i < v.size())``    ``{``        ``sum -= (v.get(i)[``0``] - v.get(i)[``1``]);``        ``i++;``    ``}` `    ``if` `(sum <= K)``        ``return` `i;` `    ``return` `-``1``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``4``, K = ``25``;` `    ``ArrayList<``int``[]> v = ``new` `ArrayList<>();` `    ``v.add(``new` `int``[] { ``10``, ``5` `});``    ``v.add(``new` `int``[] { ``20``, ``9` `});``    ``v.add(``new` `int``[] { ``12``, ``10` `});``    ``v.add(``new` `int``[] { ``4``, ``2` `});` `    ``// Function Call``    ``System.out.println(countReductions(v, K));``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to find the count of``# minimum reductions required to``# get the required sum K``from` `typing ``import` `Any``, ``List` `# Function to return the count``# of minimum reductions``def` `countReductions(v: ``List``[``Any``], K: ``int``) ``-``> ``int``:` `    ``sum` `=` `0``    ` `    ``for` `i ``in` `v:``        ``sum` `+``=` `i[``0``]` `    ``# If the sum is already``    ``# less than K``    ``if` `(``sum` `<``=` `K):``        ``return` `0` `    ``# Sort in non-increasing``    ``# order of difference``    ``v.sort(key ``=` `lambda` `a : a[``0``] ``-` `a[``1``])` `    ``i ``=` `0``    ` `    ``while` `(``sum` `> K ``and` `i < ``len``(v)):``        ``sum` `-``=` `(v[i][``0``] ``-` `v[i][``1``])``        ``i ``+``=` `1` `    ``if` `(``sum` `<``=` `K):``        ``return` `i` `    ``return` `-``1` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `4``    ``K ``=` `25` `    ``v ``=` `[[``0``, ``0``] ``for` `_ ``in` `range``(N)]``    ``v[``0``] ``=` `[``10``, ``5``]``    ``v[``1``] ``=` `[``20``, ``9``]``    ``v[``2``] ``=` `[``12``, ``10``]``    ``v[``3``] ``=` `[``4``, ``2``]` `    ``# Function Call``    ``print``(countReductions(v, K))` `# This code is contributed by sanjeev2552`

Output:

`-1`

Time Complexity:O(NlogN)
Auxiliary Space:O(1)

My Personal Notes arrow_drop_up