具有负积的子序列数

给定一个由N 个整数组成的数组arr[] ，任务是找到该数组中所有具有负乘积的子序列的计数。

例子：

Input: arr[] = {1, -5, -6} 
Output: 4 
Explanation 
{-5}, {-6}, {1, -5} and {1, -6} are the only possible subsequences

Input: arr[] = {2, 3, 1} 
Output: 0 
Explanation 
There is no such possible subsequence with negative product 
 

天真的方法：
生成数组的所有子序列并计算所有子序列的乘积。如果乘积为负，则将计数加 1。

有效的方法：

• 计算数组中正负元素的个数
• 可以为子序列选择奇数个负元素以保持负积。具有奇数个负元素的子序列的不同组合的数量将为pow(2, count of negative elements – 1)
• 可以为子序列选择任意数量的正元素以保持负积。具有所有正元素的子序列的不同组合的数量将为pow(2, count of positive elements)

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the count of all
// the subsequences with negative product
int cntSubSeq(int arr[], int n)
{
    // To store the count of positive
    // elements in the array
    int pos_count = 0;
 
    // To store the count of negative
    // elements in the array
    int neg_count = 0;
 
    int result;
 
    for (int i = 0; i < n; i++) {
 
        // If the current element
        // is positive
        if (arr[i] > 0)
            pos_count++;
 
        // If the current element
        // is negative
        if (arr[i] < 0)
            neg_count++;
    }
 
    // For all the positive
    // elements of the array
    result = pow(2, pos_count);
 
    // For all the negative
    // elements of the array
    if (neg_count > 0)
        result *= pow(2, neg_count - 1);
    else
        result = 0;
 
    return result;
}
 
// Driver code
int main()
{
    int arr[] = { 3, -4, -1, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << cntSubSeq(arr, n);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to return the count of all
// the subsequences with negative product
static int cntSubSeq(int arr[], int n)
{
    // To store the count of positive
    // elements in the array
    int pos_count = 0;
 
    // To store the count of negative
    // elements in the array
    int neg_count = 0;
 
    int result;
 
    for (int i = 0; i < n; i++)
    {
 
        // If the current element
        // is positive
        if (arr[i] > 0)
            pos_count++;
 
        // If the current element
        // is negative
        if (arr[i] < 0)
            neg_count++;
    }
 
    // For all the positive
    // elements of the array
    result = (int) Math.pow(2, pos_count);
 
    // For all the negative
    // elements of the array
    if (neg_count > 0)
        result *= Math.pow(2, neg_count - 1);
    else
        result = 0 ;
 
    return result;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 3,-4, -1, 6 };
    int n = arr.length;
 
    System.out.print(cntSubSeq(arr, n));
}
}
 
// This code is contributed by ANKITKUMAR34

Python3

# Python 3 implementation of the approach
import math
 
# Function to return the count of all
# the subsequences with negative product
def cntSubSeq(arr, n):
 
    # To store the count of positive
    # elements in the array
    pos_count = 0;
 
    # To store the count of negative
    # elements in the array
    neg_count = 0
 
    for i in range (n):
 
        # If the current element
        # is positive
        if (arr[i] > 0) :
            pos_count += 1
 
        # If the current element
        # is negative
        if (arr[i] < 0):
            neg_count += 1
 
    # For all the positive
    # elements of the array
    result = int(math.pow(2, pos_count))
 
    # For all the negative
    # elements of the array
    if (neg_count > 0):
        result *= int(math.pow(2, neg_count - 1))
    else:
        result = 0
 
    return result
 
# Driver code
arr = [ 2, -3, -1, 4 ]
n = len (arr);
 
print (cntSubSeq(arr, n))

C#

// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the count of all
// the subsequences with negative product
static int cntSubSeq(int []arr, int n)
{
    // To store the count of positive
    // elements in the array
    int pos_count = 0;
 
    // To store the count of negative
    // elements in the array
    int neg_count = 0;
 
    int result;
 
    for (int i = 0; i < n; i++)
    {
 
        // If the current element
        // is positive
        if (arr[i] > 0)
            pos_count++;
 
        // If the current element
        // is negative
        if (arr[i] < 0)
            neg_count++;
    }
 
    // For all the positive
    // elements of the array
    result = (int) Math.Pow(2, pos_count);
 
    // For all the negative
    // elements of the array
    if (neg_count > 0)
        result *= (int)Math.Pow(2, neg_count - 1);
    else
        result = 0 ;
 
    return result;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 3,-4, -1, 6 };
    int n = arr.Length;
 
    Console.Write(cntSubSeq(arr, n));
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// Javascript implementation of the approach
 
// Function to return the count of all
// the subsequences with negative product
function cntSubSeq(arr, n)
{
     
    // To store the count of positive
    // elements in the array
    var pos_count = 0;
 
    // To store the count of negative
    // elements in the array
    var neg_count = 0;
 
    var result;
 
    for(var i = 0; i < n; i++)
    {
         
        // If the current element
        // is positive
        if (arr[i] > 0)
            pos_count++;
 
        // If the current element
        // is negative
        if (arr[i] < 0)
            neg_count++;
    }
 
    // For all the positive
    // elements of the array
    result = Math.pow(2, pos_count);
 
    // For all the negative
    // elements of the array
    if (neg_count > 0)
        result *= Math.pow(2, neg_count - 1);
    else
        result = 0;
 
    return result;
}
 
// Driver code
var arr = [ 3, -4, -1, 6 ];
var n = arr.length;
 
document.write(cntSubSeq(arr, n));
 
// This code is contributed by noob2000
 

输出：

8

时间复杂度： O(n)
另一种方法：
我们还可以通过从子序列总数中减去具有正子序列的子序列总数来计算具有负乘积的子序列数。
使用本文中讨论的方法查找具有正乘积的子序列总数。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。