Maximum distance between i and j such that i ≤ j and A[i] ≤ B[j]

Given two non-increasing arrays A[] and B[] of size N, the task is to find the maximum distance between i and j such that i ≤ j and A[i] ≤ B[j].

Examples:

Input: A[] = {2, 2, 2}, B[] = {10, 10, 1}
Output: 1
Explanation: 
The valid pairs satisfying the conditions are (0, 0), (0, 1), and (1, 1).
Therefore, the maximum distance is 1 between the indices 0 of A[] and 1 of B[].

Input: A[] = {55, 30, 5, 4, 2}, B[] = {100, 20, 10, 10, 5}
Output: 2
Explanation:
The valid pairs satisfying the conditions are (0, 0), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), and (4, 4).
Therefore, the maximum distance is 2 between the indices 2 of A[] and 4 of B[].

Naive Approach: The simplest approach to solve the problem is to traverse the array A[] and for each element of A[] traverse the array B[] and find the maximum distance between points such that j>=i and B[j] >= A[i].

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

Efficient Approach: The above approach can be optimized further by using the binary search algorithm. Follow the steps below to solve the problem:

• Initialize a variable, say ans as 0 to store the maximum distance between two elements in two non-increasing arrays.
• Iterate in the range [0, N-1] using the variable i, and perform the following steps:
  • Initialize two variables, say low as i, high as N-1.
  • Iterate until low is less than or equal to high and do the following:
    • Initialize a variable, say mid as low+(high-low)/2.
    • If A[i] is less than equal to B[mid], then update ans to max of ans and mid-i and low to mid+1.
    • Otherwise, update high to mid-1.
• Finally, after completing the above steps, print the value of ans as the answer

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum distance
// between two elements satisfying the
// conditions
int maxDistance(int A[], int B[], int N)
{
    // Stores the result
    int ans = 0;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        int low = i, high = N - 1;

        // Iterate until low is less than
        // or equal to high
        while (low <= high) {

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

            // If A[i] less than equal to B[mid]
            if (A[i] <= B[mid]) {

                // Update answer and low
                ans = max(ans, mid - i);
                low = mid + 1;
            }
            // Otherwise
            else {
                // Update high
                high = mid - 1;
            }
        }
    }

    // Finally, print the ans
    return ans;
}

// Driver Code
int main()
{
    // Given Input
    int A[] = { 2, 2, 2 };
    int B[] = { 10, 10, 1 };
    int N = 3;

    // Function Call
    cout << maxDistance(A, B, N);
}

Java

// Java program for the above approach
public class GFG {

    // Function to find the maximum distance
    // between two elements satisfying the
    // conditions
    static int maxDistance(int A[], int B[], int N)
    {

        // Stores the result
        int ans = 0;

        // Traverse the array
        for (int i = 0; i < N; i++) {

            int low = i, high = N - 1;

            // Iterate until low is less than
            // or equal to high
            while (low <= high) {

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

                // If A[i] less than equal to B[mid]
                if (A[i] <= B[mid]) {

                    // Update answer and low
                    ans = Math.max(ans, mid - i);
                    low = mid + 1;
                }
                // Otherwise
                else {
                    // Update high
                    high = mid - 1;
                }
            }
        }

        // Finally, print the ans
        return ans;
    }

    // Driver code
    public static void main(String[] args)
    {
        // Given Input
        int A[] = { 2, 2, 2 };
        int B[] = { 10, 10, 1 };
        int N = 3;

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

// This code is contributed by abhinavjain194

Python3

# Python3 program for the above approach

# Function to find the maximum distance
# between two elements satisfying the
# conditions
def maxDistance(A, B, N):

    # Stores the result
    ans = 0

    # Traverse the array
    for i in range(N):
        low = i
        high = N - 1

        # Iterate until low is less than
        # or equal to high
        while (low <= high):
            mid = low + (high - low) // 2

            # If A[i] less than equal to B[mid]
            if (A[i] <= B[mid]):

                # Update answer and low
                ans = max(ans, mid - i)
                low = mid + 1

            # Otherwise
            else:

                # Update high
                high = mid - 1

    # Finally, print the ans
    return ans

# Driver Code
if __name__ == '__main__':

    # Given Input
    A = [ 2, 2, 2 ]
    B = [ 10, 10, 1 ]
    N = 3

    # Function Call
    print(maxDistance(A, B, N))

# This code is contributed by bgangwar59

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

public class GFG{
    // Function to find the maximum distance
    // between two elements satisfying the
    // conditions
    static int maxDistance(int[] A, int[] B, int N)
    {

        // Stores the result
        int ans = 0;

        // Traverse the array
        for (int i = 0; i < N; i++) {

            int low = i, high = N - 1;

            // Iterate until low is less than
            // or equal to high
            while (low <= high) {

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

                // If A[i] less than equal to B[mid]
                if (A[i] <= B[mid]) {

                    // Update answer and low
                    ans = Math.Max(ans, mid - i);
                    low = mid + 1;
                }
                // Otherwise
                else {
                    // Update high
                    high = mid - 1;
                }
            }
        }

        // Finally, print the ans
        return ans;
    }

    // Driver code
    public static void Main()
    {
        // Given Input
        int[] A = { 2, 2, 2 };
        int[] B = { 10, 10, 1 };
        int N = 3;

        // Function Call
        Console.Write(maxDistance(A, B, N));
    }
}

// This code is contributed by shubhamsingh10

Javascript

<script>
       // JavaScript program for the above approach

       // Function to find the maximum distance
       // between two elements satisfying the
       // conditions
       function maxDistance(A, B, N) {
           // Stores the result
           let ans = 0;

           // Traverse the array
           for (let i = 0; i < N; i++) {

               let low = i, high = N - 1;

               // Iterate until low is less than
               // or equal to high
               while (low <= high) {

                   let mid = low + (high - low) / 2;

                   // If A[i] less than equal to B[mid]
                   if (A[i] <= B[mid]) {

                       // Update answer and low
                       ans = Math.max(ans, mid - i);
                       low = mid + 1;
                   }
                   // Otherwise
                   else {
                       // Update high
                       high = mid - 1;
                   }
               }
           }

           // Finally, print the ans
           return ans;
       }

       // Driver Code

       // Given Input
       let A = [2, 2, 2];
       let B = [10, 10, 1];
       let N = 3;

       // Function Call
       document.write(maxDistance(A, B, N));

   // This code is contributed by Potta Lokesh

   </script>

Output

1

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

Efficient Approach: The above approach can be optimized further by using two pointers technique. Follow the steps below to solve the problem:

• Initialize two variables, say, i, and j to perform a two-pointer.
• Iterate until i and j are less than N and perform the following steps:
  • If A[i] is greater than B[j], then increment i by 1, because the arrays are sorted in non-increasing.
  • Otherwise, update ans to max of ans and j-i, and increment j by 1.
• Finally, after completing the above steps, print the value of ans as the answer.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum distance
// between two elements in two non increasing
// arrays

int maxDistance(int A[], int B[], int N)
{

    int i = 0, j = 0;
    // Stores the result
    int ans = 0;

    // Iterate while i and j are less than N
    while (i < N && j < N) {

        // If A[i] is greater than B[j]
        if (A[i] > B[j]) {
            ++i;
        }
        // Otherwise,
        else {

            // Update the answer
            ans = max(ans, j - i);

            // Increment j
            j++;
        }
    }

    // Finally, print the ans
    return ans;
}

// Driver Code
int main()
{
    // Given Input
    int A[] = { 2, 2, 2 };
    int B[] = { 10, 10, 1 };
    int N = sizeof(A) / sizeof(A[0]);

    // Function Call
    cout << maxDistance(A, B, N);
}

Java

// Java program for the above approach
import java.io.*;
class GFG {

    // Function to find the maximum distance
    // between two elements in two non increasing
    // arrays
    static int maxDistance(int A[], int B[], int N)
    {

        int i = 0, j = 0;

        // Stores the result
        int ans = 0;

        // Iterate while i and j are less than N
        while (i < N && j < N) {

            // If A[i] is greater than B[j]
            if (A[i] > B[j]) {
                ++i;
            }
            // Otherwise,
            else {

                // Update the answer
                ans = Math.max(ans, j - i);

                // Increment j
                j++;
            }
        }

        // Finally, print the ans
        return ans;
    }

    // Driver Code
    public static void main (String[] args)
    {

        // Given Input
        int A[] = { 2, 2, 2 };
        int B[] = { 10, 10, 1 };
        int N = A.length;

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

// This code is contributed by Shubhamsingh10

Python3

# Python3 program for the above approach

# Function to find the maximum distance
# between two elements in two non increasing
# arrays
def maxDistance(A, B, N):

    i = 0
    j = 0

    # Stores the result
    ans = 0

    # Iterate while i and j are less than N
    while (i < N and j < N):

        # If A[i] is greater than B[j]
        if (A[i] > B[j]):
            i += 1

        # Otherwise,
        else:

            # Update the answer
            ans = max(ans, j - i)

            # Increment j
            j += 1

    # Finally, print the ans
    return ans

# Driver Code
if __name__ == '__main__':

    # Given Input
    A = [ 2, 2, 2 ]
    B = [ 10, 10, 1 ]
    N = len(A)

    # Function Call
    print(maxDistance(A, B, N))

# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
class GFG {

    // Function to find the maximum distance
    // between two elements in two non increasing
    // arrays
    static int maxDistance(int []A, int []B, int N)
    {

        int i = 0, j = 0;

        // Stores the result
        int ans = 0;

        // Iterate while i and j are less than N
        while (i < N && j < N) {

            // If A[i] is greater than B[j]
            if (A[i] > B[j]) {
                ++i;
            }
            // Otherwise,
            else {

                // Update the answer
                ans = Math.Max(ans, j - i);

                // Increment j
                j++;
            }
        }

        // Finally, print the ans
        return ans;
    }

    // Driver Code
    public static void Main (String[] args)
    {

        // Given Input
        int []A = { 2, 2, 2 };
        int []B = { 10, 10, 1 };
        int N = A.Length;

        // Function Call
        Console.Write(maxDistance(A, B, N));
    }
}

// This code is contributed by shivanisinghss2110

Javascript

<script>
// JavaScript program for the above approach
// Function to find the maximum distance
// between two elements in two non increasing
// arrays
function maxDistance( A, B, N)
    {

        var i = 0, j = 0;

        // Stores the result
        var ans = 0;

        // Iterate while i and j are less than N
        while (i < N && j < N) {

            // If A[i] is greater than B[j]
            if (A[i] > B[j]) {
                ++i;
            }

            // Otherwise,
            else {

                // Update the answer
                ans = Math.max(ans, j - i);

                // Increment j
                j++;
            }
        }

        // Finally, print the ans
        return ans;
    }

    // Driver Code
    // Given Input
    var A = [ 2, 2, 2 ];
    var B = [ 10, 10, 1 ];
    var N = A.length;

    // Function Call
    document.write(maxDistance(A, B, N));

// This code is contributed by shivanisinghss2110
</script>

Output

1

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