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:
- 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 ith cell.
- 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:
- 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.
- 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].
- 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++
#include <bits/stdc++.h>
using namespace std;
void MaximumProduct( int a[], int n)
{
int cntneg = 0;
int cntzero = 0;
int used[n] = { 0 };
int pos = -1;
for ( int i = 0; i < n; ++i) {
if (a[i] == 0) {
used[i] = 1;
cntzero++;
}
if (a[i] < 0) {
cntneg++;
if (pos == -1 || abs (a[pos]) > abs (a[i]))
pos = i;
}
}
if (cntneg % 2 == 1)
used[pos] = 1;
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;
}
}
if (lst != -1)
cout << 2 << " " << lst + 1 << endl;
lst = -1;
for ( int i = 0; i < n; ++i) {
if (!used[i]) {
if (lst != -1)
cout << 1 << " " << lst + 1 << " "
<< i + 1 << endl;
lst = i;
}
}
}
int main()
{
int a[] = { 5, -2, 0, 1, -3 };
int n = sizeof (a) / sizeof (a[0]);
MaximumProduct(a, n);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
void MaximumProduct( int a[], int n)
{
int cntneg = 0;
int cntzero = 0;
int used[n];
for ( int i = 0; i < n; i++)
{
used[i] = 0;
}
int pos = -1;
for ( int i = 0; i < n; ++i) {
if (a[i] == 0) {
used[i] = 1;
cntzero++;
}
if (a[i] < 0) {
cntneg++;
if (pos == -1 || abs (a[pos]) > abs (a[i]))
pos = i;
}
}
if (cntneg % 2 == 1)
used[pos] = 1;
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;
}
}
if (lst != -1)
printf ( "%d %d\n" , 2, lst + 1);
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;
}
}
}
int main()
{
int a[] = { 5, -2, 0, 1, -3 };
int n = sizeof (a) / sizeof (a[0]);
MaximumProduct(a, n);
return 0;
}
|
Java
class GFG {
static void MaximumProduct( int a[], int n) {
int cntneg = 0 ;
int cntzero = 0 ;
int used[] = new int [n];
int pos = - 1 ;
for ( int i = 0 ; i < n; ++i) {
if (a[i] == 0 )
{
used[i] = 1 ;
cntzero++;
}
if (a[i] < 0 ) {
cntneg++;
if (pos == - 1 || Math.abs(a[pos]) > Math.abs(a[i])) {
pos = i;
}
}
}
if (cntneg % 2 == 1 ) {
used[pos] = 1 ;
}
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;
}
}
if (lst != - 1 ) {
System.out.println( 2 + " " + (lst + 1 ));
}
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;
}
}
}
public static void main(String[] args)
{
int a[] = { 5 , - 2 , 0 , 1 , - 3 };
int n = a.length;
MaximumProduct(a, n);
}
}
|
Python3
def MaximumProduct(a, n):
cntneg = 0
cntzero = 0
used = [ 0 ] * n
pos = - 1
for i in range (n):
if (a[i] = = 0 ) :
used[i] = 1
cntzero + = 1
if (a[i] < 0 ):
cntneg + = 1
if (pos = = - 1 or abs (a[pos]) > abs (a[i])):
pos = i
if (cntneg % 2 = = 1 ):
used[pos] = 1
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
if (lst ! = - 1 ):
print ( 2 , " " , lst + 1 )
lst = - 1
for i in range ( n) :
if ( not used[i]) :
if (lst ! = - 1 ):
print ( 1 , " " , lst + 1 , " " , i + 1 )
lst = i
if __name__ = = "__main__" :
a = [ 5 , - 2 , 0 , 1 , - 3 ]
n = len (a)
MaximumProduct(a, n)
|
C#
using System;
class GFG
{
static void MaximumProduct( int []a, int n)
{
int cntneg = 0;
int cntzero = 0;
int []used = new int [n];
int pos = -1;
for ( int i = 0; i < n; ++i)
{
if (a[i] == 0)
{
used[i] = 1;
cntzero++;
}
if (a[i] < 0)
{
cntneg++;
if (pos == -1 || Math.Abs(a[pos]) >
Math.Abs(a[i]))
{
pos = i;
}
}
}
if (cntneg % 2 == 1)
{
used[pos] = 1;
}
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;
}
}
if (lst != -1)
{
Console.WriteLine(2 + " " + (lst + 1));
}
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;
}
}
}
static public void Main ()
{
int []a = {5, -2, 0, 1, -3};
int n = a.Length;
MaximumProduct(a, n);
}
}
|
Javascript
<script>
function MaximumProduct(a, n)
{
let cntneg = 0;
let cntzero = 0;
let used = new Uint8Array(n);
let pos = -1;
for (let i = 0; i < n; ++i) {
if (a[i] == 0) {
used[i] = 1;
cntzero++;
}
if (a[i] < 0) {
cntneg++;
if (pos == -1 || Math.abs(a[pos]) > Math.abs(a[i]))
pos = i;
}
}
if (cntneg % 2 == 1)
used[pos] = 1;
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;
}
}
if (lst != -1)
document.write(2 + " " + (lst + 1) + "<br>" );
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;
}
}
}
let a = [ 5, -2, 0, 1, -3 ];
let n = a.length;
MaximumProduct(a, n);
</script>
|
Output
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.
Last Updated :
01 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...