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 equlas to j), replace the value of a[j] with a[i]*a[j] and remove the number from the ith cell.
  2. Choose some position i and remove the number from the ith 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:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 reamining 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 reamining 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 reamining 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 reamining 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

chevron_right


Output:

2 3
1 1 2
1 2 4
1 4 5

Time Complexity:O(n)



My Personal Notes arrow_drop_up

pawanasipugmailcom

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.