Maximum Subarray Length with Divisibility and Sum Constraint

Given two integers N, K, and two arrays A and B each of size N, such that for every index i, A[i] lies between [1, 10⁴] and B[i] lies between [1, 10⁹]. Find the maximum subarray length [l, r] such that:

• For each index i which lies between [l, r-1], B[i] is divisible by B[i+1] and
• The sum of all the elements in the range [l, r] in array A<= K.

Examples:

Input: N = 5, A[] = {3, 2, 4, 1, 8}, B[] = {4, 4, 2, 4, 1}, K = 12
Output: 3
Explanation: A valid and max length subarray can be l = 0, r = 2.

Input: N = 4, A[] = {5, 4, 1, 2}, B[] = {6, 2, 3, 1}, K = 8
Output: 2
Explanation: A valid and max length subarray can be l = 2, r = 3.

Approach: To solve the problem follow the below idea:

The problem can be solved by maintaining a sliding window using two pointers. At every index, we will increase the length of the sliding window and check whether the conditions are getting fulfilled on both arrays A and B. If the divisibility check of subarray B fails, then it means that we need to start with a new sliding window from this index. If the sum of subarray A becomes greater than K, we start reducing the size of the window by moving the start pointer forward. After satisfying both the conditions, update the answer.

Steps to solve the problem:

• Maintain 2 pointers, start and end to keep track of the sliding window.
• Initialize the sum of subarray sum = 0.
• Maintain a variable ans to keep track of the length of the longest valid sliding window encountered so far.
• Increment the length of the sliding window by incrementing end by 1.
• Check for the divisibility condition in subarray B:
  • If the divisibility check fails, start a new subarray from this index.
  • If the divisibility check passes, check if the sum of subarray A is less than K.
    • If sum <= K, update ans if the window's length is greater than ans.
    • If sum > K, decrease the window's length by moving the start pointer until we have sum <= K and then update ans if the window's length is greater than ans.
• After iterating over the whole array, return and.

Below is the implementation for the above approach:

3

Time Complexity: O(N), where N is the size of array A[] and B[]
Auxiliary Space: O(1)