Maximum length of same indexed subarrays from two given arrays satisfying the given condition

// Java program for the above approach

import java.io.*;
import java.util.*;
class GFG {

    // Stores the segment tree node values
    static int seg[];

    // Function to find maximum length
    // of subarray such that sum of
    // maximum element in subarray in brr[] and
    // sum of subarray in arr[] * K is at most C
    public static int maxLength(
        int a[], int b[], int n, int c)
    {
        // Base Case
        if (n == 0)
            return 0;

        // Let maximum length be 0
        int max_length = 0;

        int low = 0, high = n;

        // Perform Binary search
        while (low <= high) {

            // Find mid value
            int mid = low + (high - low) / 2;

            // Check if the current mid
            // satisfy the given condition
            if (possible(a, b, n, c, mid)) {

                // If yes, then store length
                max_length = mid;
                low = mid + 1;
            }

            // Otherwise
            else
                high = mid - 1;
        }

        // Return maximum length stored
        return max_length;
    }

    // Function to check if it is possible
    // to have such a subarray of length K
    public static boolean possible(
        int a[], int b[], int n,
        int c, int k)
    {
        int sum = 0;

        // Check for first window of size K
        for (int i = 0; i < k; i++) {
            sum += a[i];
        }

        // Calculate the total cost and
        // check if less than equal to c
        int total_cost
            = sum * k + getMax(b, 0, n - 1,
                               0, k - 1, 0);

        // If it satisfy the condition
        if (total_cost <= c)
            return true;

        // Find the sum of current subarray
        // and calculate total cost
        for (int i = k; i < n; i++) {

            // Include the new element
            // of current subarray
            sum += a[i];

            // Discard the element
            // of last subarray
            sum -= a[i - k];

            // Calculate total cost
            // and check <=c
            total_cost
                = sum * k
                  + getMax(b, 0, n - 1,
                           i - k + 1, i, 0);

            // If possible, then
            // return true
            if (total_cost <= c)
                return true;
        }

        // If it is not possible
        return false;
    }

    // Function that builds segment Tree
    public static void build(
        int b[], int index, int s, int e)
    {
        // If there is only one element
        if (s == e) {
            seg[index] = b[s];
            return;
        }

        // Find the value of mid
        int mid = s + (e - s) / 2;

        // Build left and right parts
        // of segment tree recursively
        build(b, 2 * index + 1, s, mid);
        build(b, 2 * index + 2, mid + 1, e);

        // Update the value at current
        // index
        seg[index] = Math.max(
            seg[2 * index + 1],
            seg[2 * index + 2]);
    }

    // Function to find maximum element
    // in the given range
    public static int getMax(
        int b[], int ss, int se, int qs,
        int qe, int index)
    {
        // If the query is out of bounds
        if (se < qs || ss > qe)
            return Integer.MIN_VALUE / 2;

        // If the segment is completely
        // inside the query range
        if (ss >= qs && se <= qe)
            return seg[index];

        // Calculate the mid
        int mid = ss + (se - ss) / 2;

        // Return maximum in left & right
        // of the segment tree recursively
        return Math.max(
            getMax(b, ss, mid, qs,
                   qe, 2 * index + 1),
            getMax(b, mid + 1, se,
                   qs, qe, 2 * index + 2));
    }

    // Function that initializes the
    // segment Tree
    public static void
    initialiseSegmentTree(int N)
    {
        seg = new int[4 * N];
    }

    // Driver Code
    public static void main(String[] args)
    {
        int A[] = { 1, 2, 1, 6, 5, 5, 6, 1 };
        int B[] = { 14, 8, 15, 15, 9, 10, 7, 12 };

        int C = 40;

        int N = A.length;

        // Initialize and Build the
        // Segment Tree
        initialiseSegmentTree(N);
        build(B, 0, 0, N - 1);

        // Function Call
        System.out.println(maxLength(A, B, N, C));
    }
}

// Java program for the above approach

import java.io.*;
import java.util.*;
class GFG {

    // Function to find maximum length
    // of subarray such that sum of
    // maximum element in subarray in brr[] and
    // sum of subarray in arr[] * K is at most C
    public static int maxLength(
        int a[], int b[], int n, int c)
    {
        // Base Case
        if (n == 0)
            return 0;

        // Let maximum length be 0
        int max_length = 0;

        int low = 0, high = n;

        // Perform Binary search
        while (low <= high) {

            // Find mid value
            int mid = low + (high - low) / 2;

            // Check if the current mid
            // satisfy the given condition
            if (possible(a, b, n, c, mid)) {

                // If yes, then store length
                max_length = mid;
                low = mid + 1;
            }

            // Otherwise
            else
                high = mid - 1;
        }

        // Return maximum length stored
        return max_length;
    }

    // Function to check if it is possible
    // to have such a subarray of length K
    public static boolean possible(
        int a[], int b[], int n, int c, int k)
    {

        // Finds the maximum element
        // in each window of size k
        Deque<Integer> dq
            = new LinkedList<Integer>();

        // Check for window of size K
        int sum = 0;

        // For all possible subarrays of
        // length k
        for (int i = 0; i < k; i++) {

            sum += a[i];

            // Until deque is empty
            while (dq.size() > 0
                   && b[i] > b[dq.peekLast()])
                dq.pollLast();
            dq.addLast(i);
        }

        // Calculate the total cost and
        // check if less than equal to c
        int total_cost = sum * k
                         + b[dq.peekFirst()];
        if (total_cost <= c)
            return true;

        // Find sum of current subarray
        // and the total cost
        for (int i = k; i < n; i++) {

            // Include the new element
            // of current subarray
            sum += a[i];

            // Discard the element
            // of last subarray
            sum -= a[i - k];

            // Remove all the elements
            // in the old window
            while (dq.size() > 0
                   && dq.peekFirst()
                          <= i - k)
                dq.pollFirst();

            while (dq.size() > 0
                   && b[i]
                          > b[dq.peekLast()])
                dq.pollLast();

            dq.add(i);

            // Calculate total cost
            // and check <=c
            total_cost = sum * k
                         + b[dq.peekFirst()];

            // If current subarray
            // length satisfies
            if (total_cost <= c)
                return true;
        }

        // If it is not possible
        return false;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int A[] = { 1, 2, 1, 6, 5, 5, 6, 1 };
        int B[] = { 14, 8, 15, 15, 9, 10, 7, 12 };

        int N = A.length;

        int C = 40;

        System.out.println(
            maxLength(A, B, N, C));
    }
}