带负积的最长子阵列的长度

给定N个元素的数组arr [] 。任务是找到最长子阵列的长度，以使子阵列的乘积为负。如果没有可用的子数组，则打印-1。
例子：

Input: N = 6, arr[] = {-1, 2, 3, 2, 1, -4} 
Output: 5 
Explanation: 
In the example the subarray 
in range [1, 5] has product -12 which is negative, 
so the length is 5.
Input: N = 4, arr[] = {1, 2, 3, 2} 
Output: -1 
 

方法：

• 首先，检查数组的总积是否为负。如果数组的总积为负，则答案为N。
• 如果数组的总积不是负数，则表示它是正数。因此，我们的想法是从数组中找到一个负元素，以便排除该元素并比较数组两部分的长度，我们可以获得带有负乘积的子数组的最大长度。
• 很明显，

subarray with negative product will exist in the range [1, x) or (x, N], where 1 <= x <= N, and arr[x] is negative.

以下是上述方法的实现-

C++

// C++ implementation of the above approach
#include 
using namespace std;
 
// Function to find length of the
// longest subarray such that product
// of the subarray is negative
int maxLength(int a[], int n)
{
    int product = 1, len = -1;
 
    // Check if product of complete
    // array is negative
    for (int i = 0; i < n; i++)
        product *= a[i];
 
    // Total product is already
    // negative
    if (product < 0)
        return n;
 
    // Find an index i such the a[i]
    // is negative and compare length
    // of both halfs excluding a[i] to
    // find max length subarray
    for (int i = 0; i < n; i++) {
        if (a[i] < 0)
            len = max(len,
                      max(n - i - 1, i));
    }
 
    return len;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, -3, 2, 5, -6 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << maxLength(arr, N)
         << "\n";
 
    int arr1[] = { 1, 2, 3, 4 };
    N = sizeof(arr1) / sizeof(arr1[0]);
 
    cout << maxLength(arr1, N)
         << "\n";
 
    return 0;
}

Java

// Java implementation of the above approach
import java.util.Arrays;
 
class GFG{
     
// Function to find length of the
// longest subarray such that product
// of the subarray is negative
static int maxLength(int a[], int n)
{
    int product = 1, len = -1;
 
    // Check if product of complete
    // array is negative
    for(int i = 0; i < n; i++)
        product *= a[i];
 
    // Total product is already
    // negative
    if (product < 0)
        return n;
 
    // Find an index i such the a[i]
    // is negative and compare length
    // of both halfs excluding a[i] to
    // find max length subarray
    for(int i = 0; i < n; i++)
    {
        if (a[i] < 0)
            len = Math.max(len,
                  Math.max(n - i - 1, i));
    }
    return len;
}
     
// Driver code
public static void main (String[] args)
{
     
    // Given array arr[]
    int arr[] = new int[]{ 1, 2, -3,
                           2, 5, -6 };
    int N = arr.length;
     
    System.out.println(maxLength(arr, N));
     
    // Given array arr[]
    int arr1[] = new int[]{ 1, 2, 3, 4 };
    N = arr1.length;
 
    System.out.println(maxLength(arr1, N));
}
}
 
// This code is contributed by Pratima Pandey

Python3

# Python3 implementation of the above approach
# Function to find length of the
# longest subarray such that product
# of the subarray is negative
def maxLength(a, n):
    product = 1
    length = -1
 
    # Check if product of complete
    # array is negative
    for i in range (n):
        product *= a[i]
 
    # Total product is already
    # negative
    if (product < 0):
        return n
 
    # Find an index i such the a[i]
    # is negative and compare length
    # of both halfs excluding a[i] to
    # find max length subarray
    for i in range (n):
        if (a[i] < 0):
            length = max(length,
                         max(n - i - 1, i))
 
    return length
 
# Driver Code
if __name__ == "__main__": 
    arr = [1, 2, -3, 2, 5, -6]
    N = len(arr)
    print (maxLength(arr, N))
    arr1 = [1, 2, 3, 4]
    N = len(arr1)
    print (maxLength(arr1, N))
          
# This code is contributed by Chitranayal

C#

// C# implementation of the above approach
using System;
 
class GFG{
     
// Function to find length of the
// longest subarray such that product
// of the subarray is negative
static int maxLength(int []a, int n)
{
    int product = 1, len = -1;
 
    // Check if product of complete
    // array is negative
    for(int i = 0; i < n; i++)
        product *= a[i];
 
    // Total product is already
    // negative
    if (product < 0)
        return n;
 
    // Find an index i such the a[i]
    // is negative and compare length
    // of both halfs excluding a[i] to
    // find max length subarray
    for(int i = 0; i < n; i++)
    {
        if (a[i] < 0)
            len = Math.Max(len,
                  Math.Max(n - i - 1, i));
    }
    return len;
}
     
// Driver code
public static void Main(String[] args)
{
     
    // Given array []arr
    int []arr = new int[]{ 1, 2, -3,
                           2, 5, -6 };
    int N = arr.Length;
     
    Console.WriteLine(maxLength(arr, N));
     
    // Given array []arr
    int []arr1 = new int[]{ 1, 2, 3, 4 };
    N = arr1.Length;
 
    Console.WriteLine(maxLength(arr1, N));
}
}
 
// This code is contributed by Amit Katiyar

输出：

5
-1

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