负积的子序列数

给定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，负数元素的数量– 1)
• 可以为子序列选择任意数量的正元素，以维持负积。具有所有正元素的子序列不同组合的数量将为pow(2，正元素计数)

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

Python 3

# 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

输出：

8

时间复杂度： O(n)

另一种方法：
我们还可以通过从子序列总数中减去具有正子序列的子序列总数来计算具有负乘积的子序列数。
使用本文讨论的方法来查找具有阳性乘积的子序列的总数。