Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Minimum product subarray of size K including negative integers

Given an array arr[] of length N, the task is to find the minimum product of subarray of size K of an array including negative integers.

Example:

Input: arr = [2, 3, -1, -5, 4, 0], K = 3
Output: -6
Explanation: The product of the subarray {2, 3, -1} is -6 which is the minimum possible.

Input: arr = [-2, -4, 0, 1, 5, -6, 9], K =4
Output: -270
Explanation: The product of the subarray {1, 5, -6, 9} is -270 which is the minimum possible.

If the array consists of only positive numbers the problem can be efficiently solved using only the sliding window technique as discussed here.

Approach: The given problem can be solved using the two-pointers technique and the sliding window approach. Below steps can be followed to solve the problem:

• Iterate the array arr till K – 1 and multiply every non-zero number to find the product and also count the number of zeros in the subarray.
• Iterate the array arr from K till the end of the array and at every iteration:
• If the current element is not a zero then multiply it to the product or else increment the count of zeros
• If the element to the left of the current sliding window is not a zero then divide the product by that element or else reduce the count of zeros
• If the number of zeros in the sliding window is 0 then update the result with the current product or else update it with zero
• Return the result res.

Below is the implementation of the above approach:

## C++

 `// C++ implementation for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum``// product of subarray of size K``int` `minProdK(vector<``int``>& arr, ``int` `K)``{` `    ``// Initialize prod to 1``    ``// and zeros to 0``    ``int` `prod = 1, zeros = 0;` `    ``// Initialize length of the array``    ``int` `N = arr.size();` `    ``// Iterate the array arr till K - 1``    ``for` `(``int` `i = 0; i < K; i++) {` `        ``// If current element is 0``        ``// then increment zeros``        ``if` `(arr[i] == 0)``            ``zeros++;` `        ``// Else multiply current``        ``// element to prod``        ``else``            ``prod *= arr[i];``    ``}` `    ``// Initialize prod to 0 if zeros > 0``    ``// else to prod``    ``int` `res = zeros == 0 ? prod : 0;` `    ``// Iterate the array arr``    ``// from K till the end``    ``for` `(``int` `right = K; right < N; right++) {` `        ``// If current element is 0``        ``// then increment zeros``        ``if` `(arr[right] == 0)``            ``zeros++;` `        ``// Else multiply arr[right]``        ``// to prod``        ``else``            ``prod *= arr[right];` `        ``// If leftmost element in``        ``// the sliding window is 0``        ``// then decrement zeros``        ``if` `(arr[right - K] == 0)``            ``zeros--;` `        ``// Else divide prod by arr[right-K]``        ``else``            ``prod /= arr[right - K];` `        ``// If zeros == 0 then update``        ``// res by taking minimum value``        ``// of res and prod``        ``if` `(zeros == 0)``            ``res = min(res, prod);` `        ``// If zeros > 0 and res > 0``        ``// then initialize res to 0``        ``else` `if` `(res > 0)``            ``res = 0;``    ``}` `    ``// Return the answer as res``    ``return` `res;``}` `// Driver code``int` `main()``{` `    ``// Initialize the array``    ``vector<``int``> arr = { 2, 3, -1, -5, 4, 0 };` `    ``// Initialize the value of K``    ``int` `K = 3;` `    ``// Call the function and``    ``// print the result``    ``cout << minProdK(arr, K);` `    ``return` `0;``}` `    ``// This code is contributed by rakeshsahni`

## Java

 `// Java implementation for the above approach` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the minimum``    ``// product of subarray of size K``    ``public` `static` `int` `minProdK(``        ``int` `arr[], ``int` `K)``    ``{` `        ``// Initialize prod to 1``        ``// and zeros to 0``        ``int` `prod = ``1``, zeros = ``0``;` `        ``// Initialize length of the array``        ``int` `N = arr.length;` `        ``// Iterate the array arr till K - 1``        ``for` `(``int` `i = ``0``; i < K; i++) {` `            ``// If current element is 0``            ``// then increment zeros``            ``if` `(arr[i] == ``0``)``                ``zeros++;` `            ``// Else multiply current``            ``// element to prod``            ``else``                ``prod *= arr[i];``        ``}` `        ``// Initialize prod to 0 if zeros > 0``        ``// else to prod``        ``int` `res = zeros == ``0` `? prod : ``0``;` `        ``// Iterate the array arr``        ``// from K till the end``        ``for` `(``int` `right = K; right < N; right++) {` `            ``// If current element is 0``            ``// then increment zeros``            ``if` `(arr[right] == ``0``)``                ``zeros++;` `            ``// Else multiply arr[right]``            ``// to prod``            ``else``                ``prod *= arr[right];` `            ``// If leftmost element in``            ``// the sliding window is 0``            ``// then decrement zeros``            ``if` `(arr[right - K] == ``0``)``                ``zeros--;` `            ``// Else divide prod by arr[right-K]``            ``else``                ``prod /= arr[right - K];` `            ``// If zeros == 0 then update``            ``// res by taking minimum value``            ``// of res and prod``            ``if` `(zeros == ``0``)``                ``res = Math.min(res, prod);` `            ``// If zeros > 0 and res > 0``            ``// then initialize res to 0``            ``else` `if` `(res > ``0``)``                ``res = ``0``;``        ``}` `        ``// Return the answer as res``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Initialize the array``        ``int``[] arr = { ``2``, ``3``, -``1``, -``5``, ``4``, ``0` `};` `        ``// Initialize the value of K``        ``int` `K = ``3``;` `        ``// Call the function and``        ``// print the result``        ``System.out.println(minProdK(arr, K));``    ``}``}`

## Python3

 `# Python 3 implementation for the above approach` `# Function to find the minimum``# product of subarray of size K``def` `minProdK(arr, K):` `    ``# Initialize prod to 1``    ``# and zeros to 0``    ``prod ``=` `1``    ``zeros ``=` `0` `    ``# Initialize length of the array``    ``N ``=` `len``(arr)` `    ``# Iterate the array arr till K - 1``    ``for` `i ``in` `range``(K):``        ``# If current element is 0``        ``# then increment zeros``        ``if` `(arr[i] ``=``=` `0``):``            ``zeros ``+``=` `1` `        ``# Else multiply current``        ``# element to prod``        ``else``:``            ``prod ``*``=` `arr[i]` `    ``# Initialize prod to 0 if zeros > 0``    ``# else to prod``    ``if` `zeros ``=``=` `0``:``        ``res ``=` `prod``    ``else``:``        ``res ``=` `0` `    ``# Iterate the array arr``    ``# from K till the end``    ``for` `right ``in` `range``(K,  N):``      ` `        ``# If current element is 0``        ``# then increment zeros``        ``if` `(arr[right] ``=``=` `0``):``            ``zeros ``+``=` `1` `        ``# Else multiply arr[right]``        ``# to prod``        ``else``:``            ``prod ``*``=` `arr[right]` `        ``# If leftmost element in``        ``# the sliding window is 0``        ``# then decrement zeros``        ``if` `(arr[right ``-` `K] ``=``=` `0``):``            ``zeros ``-``=` `1` `        ``# Else divide prod by arr[right-K]``        ``else``:``            ``prod ``/``/``=` `arr[right ``-` `K]` `        ``# If zeros == 0 then update``        ``# res by taking minimum value``        ``# of res and prod``        ``if` `(zeros ``=``=` `0``):``            ``res ``=` `min``(res, prod)` `        ``# If zeros > 0 and res > 0``        ``# then initialize res to 0``        ``elif` `(res > ``0``):``            ``res ``=` `0` `    ``# Return the answer as res``    ``return` `res` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Initialize the array``    ``arr ``=` `[``2``, ``3``, ``-``1``, ``-``5``, ``4``, ``0``]` `    ``# Initialize the value of K``    ``K ``=` `3` `    ``# Call the function and``    ``# print the result``    ``print``(minProdK(arr, K))` `    ``# This code is contributed by ukasp.`

## C#

 `// C# implementation for the above approach``using` `System;``class` `GFG``{``    ``// Function to find the minimum``    ``// product of subarray of size K``    ``public` `static` `int` `minProdK(``        ``int` `[]arr, ``int` `K)``    ``{` `        ``// Initialize prod to 1``        ``// and zeros to 0``        ``int` `prod = 1, zeros = 0;` `        ``// Initialize length of the array``        ``int` `N = arr.Length;` `        ``// Iterate the array arr till K - 1``        ``for` `(``int` `i = 0; i < K; i++) {` `            ``// If current element is 0``            ``// then increment zeros``            ``if` `(arr[i] == 0)``                ``zeros++;` `            ``// Else multiply current``            ``// element to prod``            ``else``                ``prod *= arr[i];``        ``}` `        ``// Initialize prod to 0 if zeros > 0``        ``// else to prod``        ``int` `res = zeros == 0 ? prod : 0;` `        ``// Iterate the array arr``        ``// from K till the end``        ``for` `(``int` `right = K; right < N; right++) {` `            ``// If current element is 0``            ``// then increment zeros``            ``if` `(arr[right] == 0)``                ``zeros++;` `            ``// Else multiply arr[right]``            ``// to prod``            ``else``                ``prod *= arr[right];` `            ``// If leftmost element in``            ``// the sliding window is 0``            ``// then decrement zeros``            ``if` `(arr[right - K] == 0)``                ``zeros--;` `            ``// Else divide prod by arr[right-K]``            ``else``                ``prod /= arr[right - K];` `            ``// If zeros == 0 then update``            ``// res by taking minimum value``            ``// of res and prod``            ``if` `(zeros == 0)``                ``res = Math.Min(res, prod);` `            ``// If zeros > 0 and res > 0``            ``// then initialize res to 0``            ``else` `if` `(res > 0)``                ``res = 0;``        ``}` `        ``// Return the answer as res``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``// Initialize the array``        ``int``[] arr = { 2, 3, -1, -5, 4, 0 };` `        ``// Initialize the value of K``        ``int` `K = 3;` `        ``// Call the function and``        ``// print the result``        ``Console.Write(minProdK(arr, K));``    ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`-6`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up