Maximum Possible Product in Array after performing given Operations

Given an array with size N. You are allowed to perform two types of operations on the given array as described below:

1. Choose some position i and j, such that (i is not equals to j), replace the value of a[j] with a[i]*a[j] and remove the number from the i^th cell.
2. Choose some position i and remove the number from the i^th cell (This operation can be performed at-most once and at any point of time, not necessarily in the beginning).

The task is to perform exactly N-1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it, print the sequence of operations which leads to this maximum number. 

The output should contain exactly N-1 lines:

• If the operation is of the first type then print 1 i j.
• If the operation is of the second type then print 2 i.

Note: The array is considered to have 1-based indexing.

Examples:  

Input : a[] = { 5, -2, 0, 1, -3 }
Output : 2 3
         1 1 2
         1 2 4
         1 4 5
Explanation: 
Step 1: a[3] is removed.
Step 2: a[2] = a[2]*a[1] = -10; a[1] is removed.
Step 3: a[4] = a[4]*a[2] = -10; a[2] is removed.
Step 4: a[5] = a[5]*a[4] = 30; a[4] is removed.
So, the maximum product is 30.

Input : a[] = { 0, 0, 0, 0 }
Output : 1 1 2
         1 2 3
         1 3 4

Approach: There are several cases in the problem. Let the number of zeroes in the array be cntZero and the number of negative elements be cntNeg. Also let maxNeg be the position of the maximum negative element in the array, or -1 if there are no negative elements in the array.

Let the answer part be the product of all the numbers which will be in the answer and the removed part be the product of all the numbers which will be removed by the second type of operation.

The cases are as follows:  

1. The first case is when cntZero=0 and cntNeg=0. Then the answer part is the product of all the numbers in the array. The removed part is empty.
2. The second case is when cntNeg is odd. Then the answer part is the product of all the numbers in the array except all zeroes and a[maxNeg]. The removed part is the product of all zeroes and a[maxNeg].
3. The third case is when cntNeg is even. Then the answer part is the product of all the numbers in the array except all zeroes. The removed part is the product of all zeroes in the array (be careful in case cntNeg=0 and cntZero=n).

Below is the implementation of the above idea:  

// CPP program for maximum possible product
// with given array of numbers
#include <bits/stdc++.h>
using namespace std;

// Function that prints operations in each step
void MaximumProduct(int a[], int n)
{
    int cntneg = 0;
    int cntzero = 0;
    
    int used[n] = { 0 };
    int pos = -1;

    // count number of zeros and negative numbers
    for (int i = 0; i < n; ++i) {
        if (a[i] == 0) {
            used[i] = 1;
            cntzero++;
        }
        
        if (a[i] < 0) {
            cntneg++;
            
            // To get negative number which 
            // is nearest to zero, that is maximum 
            // negative number 
            if (pos == -1 || abs(a[pos]) > abs(a[i]))
                pos = i;
        }
    }
    
    // if number of negative number are odd then
    // remove negative number at position pos
    if (cntneg % 2 == 1)
        used[pos] = 1;

    // initial condition
    if (cntzero == n || (cntzero == n - 1 && 
                                    cntneg == 1)) {
        for (int i = 0; i < n - 1; ++i)
            cout << 1 << " " << i + 1 << " " 
                                << i + 2 << endl;
        return;
    }

    int lst = -1;
    for (int i = 0; i < n; ++i) {
        if (used[i]) {
            if (lst != -1)
                cout << 1 << " " << lst + 1 << " " 
                                << i + 1 << endl;
            lst = i;
        }
    }
    
    // perform second type operation
    if (lst != -1)
        cout << 2 << " " << lst + 1 << endl;

    lst = -1;
    
    // for remaining numbers
    for (int i = 0; i < n; ++i) {
        // if it is not removed yet
        if (!used[i]) {
            if (lst != -1)
                cout << 1 << " " << lst + 1 << " " 
                                    << i + 1 << endl;
            lst = i;
        }
    }
}

// Driver code
int main()
{
    int a[] = { 5, -2, 0, 1, -3 };

    int n = sizeof(a) / sizeof(a[0]);

    MaximumProduct(a, n);

    return 0;
}

// C program for maximum possible product
// with given array of numbers
#include <stdio.h>
#include <stdlib.h>

// Function that prints operations in each step
void MaximumProduct(int a[], int n)
{
  int cntneg = 0;
  int cntzero = 0;

  int used[n];
  //initializing the array as 0
  for (int i = 0; i < n; i++)
  {
    used[i] = 0;
  }
  int pos = -1;

  // count number of zeros and negative numbers
  for (int i = 0; i < n; ++i) {
    if (a[i] == 0) {
      used[i] = 1;
      cntzero++;
    }

    if (a[i] < 0) {
      cntneg++;

      // To get negative number which 
      // is nearest to zero, that is maximum 
      // negative number 
      if (pos == -1 || abs(a[pos]) > abs(a[i]))
        pos = i;
    }
  }

  // if number of negative number are odd then
  // remove negative number at position pos
  if (cntneg % 2 == 1)
    used[pos] = 1;

  // initial condition
  if (cntzero == n || (cntzero == n - 1 && 
                       cntneg == 1)) {
    for (int i = 0; i < n - 1; ++i)
      printf("%d %d %d\n", 1, i + 1, i + 2);
    return;
  }

  int lst = -1;
  for (int i = 0; i < n; ++i) {
    if (used[i]) {
      if (lst != -1)
        printf("%d %d %d\n", 1, lst+1, i+1);
      lst = i;
    }
  }

  // perform second type operation
  if (lst != -1)
    printf("%d %d\n", 2, lst + 1);


  lst = -1;

  // for remaining numbers
  for (int i = 0; i < n; ++i) {
    // if it is not removed yet
    if (!used[i]) {
      if (lst != -1)
        printf("%d %d %d\n", 1, lst + 1, i+1);

      lst = i;
    }
  }
}

// Driver code
int main()
{
  int a[] = { 5, -2, 0, 1, -3 };
  int n = sizeof(a) / sizeof(a[0]);
  MaximumProduct(a, n);
  return 0;
}

// This code is contributed by phalashi.

// Java program for maximum possible product
// with given array of numbers
class GFG {

// Function that prints operations in each step
static void MaximumProduct(int a[], int n) {
    int cntneg = 0;
    int cntzero = 0;

    int used[] = new int[n];
    int pos = -1;
    
    // count number of zeros and negative numbers
    for (int i = 0; i < n; ++i) {
        if (a[i] == 0)
        {
            used[i] = 1;
            cntzero++;
            
        }
        
        if (a[i] < 0) {
            cntneg++;
            
            // To get negative number which 
            // is nearest to zero, that is maximum 
            // negative number 
            if (pos == -1 || Math.abs(a[pos]) > Math.abs(a[i])) {
                pos = i;
                
            }
            
        }
        
    }
    
    // if number of negative number are odd then
    // remove negative number at position pos
    if (cntneg % 2 == 1) {
        used[pos] = 1;
        
    }
    
    // initial condition
    if (cntzero == n || (cntzero == n - 1 && cntneg == 1))
    {              
        for (int i = 0; i < n - 1; ++i) {
            System.out.println(1 + " " + (i + 1) + " "
                        + (i + 2));
            
        }
        return;
        
    }
    
    int lst = -1;
    for (int i = 0; i < n; ++i) {
        if (used[i] == 1) {
            if (lst != -1) {
                System.out.println(1 + " " + (lst + 1) + " "
                            + (i + 1));
                
            }
            lst = i;
            
        }
        
    }
    
    // perform second type operations
    if (lst != -1) {
        System.out.println(2 + " " + (lst + 1));
        
    }
    lst = -1;
    // for remaining numbers
    for (int i = 0; i < n; ++i)
    {
        // if it is not removed yet
        if (used[i] != 1) 
        {
            if (lst != -1) 
            {
                System.out.println(1 + " " + (lst + 1) + " "
                            + (i + 1));
                
            }
            lst = i;
        }
    }
    
}

// Driver code
public static void main(String[] args) 
{
    int a[] = {5, -2, 0, 1, -3};
    int n = a.length;
    MaximumProduct(a, n);
    
}
}

// This code is contributed by PrinciRaj1992

# Python3 program for maximum possible product
# with given array of numbers

# Function that prints operations 
# in each step
def MaximumProduct(a, n):
    cntneg = 0
    cntzero = 0
    
    used = [0] * n
    pos = -1

    # count number of zeros and 
    # negative numbers
    for i in range(n):
        if (a[i] == 0) :
            used[i] = 1
            cntzero += 1
        
        if (a[i] < 0):
            cntneg += 1
            
            # To get negative number which 
            # is nearest to zero, that is maximum 
            # negative number 
            if (pos == -1 or abs(a[pos]) > abs(a[i])):
                pos = i
    
    # if number of negative number are odd then
    # remove negative number at position pos
    if (cntneg % 2 == 1):
        used[pos] = 1

    # initial condition
    if (cntzero == n or (cntzero == n - 1 and
                         cntneg == 1)):
        for i in range(n - 1):
            print (1, " ", i + 1, " ", i + 2)
        return

    lst = -1
    for i in range(n) :
        if (used[i]) :
            if (lst != -1):
                print (1, " ", lst + 1, " ", i + 1)
            lst = i
    
    # perform second type operation
    if (lst != -1):
        print (2, " ", lst + 1)

    lst = -1
    
    # for remaining numbers
    for i in range( n) :
        
        # if it is not removed yet
        if (not used[i]) :
            if (lst != -1):
                print (1, " ", lst + 1, " ", i + 1)
            lst = i
    
# Driver code
if __name__ == "__main__":
    a = [ 5, -2, 0, 1, -3 ]

    n = len(a)

    MaximumProduct(a, n)

# This code is contributed by ita_c

// C# program for maximum possible product
// with given array of numbers
using System;

class GFG
{
    
// Function that prints 
// operations in each step
static void MaximumProduct(int []a, int n) 
{
    int cntneg = 0;
    int cntzero = 0;

    int []used = new int[n];
    int pos = -1;
    
    // count number of zeros 
    // and negative numbers
    for (int i = 0; i < n; ++i)
    {
        if (a[i] == 0)
        {
            used[i] = 1;
            cntzero++;
            
        }
        
        if (a[i] < 0) 
        {
            cntneg++;
            
            // To get negative number which 
            // is nearest to zero, that is
            //  maximum negative number 
            if (pos == -1 || Math.Abs(a[pos]) > 
                                Math.Abs(a[i]))
            {
                pos = i;
                
            }
            
        }
        
    }
    
    // if number of negative number are odd then
    // remove negative number at position pos
    if (cntneg % 2 == 1) 
    {
        used[pos] = 1;
        
    }
    
    // initial condition
    if (cntzero == n || (cntzero == n - 1 &&
                                cntneg == 1))
    {         
        for (int i = 0; i < n - 1; ++i) 
        {
            Console.WriteLine(1 + " " + (i + 1) + " "
                        + (i + 2));
        }
        return;
        
    }
    
    int lst = -1;
    for (int i = 0; i < n; ++i)
    {
        if (used[i] == 1) 
        {
            if (lst != -1)
            {
                Console.WriteLine(1 + " " + (lst + 1) + " "
                            + (i + 1));
            }
            lst = i;
            
        }
        
    }
    
    // perform second type operations
    if (lst != -1)
    {
        Console.WriteLine(2 + " " + (lst + 1));
        
    }
    lst = -1;
    
    // for remaining numbers
    for (int i = 0; i < n; ++i)
    {
        // if it is not removed yet
        if (used[i] != 1) 
        {
            if (lst != -1) 
            {
                Console.WriteLine(1 + " " + (lst + 1) + " "
                            + (i + 1));
            }
            lst = i;
        }
    }
    
}

    // Driver code
    static public void Main ()
    {
        int []a = {5, -2, 0, 1, -3};
        int n = a.Length;
        MaximumProduct(a, n);
    }
}

// This code is contributed by ajit

<script>

// JavaScript program for maximum possible product
// with given array of numbers

// Function that prints operations in each step
function MaximumProduct(a, n)
{
    let cntneg = 0;
    let cntzero = 0;
    
    let used = new Uint8Array(n);
    let pos = -1;

    // count number of zeros and negative numbers
    for (let i = 0; i < n; ++i) {
        if (a[i] == 0) {
            used[i] = 1;
            cntzero++;
        }
        
        if (a[i] < 0) {
            cntneg++;
            
            // To get negative number which
            // is nearest to zero, that is maximum
            // negative number
            if (pos == -1 || Math.abs(a[pos]) > Math.abs(a[i]))
                pos = i;
        }
    }
    
    // if number of negative number are odd then
    // remove negative number at position pos
    if (cntneg % 2 == 1)
        used[pos] = 1;

    // initial condition
    if (cntzero == n || (cntzero == n - 1 &&
                                    cntneg == 1)) {
        for (let i = 0; i < n - 1; ++i)
            document.write(1 + " " + (i + 1) + " "
                                + (i + 2) + "<br>");
        return;
    }

    let lst = -1;
    for (let i = 0; i < n; ++i) {
        if (used[i]) {
            if (lst != -1)
                document.write(1 + " " + (lst + 1) + " "
                                + (i + 1) + "<br>");
            lst = i;
        }
    }
    
    // perform second type operation
    if (lst != -1)
        document.write(2 + " " + (lst + 1) + "<br>");

    lst = -1;
    
    // for remaining numbers
    for (let i = 0; i < n; ++i) {
        // if it is not removed yet
        if (!used[i]) {
            if (lst != -1)
                document.write(1 + " " + (lst + 1) + " "
                                    + (i + 1) + "<br>");
            lst = i;
        }
    }
}

// Driver code

    let a = [ 5, -2, 0, 1, -3 ];

    let n = a.length;

    MaximumProduct(a, n);



// This code is contributed by Surbhi Tyagi.

</script>

2 3
1 1 2
1 2 4
1 4 5

Complexity Analysis:

• Time Complexity: O(n), where n represents the size of the given array.
• Auxiliary Space: O(n), where n represents the size of the given array.