找出乘积小于或等于 K 的所有可能子数组

给定一个 数组arr[] ，任务是打印所有可能的子数组，其元素的乘积小于或等于K 。

Input: arr[] = {2, 1, 3, 4, 5, 6, 2}, K = 10 
Output: [[2], [1], [2, 1], [3], [1, 3], [2, 1, 3], [4], [5], [6], [2]] 
Explanation: 
All possible subarrays having product ≤ K are {2}, {1}, {2, 1}, {3}, {1, 3}, {2, 1, 3}, {4}, {5}, {6}, {2}.

Input: arr[] = {2, 7, 1, 4}, K = 7 
Output: [[2], [7], [1], [7, 1], [4], [1, 4]]

朴素的方法：解决问题的最简单的方法是从给定的数组中生成所有可能的子数组，对于每个子数组，检查其乘积是否小于或等于K并相应地打印。

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

有效的方法：上述方法可以通过观察来优化：

If the product of all the elements of a subarray is less than or equal to K, then all the subarrays possible from this subarray also has product less than or equal to K. Therefore, these subarrays need to be included in the answer as well.

请按照以下步骤解决问题：

1. 初始化指向数组第一个索引的指针开始。
2. 迭代数组并继续计算数组元素的乘积并将其存储在变量中，例如multi 。
3. 如果 multi 超过 K：继续将multi除以arr[start]并继续递增start直到multi减少到≤ K 。
4. 如果 multi ≤ K：从当前索引迭代到start ，并将子数组存储在 Arraylist 中。
5. 最后，一旦生成了所有子数组，打印包含获得的所有子数组的 Arraylist 。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
#include
using namespace std;
 
// Function to return all possible
// subarrays having product less
// than or equal to K
vector> maxSubArray(int arr[], int n,
                                int K)
{
     
    // Store the required subarrays
    vector> solution;
     
    // Stores the product of
    // current subarray
    int multi = 1;
     
    // Stores the starting index
    // of the current subarray
    int start = 0;
     
    // Check for empty array
    if (n <= 1 || K < 0)
    {
        return solution;
    }
     
    // Iterate over the array
    for(int i = 0; i < n; i++)
    {
         
        // Calculate product
        multi = multi * arr[i];
     
        // If product exceeds K
        while (multi > K)
        {
             
            // Reduce product
            multi = multi / arr[start];
     
            // Increase starting index
            // of current subarray
            start++;
        }
     
        // Stores the subarray elements
        vector list;
     
        // Store the subarray elements
        for(int j = i; j >= start; j--)
        {
            list.insert(list.begin(), arr[j]);
     
            // Add the subarrays
            // to the list
            solution.push_back(list);
        }
    }
     
    // Return the final
    // list of subarrays
    return solution;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 7, 1, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int K = 7;
     
    vector> v = maxSubArray(arr, n, K);
    cout << "[";
     
    bool first = true;
    for(auto x : v)
    {
        if (!first)
        {
            cout << ", ";
        }
        else
        {
            first = false;
        }
        cout << "[";
         
        bool ff = true;
        for(int y : x)
        {
            if (!ff)
            {
                cout << ", ";
            }
            else
            {
                ff = false;
            }
            cout << y;
        }
        cout << "]";
    }
    cout << "]";
     
    return 0;
}
 
// This code is contributed by rutvik_56

Java

// Java Program to implement
// the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Function to return all possible
    // subarrays having product less
    // than or equal to K
    public static List > maxSubArray(
        int[] arr, int K)
    {
 
        // Store the required subarrays
        List > solution
            = new ArrayList<>();
 
        // Stores the product of
        // current subarray
        int multi = 1;
 
        // Stores the starting index
        // of the current subarray
        int start = 0;
 
        // Check for empty array
        if (arr.length <= 1 || K < 0) {
            return new ArrayList<>();
        }
 
        // Iterate over the array
        for (int i = 0; i < arr.length; i++) {
 
            // Calculate product
            multi = multi * arr[i];
 
            // If product exceeds K
            while (multi > K) {
 
                // Reduce product
                multi = multi / arr[start];
 
                // Increase starting index
                // of current subarray
                start++;
            }
 
            // Stores the subarray elements
            List list
                = new ArrayList<>();
 
            // Store the subarray elements
            for (int j = i; j >= start; j--) {
 
                list.add(0, arr[j]);
 
                // Add the subarrays
                // to the list
                solution.add(
                    new ArrayList<>(list));
            }
        }
 
        // Return the final
        // list of subarrays
        return solution;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 2, 7, 1, 4 };
        int K = 7;
 
        System.out.println(maxSubArray(arr, K));
    }
}

Python3

# Python3 program to implement
# the above approach
  
# Function to return all possible
# subarrays having product less
# than or equal to K
def maxSubArray(arr, n, K):
      
    # Store the required subarrays
    solution = []
      
    # Stores the product of
    # current subarray
    multi = 1
      
    # Stores the starting index
    # of the current subarray
    start = 0
      
    # Check for empty array
    if (n <= 1 or K < 0):
        return solution
     
    # Iterate over the array
    for i in range(n):
         
        # Calculate product
        multi = multi * arr[i]
      
        # If product exceeds K
        while (multi > K):
             
            # Reduce product
            multi = multi // arr[start]
      
            # Increase starting index
            # of current subarray
            start += 1
      
        # Stores the subarray elements
        li = []
         
        j = i
         
        # Store the subarray elements
        while(j >= start):       
            li.insert(0, arr[j])
      
            # Add the subarrays
            # to the li
            solution.append(list(li))
            j -= 1
      
    # Return the final
    # li of subarrays
    return solution
     
# Driver Code
if __name__=='__main__':
     
    arr = [ 2, 7, 1, 4 ]
    n = len(arr)
    K = 7
      
    v = maxSubArray(arr, n, K)
     
    print(v)
      
# This code is contributed by pratham76

C#

// C# Program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to return all possible
// subarrays having product less
// than or equal to K
public static List> maxSubArray(int[] arr,
                                          int K)
{
  // Store the required subarrays
  List > solution = new List>();
 
  // Stores the product of
  // current subarray
  int multi = 1;
 
  // Stores the starting index
  // of the current subarray
  int start = 0;
 
  // Check for empty array
  if (arr.Length <= 1 || K < 0)
  {
    return new List>();
  }
 
  // Iterate over the array
  for (int i = 0; i < arr.Length; i++)
  {
    // Calculate product
    multi = multi * arr[i];
 
    // If product exceeds K
    while (multi > K)
    {
      // Reduce product
      multi = multi / arr[start];
 
      // Increase starting index
      // of current subarray
      start++;
    }
 
    // Stores the subarray elements
    List list = new List();
 
    // Store the subarray elements
    for (int j = i; j >= start; j--)
    {
      list.Insert(0, arr[j]);
 
      // Add the subarrays
      // to the list
      solution.Add(new List(list));
    }
  }
 
  // Return the final
  // list of subarrays
  return solution;
}
 
// Driver Code
public static void Main(String[] args)
{
  int[] arr = {2, 7, 1, 4};
  int K = 7;
  List > list = maxSubArray(arr, K);
  foreach(List i in list)
  {
    Console.Write("[");
    foreach(int j in i)
    {
      Console.Write(j);
      if(i.Count > 1)
        Console.Write(",");
    }
    Console.Write("]");
  }
}
}
 
// This code is contributed by 29AjayKumar

Javascript

// js program to implement
// the above approach
 
 
// Function to return all possible
// subarrays having product less
// than or equal to K
function maxSubArray(arr,  n, K)
{
     
    // Store the required subarrays
    let solution = [];
     
    // Stores the product of
    // current subarray
    let multi = 1;
     
    // Stores the starting index
    // of the current subarray
    let start = 0;
     
    // Check for empty array
    if (n <= 1 || K < 0)
    {
        return solution;
    }
     
    // Iterate over the array
    for(let i = 0; i < n; i++)
    {
         
        // Calculate product
        multi = multi * arr[i];
     
        // If product exceeds K
        while (multi > K)
        {
             
            // Reduce product
            multi =Math.floor( multi / arr[start]);
     
            // Increase starting index
            // of current subarray
            start++;
        }
     
        // Stores the subarray elements
        let list = [];
     
        // Store the subarray elements
        for(let j = i; j >= start; j--)
        {
            list.unshift(arr[j]);
     
            // Add the subarrays
            // to the list
            solution.push(list);
        }
    }
     
    // Return the final
    // list of subarrays
    return solution;
}
 
// Driver Code
    let arr = [ 2, 7, 1, 4 ];
    let n = arr.length;
    let K = 7;
     
    let v = maxSubArray(arr, n, K);
    document.write( "[");
     
    let first = true;
    for(let x=0;x< v.length;x++)
    {
        if (!first)
        {
            document.write(", ");
        }
        else
        {
            first = false;
        }
        document.write( "[");
         
        let ff = true;
        for(let y =0;y<v[x].length;y++)
        {
            if (!ff)
            {
                document.write(", ");
            }
            else
            {
                ff = false;
            }
            document.write(v[x][y]);
        }
        document.write("]");
    }
    document.write( "]");
 

输出：

[[2], [7], [1], [7, 1], [4], [1, 4]]

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live