GeeksforGeeks App
Open App
Browser
Continue

# Minimize dissolve operations to make all elements 0 except first and last

Given an array arr of length N, the task is to find the minimum number of operations required to make all array elements 0, except  first and last, using the given operation any number of times:

• In each operation choose 3 indices 1 ≤ i < j < k ≤ n, such that  arr[j]>=2, and
• Subtract 2 from arr[j] and add 1 to both arr[i] and arr[k].

Examples

Input : arr = {1, 2,  2,  3,  6}
Output: 4
Explanation:
Select (i,j,k)=(1,2,5), array = {2,0,2,3,7}.
Select (i,j,k)=(1,3,4), array = [3,0,0,4,7].
Select (i,j,k)=(1,4,5) twice.
array = [5,0,0,0,9].
All elements except the first and last element  becomes equal to zero.

Input : arr = { 3, 1, 1, 2}
Output: -1
Explanation : It’s impossible to perform any operation,since it is not possible to  select j because all middle elements are 1

Approach: Consider the below observations:

There are only two cases when the answer is not possible

• Case 1 : When all elements except first and last are 1
• Case 2 : When the array size is 3 and there is an odd number on middle position.

Now consider other cases:

• Number on jth position, can convert two odd numbers ( on ith and kth indices)  into even by transferring 1
• and even number let’ s say x will require x/2 operations to convert into zero.
• If there are odd numbers , they will be first converted into even and then they are converted into zero ,
• If there are no odd  numbers left always select first and last indices as i and j.

Therefore this problem can be solves using below steps with the help of above observation:

• For even number (let’s say x), minimum operations required will be x/2
• For odd number (let’s say y), minimum operations required will be (y+1)/2

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;` `void` `solver(``int` `n, ``int` `arr[])``{``    ``int` `ans = 0;``    ``int` `cnt = 0;``    ``int` `i = 0;` `    ``// Check case 1``    ``if` `(n == 3 && arr[1] % 2 == 1) {``        ``cout << -1;``        ``return``;``    ``}` `    ``// Check case 2``    ``for` `(i = 1; i < n - 1; i++) {``        ``if` `(arr[i] == 1)``            ``cnt++;``    ``}` `    ``if` `(cnt == n - 2)``        ``cout << (-1);``    ``else` `{``        ``for` `(i = 1; i < n - 1; i++) {` `            ``// if number is odd``            ``// we have to first make it even``            ``// and then increased by one``            ``ans += (arr[i] + 1) / 2;``        ``}``        ``cout << (ans);``    ``}``}` `// Driver code``int` `main()``{` `    ``int` `N = 5;``    ``int` `arr[] = { 1, 2, 2, 3, 6 };``    ``solver(N, arr);` `    ``return` `0;``}` `    ``// This code is contributed by rakeshsahni`

## Java

 `// Java implementation of above approach` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `solver(``int` `n, ``int` `arr[])``    ``{``        ``int` `ans = ``0``;``        ``int` `cnt = ``0``;``        ``int` `i = ``0``;` `        ``// Check case 1``        ``if` `(n == ``3` `&& arr[``1``] % ``2` `== ``1``) {``            ``System.out.println(-``1``);``            ``return``;``        ``}` `        ``// Check case 2``        ``for` `(i = ``1``; i < n - ``1``; i++) {``            ``if` `(arr[i] == ``1``)``                ``cnt++;``        ``}` `        ``if` `(cnt == n - ``2``)``            ``System.out.println(-``1``);``        ``else` `{``            ``for` `(i = ``1``; i < n - ``1``; i++) {` `                ``// if number is odd``                ``// we have to first make it even``                ``// and then increased by one``                ``ans += (arr[i] + ``1``) / ``2``;``            ``}``            ``System.out.println(ans);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `N = ``5``;``        ``int` `arr[] = { ``1``, ``2``, ``2``, ``3``, ``6` `};``        ``solver(N, arr);``    ``}``}`

## Python

 `# Python implementation of above approach``def` `solver(n, arr):``    ``ans ``=` `0``    ``cnt ``=` `0``    ``i ``=` `0` `    ``# Check case 1``    ``if` `(n ``=``=` `3` `and` `arr[``1``] ``%` `2` `=``=` `1``):``        ``print``(``-``1``)``        ``return` `    ``# Check case 2``    ``for` `i ``in` `range``(``1``, n ``-` `1``):``        ``if` `(arr[i] ``=``=` `1``):``            ``cnt ``+``=` `1` `    ``if` `(cnt ``=``=` `n ``-` `2``):``        ``print``(``-``1``)``        ` `    ``else``:``        ``for` `i ``in` `range``(``1``, n ``-` `1``):` `            ``# if number is odd``            ``# we have to first make it even``            ``# and then increased by one``            ``ans ``+``=` `(arr[i] ``+` `1``) ``/``/` `2` `        ``print``(ans)` `# Driver code``N ``=` `5``arr ``=` `[ ``1``, ``2``, ``2``, ``3``, ``6` `]``solver(N, arr)` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# implementation of above approach``using` `System;` `class` `GFG {``    ``public` `static` `void` `solver(``int` `n, ``int` `[]arr)``    ``{``        ``int` `ans = 0;``        ``int` `cnt = 0;``        ``int` `i = 0;` `        ``// Check case 1``        ``if` `(n == 3 && arr[1] % 2 == 1) {``            ``Console.WriteLine(-1);``            ``return``;``        ``}` `        ``// Check case 2``        ``for` `(i = 1; i < n - 1; i++) {``            ``if` `(arr[i] == 1)``                ``cnt++;``        ``}` `        ``if` `(cnt == n - 2)``            ``Console.WriteLine(-1);``        ``else` `{``            ``for` `(i = 1; i < n - 1; i++) {` `                ``// if number is odd``                ``// we have to first make it even``                ``// and then increased by one``                ``ans += (arr[i] + 1) / 2;``            ``}``            ``Console.WriteLine(ans);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``int` `N = 5;``        ``int` `[]arr = { 1, 2, 2, 3, 6 };``        ``solver(N, arr);``    ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`4`

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

Another Approach:

1. Define a function named minOperations that takes two arguments: an integer n and an integer array arr.
2. Initialize a variable ans to 0.
3. Check for case 1: if n is 3 and the second element of arr is odd, return -1.
4. Check for case 2: if all elements of arr except the first and last are 1, return -1.
5. Loop through the array arr starting from the second element and ending at the second-to-last element:
a. If the current element is odd, add (arr[i] + 1) / 2 to ans.
b. If the current element is even, add arr[i] / 2 to ans.
6. Return ans.
7. In the main function, define an integer array arr and initialize it with the given values.
8. Compute the length of the array arr and store it in an integer variable n.
9. Call the minOperations function with arguments n and arr, and store the result in an integer variable ans.
10. Print the value of ans.
11. Return 0 to indicate successful completion of the program.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `int` `minOperations(``int` `n, ``int` `arr[]) {``    ``int` `ans = 0;` `    ``// check for case 1``    ``if` `(n == 3 && arr[1] % 2 == 1) {``        ``return` `-1;``    ``}` `    ``// check for case 2``    ``bool` `allOnes = ``true``;``    ``for` `(``int` `i = 1; i < n - 1; i++) {``        ``if` `(arr[i] != 1) {``            ``allOnes = ``false``;``            ``break``;``        ``}``    ``}``    ``if` `(allOnes) {``        ``return` `-1;``    ``}` `    ``// count minimum operations``    ``for` `(``int` `i = 1; i < n - 1; i++) {``        ``// if the number is odd, first make it even, then make it zero``        ``if` `(arr[i] % 2 == 1) {``            ``ans += (arr[i] + 1) / 2;``        ``}``        ``// if the number is even, just make it zero``        ``else` `{``            ``ans += arr[i] / 2;``        ``}``    ``}``    ``return` `ans;``}` `int` `main() {``    ``int` `arr[] = {1, 2, 2, 3, 6};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `ans = minOperations(n, arr);``    ``cout << ans << endl;``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {``    ``public` `static` `int` `minOperations(``int` `n, ``int``[] arr) {``        ``int` `ans = ``0``;` `        ``// check for case 1``        ``if` `(n == ``3` `&& arr[``1``] % ``2` `== ``1``) {``            ``return` `-``1``;``        ``}` `        ``// check for case 2``        ``boolean` `allOnes = ``true``;``        ``for` `(``int` `i = ``1``; i < n - ``1``; i++) {``            ``if` `(arr[i] != ``1``) {``                ``allOnes = ``false``;``                ``break``;``            ``}``        ``}``        ``if` `(allOnes) {``            ``return` `-``1``;``        ``}` `        ``// count minimum operations``        ``for` `(``int` `i = ``1``; i < n - ``1``; i++) {``            ``// if the number is odd, first make it even, then make it zero``            ``if` `(arr[i] % ``2` `== ``1``) {``                ``ans += (arr[i] + ``1``) / ``2``;``            ``}``            ``// if the number is even, just make it zero``            ``else` `{``                ``ans += arr[i] / ``2``;``            ``}``        ``}``        ``return` `ans;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = {``1``, ``2``, ``2``, ``3``, ``6``};``        ``int` `n = arr.length;``        ``int` `ans = minOperations(n, arr);``        ``System.out.println(ans);``    ``}``}`

## C#

 `using` `System;` `public` `class` `GFG {``  ``public` `static` `int` `MinOperations(``int` `n, ``int``[] arr) {``    ``int` `ans = 0;` `    ``// check for case 1``    ``if` `(n == 3 && arr[1] % 2 == 1)``    ``{``      ``return` `-1;``    ``}` `    ``// check for case 2``    ``bool` `allOnes = ``true``;``    ``for` `(``int` `i = 1; i < n - 1; i++)``    ``{``      ``if` `(arr[i] != 1)``      ``{``        ``allOnes = ``false``;``        ``break``;``      ``}``    ``}``    ``if` `(allOnes)``    ``{``      ``return` `-1;``    ``}` `    ``// count minimum operations``    ``for` `(``int` `i = 1; i < n - 1; i++)``    ``{``      ``// if the number is odd, first make it even, then make it zero``      ``if` `(arr[i] % 2 == 1)``      ``{``        ``ans += (arr[i] + 1) / 2;``      ``}``      ``// if the number is even, just make it zero``      ``else``      ``{``        ``ans += arr[i] / 2;``      ``}``    ``}``    ``return` `ans;``  ``}` `  ``public` `static` `void` `Main()``  ``{``    ``int``[] arr = {1, 2, 2, 3, 6};``    ``int` `n = arr.Length;``    ``int` `ans = MinOperations(n, arr);``    ``Console.WriteLine(ans);``  ``}``}` `// This code is contributed by aeroabrar_31`

Output

`4`

Time complexity: O(n)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up