 Open in App
Not now

# Minimize operations to reduce Array by replacing pair with their sum

• Last Updated : 14 Mar, 2023

Given an array X[] of length N. In each operation, the following task is performed:

• Decrement any value by 1.
• Replace any pair with their sum and the cost of replacing is the same as the reduced value (i.e., 1).

Examples:

Input: N = 4, X[] = {4, 2, 1, 3}
Output: 2
Explanation: Operations are performed as:
First operation: Select X = 1, reduced that value by one, and used it to merge X and X, Formally, X + X + 1 = 4 + 2 + 1 = 7. Now updated X[] is = {7,  3}
Second operation:  Seclect element X=3, reduced it by one, then X=2, Now merge X and X with that reduced value. Formally, X + X + 1 = 7 + 2 + 1 = 10. Updated X[] is: X[]={10}. No need to proceed with further operations as only one element is there in X[].
So, in total 2 operations were required.

Input: N = 7, X[] = {4, 2, 2, 4, 1, 2, 7}, Z=3
Output: 4
Explanation: Operations are performed as:
First operation: Select X, reduced it by one, Now A=0 and use the reduced value to merge X and X. Formally, X +  X + 1 = 2 + 2 +1 = 5. Now updated X[] is: {4, 5, 4, 2, 7}
Second operation: Select X = 4, reduced it by one, Now X=3 and use reduced value to merge X and X. Formally, X + X+1 = 5 + 4 + 1 = 10. Now updated X[] is: {3, 10, 2, 7}
Third operation: Select X = 2, reduce it by one, Now X=1, and use reduced value to merge X and X. Formally, X + X + 1 = 3 + 7 + 1 = 11. Now updated X[] is: {10, 1, 11}
Fourth operation: Select X=1, reduce it by one, Now X=0, and use reduced value to merge X and X. Formally, X + X + 1 = 10 + 11 + 1 = 22. Now updated X[] is: {22}

Approach: Implement the idea below to solve the problem

The problem is observation based and can be solved by using Greedy Technique. The problem required to be perform sorting then start reducing the lowest elements because this will result in minimum number of operations as some elements may disappear during the process.

Follow the below steps to implement the idea:

• Create a variable (say operations = 0) for holding the minimum number of operations.
• Sort the array.
• Run a loop from i = 0 to N-1:
• If (N – i – 1 >operations) then:
• If (N – i – 2 > operations + X[i]) then add X[i] to operations.
• Otherwise, if (N – i – 2 = operations + X[i]) then add X[i] to operations and break
• Else set operations as (N – i – 1).
• Otherwise, break from the loop.
• Return the value of operations.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Method for obtaining minimum cost` `void` `min_cuts(``int` `N, ``int` `X[])` `{` `    ``// Variable to store number of operations` `    ``int` `operations = 0;`   `    ``// Sorting array` `    ``sort(X, X + N);`   `    ``// Loop for traversing` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(N - i - 1 > operations) {` `            ``if` `(N - i - 2 > operations + X[i])` `                ``operations += X[i];` `            ``else` `if` `(N - i - 2 == operations + X[i]) {` `                ``operations += X[i];` `                ``break``;` `            ``}` `            ``else` `                ``operations = N - i - 1;` `        ``}` `        ``else` `            ``break``;` `    ``}`   `    ``// Printing the minimum cost of total operations` `    ``cout << operations << endl;` `}`   `int` `main() {`   `    ``int` `X[] = { 4, 2, 2, 4, 1, 2, 7 };` `    ``int` `N = ``sizeof``(X)/``sizeof``(X);`   `    ``// Function call` `    ``min_cuts(N, X);` `}`

## Java

 `// Java code to implement the approach`   `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `        ``throws` `java.lang.Exception` `    ``{` `        ``int` `X[] = { ``4``, ``2``, ``2``, ``4``, ``1``, ``2``, ``7` `};` `        ``int` `N = X.length;`   `        ``// Function call` `        ``min_cuts(N, X);` `    ``}`   `    ``// Method for obtaining minimum cost` `    ``static` `void` `min_cuts(``int` `N, ``int``[] X)` `    ``{` `        ``// Variable to store number of` `        ``// operations` `        ``int` `operations = ``0``;`   `        ``// Sorting array` `        ``Arrays.sort(X);`   `        ``// Loop for traversing` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``if` `(N - i - ``1` `> operations) {` `                ``if` `(N - i - ``2` `> operations + X[i])` `                    ``operations += X[i];` `                ``else` `if` `(N - i - ``2` `== operations + X[i]) {` `                    ``operations += X[i];` `                    ``break``;` `                ``}` `                ``else` `                    ``operations = N - i - ``1``;` `            ``}` `            ``else` `                ``break``;` `        ``}`   `        ``// Printing the minimum cost of total operations` `        ``System.out.println(operations);` `    ``}` `}`

## C#

 `// C# code to implement the approach`   `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[] X = { 4, 2, 2, 4, 1, 2, 7 };` `    ``int` `N = X.Length;`   `    ``// Function call` `    ``min_cuts(N, X);` `  ``}`   `  ``// Method for obtaining minimum cost` `  ``static` `void` `min_cuts(``int` `N, ``int``[] X)` `  ``{` `    ``// Variable to store number of operations` `    ``int` `operations = 0;`   `    ``// Sorting array` `    ``Array.Sort(X);`   `    ``// Loop for traversing` `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``if` `(N - i - 1 > operations) {` `        ``if` `(N - i - 2 > operations + X[i])` `          ``operations += X[i];` `        ``else` `if` `(N - i - 2 == operations + X[i]) {` `          ``operations += X[i];` `          ``break``;` `        ``}` `        ``else` `          ``operations = N - i - 1;` `      ``}` `      ``else` `        ``break``;` `    ``}`   `    ``// Printing the minimum cost of total operations` `    ``Console.WriteLine(operations);` `  ``}` `}`   `// This code is contributed by sankar.`

## Python3

 `def` `min_cuts(N, X):` `# Variable to store number of operations` `  ``operations ``=` `0` `# Sorting array` `  ``X.sort()`   `# Loop for traversing` `  ``for` `i ``in` `range``(N):` `      ``if` `N ``-` `i ``-` `1` `> operations:` `          ``if` `N ``-` `i ``-` `2` `> operations ``+` `X[i]:` `              ``operations ``+``=` `X[i]` `          ``elif` `N ``-` `i ``-` `2` `=``=` `operations ``+` `X[i]:` `            ``operations ``+``=` `X[i]` `            ``break` `          ``else``:` `              ``operations ``=` `N ``-` `i ``-` `1` `      ``else``:` `         ``break`   `# Printing the minimum cost of total operations` `  ``print``(operations)`     `X ``=` `[``4``, ``2``, ``2``, ``4``, ``1``, ``2``, ``7``]` `N ``=` `len``(X)` `# Function call` `min_cuts(N, X)`

## Javascript

 `// Javascript program for the above approach`   `function` `min_cuts(N, X) {` `  ``// Variable to store number of operations` `  ``let operations = 0;` `  `  `  ``// Sorting array` `  ``X.sort((a, b) => a - b);`   `  ``// Loop for traversing` `  ``for` `(let i = 0; i < N; i++) {` `    ``if` `(N - i - 1 > operations) {` `      ``if` `(N - i - 2 > operations + X[i]) {` `        ``operations += X[i];` `      ``} ``else` `if` `(N - i - 2 === operations + X[i]) {` `        ``operations += X[i];` `        ``break``;` `      ``} ``else` `{` `        ``operations = N - i - 1;` `      ``}` `    ``} ``else` `{` `      ``break``;` `    ``}` `  ``}`   `  ``// Printing the minimum cost of total operations` `  ``console.log(operations);` `}`   `let X = [4, 2, 2, 4, 1, 2, 7];` `let N = X.length;` `// Function call` `min_cuts(N, X);`     `// This code is contributed by rishab`

Output

`4`

Time Complexity: O(N * log(N))
Auxiliary Space: O(1)

Related Articles:

My Personal Notes arrow_drop_up
Related Articles