数组的最小乘积子集的Java程序

给定一个数组 a，我们必须找到数组中存在的元素子集的最小乘积。最小乘积也可以是单个元素。

例子：

Input : a[] = { -1, -1, -2, 4, 3 }
Output : -24
Explanation : Minimum product will be ( -2 * -1 * -1 * 4 * 3 ) = -24

Input : a[] = { -1, 0 }
Output : -1
Explanation : -1(single element) is minimum product possible
 
Input : a[] = { 0, 0, 0 }
Output : 0

一个简单的解决方案是生成所有子集，找到每个子集的乘积并返回最小乘积。
更好的解决方案是使用以下事实。

1. 如果有偶数个负数且没有零，则结果是除最大值负数之外的所有负数的乘积。
2. 如果有奇数个负数并且没有零，则结果只是所有的乘积。
3. 如果有零和正数，没有负数，则结果为 0。例外情况是当没有负数且所有其他元素为正数时，我们的结果应该是第一个最小正数。

Java

// Java program to find maximum product of
// a subset.
class GFG {
  
    static int minProductSubset(int a[], int n)
    {
        if (n == 1)
            return a[0];
  
        // Find count of negative numbers,
        // count of zeros, maximum valued
        // negative number, minimum valued
        // positive number and product of
        // non-zero numbers
        int negmax = Integer.MIN_VALUE;
        int posmin = Integer.MAX_VALUE;
        int count_neg = 0, count_zero = 0;
        int product = 1;
  
        for (int i = 0; i < n; i++) {
  
            // if number is zero,count it
            // but dont multiply
            if (a[i] == 0) {
                count_zero++;
                continue;
            }
  
            // count the negative numbers
            // and find the max negative number
            if (a[i] < 0) {
                count_neg++;
                negmax = Math.max(negmax, a[i]);
            }
  
            // find the minimum positive number
            if (a[i] > 0 && a[i] < posmin)
                posmin = a[i];
  
            product *= a[i];
        }
  
        // if there are all zeroes
        // or zero is present but no
        // negative number is present
        if (count_zero == n
            || (count_neg == 0 && count_zero > 0))
            return 0;
  
        // If there are all positive
        if (count_neg == 0)
            return posmin;
  
        // If there are even number except
        // zero of negative numbers
        if (count_neg % 2 == 0 && count_neg != 0) {
  
            // Otherwise result is product of
            // all non-zeros divided by maximum
            // valued negative.
            product = product / negmax;
        }
  
        return product;
    }
  
    // main function
    public static void main(String[] args)
    {
  
        int a[] = { -1, -1, -2, 4, 3 };
        int n = 5;
  
        System.out.println(minProductSubset(a, n));
    }
}
  
// This code is contributed by Arnab Kundu.

输出：

-24

时间复杂度： O(n)
辅助空间： O(1)

有关更多详细信息，请参阅有关数组的最小产品子集的完整文章！