Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array

Given two sorted arrays A[] and B[] of size N, the task is to check if it is possible to merge two given sorted arrays into a new sorted array such that no two consecutive elements are from the same array.

Examples:

Input: A[] = {3, 5, 8}, B[] = {2, 4, 6}
Output: Yes

Explanation: Merged array = {B[0], A[0], B[1], A[1], B[2], A[2]} 
Since the resultant array is sorted array, the required output is Yes. 

Input: A[] = {12, 4, 2, 5, 3}, B[] = {32, 13, 43, 10, 8}
Output: No

Approach: Follow the steps below to solve the problem:

• Initialize a variable, say flag = true to check if it is possible to form a new sorted array by merging the given two sorted arrays such that no two consecutive elements are from the same array.
• Initialize a variable, say prev to check if the previous element of the merge array are from the array A[] or the array B[]. If prev == 1 then the previous element are from the array A[] and if prev == 0 then the previous element are from the array B[].
• Traverse both the array using variables, i and j and check the following conditions: 
  • If A[i] < B[j] and prev != 0 then increment the value of i and update the value of prev to 0.
  • If B[j] < A[i[ and prev != 1 then increment the value of j and update the value of prev to 1.
  • If A[i] == B[j] and prev != 1 then increment the value of j and update the value of prev to 1.
  • If A[i] == B[j] and prev != 0 then increment the value of i and update the value of prev to 0.
  • If none of the above condition satisfy then update flag = false.
• Finally, print the value of flag.

Below is the implementation of the above approach:

C++

// C++ program to implement
// the above approach

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

// Function to check if it is possible to merge
// the two given arrays with given conditions
bool checkIfPossibleMerge(int A[], int B[], int N)
{
    // Stores index of
    // the array A[]
    int i = 0;

    // Stores index of
    // the array  B[]
    int j = 0;

    // Check if the previous element are from
    // the array A[] or from the array B[]
    int prev = -1;

    // Check if it is possible to merge the two
    // given sorted arrays with given conditions
    int flag = 1;

    // Traverse both the arrays
    while (i < N && j < N) {

        // If A[i] is less than B[j] and
        // previous element are not from A[]
        if (A[i] < B[j] && prev != 0) {

            // Update prev
            prev = 0;

            // Update i
            i++;
        }

        // If B[j] is less than A[i] and
        // previous element are not from B[]
        else if (B[j] < A[i] && prev != 1) {

            // Update prev
            prev = 1;

            // Update j
            j++;
        }

        // If A[i] equal to B[j]
        else if (A[i] == B[j]) {

            // If previous element
            // are not from B[]
            if (prev != 1) {

                // Update prev
                prev = 1;

                // Update j
                j++;
            }

            // If previous element is
            // not from A[]
            else {

                // Update prev
                prev = 0;

                // Update i
                i++;
            }
        }

        // If it is not possible to merge two
        // sorted arrays with given conditions
        else {

            // Update flag
            flag = 0;
            break;
        }
    }

    return flag;
}

// Driver Code
int main()
{
    int A[3] = { 3, 5, 8 };
    int B[3] = { 2, 4, 6 };
    int N = sizeof(A) / sizeof(A[0]);

    if (checkIfPossibleMerge(A, B, N)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
    return 0;
}

Java

// Java program to implement
// the above approach
import java.io.*;

class GFG{

// Function to check if it is possible to merge
// the two given arrays with given conditions
static boolean checkIfPossibleMerge(int[] A, int[] B,
                                    int N)
{

    // Stores index of
    // the array A[]
    int i = 0;

    // Stores index of
    // the array  B[]
    int j = 0;

    // Check if the previous element are from
    // the array A[] or from the array B[]
    int prev = -1;

    // Check if it is possible to merge the two
    // given sorted arrays with given conditions
    boolean flag = true;

    // Traverse both the arrays
    while (i < N && j < N)
    {

        // If A[i] is less than B[j] and
        // previous element are not from A[]
        if (A[i] < B[j] && prev != 0)
        {

            // Update prev
            prev = 0;

            // Update i
            i++;
        }

        // If B[j] is less than A[i] and
        // previous element are not from B[]
        else if (B[j] < A[i] && prev != 1)
        {

            // Update prev
            prev = 1;

            // Update j
            j++;
        }

        // If A[i] equal to B[j]
        else if (A[i] == B[j])
        {

            // If previous element
            // are not from B[]
            if (prev != 1)
            {

                // Update prev
                prev = 1;

                // Update j
                j++;
            }

            // If previous element is
            // not from A[]
            else
            {

                // Update prev
                prev = 0;

                // Update i
                i++;
            }
        }

        // If it is not possible to merge two
        // sorted arrays with given conditions
        else
        {

            // Update flag
            flag = false;
            break;
        }
    }
    return flag;
}

// Driver Code
public static void main(String[] args)
{
    int[] A = { 3, 5, 8 };
    int[] B = { 2, 4, 6 };
    int N = A.length;

    if (checkIfPossibleMerge(A, B, N))
    {
        System.out.println("Yes");
    }
    else
    {
        System.out.println("No");
    }
}
}

// This code is contributed by akhilsaini

Python3

# Python3 program to implement
# the above approach

# Function to check if it is possible
# to merge the two given arrays with
# given conditions
def checkIfPossibleMerge(A, B, N):

    # Stores index of
    # the array A[]
    i = 0

    # Stores index of
    # the array  B[]
    j = 0

    # Check if the previous element
    # are from the array A[] or from
    # the array B[]
    prev = -1

    # Check if it is possible to merge
    # the two given sorted arrays with
    # given conditions
    flag = 1

    # Traverse both the arrays
    while (i < N and j < N):

        # If A[i] is less than B[j] and
        # previous element are not from A[]
        if (A[i] < B[j] and prev != 0):

            # Update prev
            prev = 0

            # Update i
            i += 1

        # If B[j] is less than A[i] and
        # previous element are not from B[]
        elif (B[j] < A[i] and prev != 1):

            # Update prev
            prev = 1

            # Update j
            j += 1

        # If A[i] equal to B[j]
        elif (A[i] == B[j]):

            # If previous element
            # are not from B[]
            if (prev != 1):

                # Update prev
                prev = 1

                # Update j
                j += 1

            # If previous element is
            # not from A[]
            else:

                # Update prev
                prev = 0

                # Update i
                i += 1

        # If it is not possible to merge two
        # sorted arrays with given conditions
        else:

            # Update flag
            flag = 0
            break

    return flag

# Driver Code
if __name__ == '__main__':

    A = [ 3, 5, 8 ]
    B = [ 2, 4, 6 ]
    N = len(A)

    if (checkIfPossibleMerge(A, B, N)):
        print("Yes")
    else:
        print("No")

# This code is contributed by akhilsaini

C#

// C# program to implement
// the above approach
using System;

class GFG{

// Function to check if it is possible to merge
// the two given arrays with given conditions
static bool checkIfPossibleMerge(int[] A, int[] B,
                                 int N)
{

    // Stores index of
    // the array A[]
    int i = 0;

    // Stores index of
    // the array  B[]
    int j = 0;

    // Check if the previous element are
    // from the array A[] or from the
    // array B[]
    int prev = -1;

    // Check if it is possible to merge
    // the two given sorted arrays with
    // given conditions
    bool flag = true;

    // Traverse both the arrays
    while (i < N && j < N)
    {

        // If A[i] is less than B[j] and
        // previous element are not from A[]
        if (A[i] < B[j] && prev != 0)
        {

            // Update prev
            prev = 0;

            // Update i
            i++;
        }

        // If B[j] is less than A[i] and
        // previous element are not from B[]
        else if (B[j] < A[i] && prev != 1)
        {

            // Update prev
            prev = 1;

            // Update j
            j++;
        }

        // If A[i] equal to B[j]
        else if (A[i] == B[j])
        {

            // If previous element
            // are not from B[]
            if (prev != 1)
            {

                // Update prev
                prev = 1;

                // Update j
                j++;
            }

            // If previous element is
            // not from A[]
            else
            {

                // Update prev
                prev = 0;

                // Update i
                i++;
            }
        }

        // If it is not possible to merge two
        // sorted arrays with given conditions
        else
        {

            // Update flag
            flag = false;
            break;
        }
    }
    return flag;
}

// Driver Code
public static void Main()
{
    int[] A = { 3, 5, 8 };
    int[] B = { 2, 4, 6 };
    int N = A.Length;

    if (checkIfPossibleMerge(A, B, N))
    {
        Console.WriteLine("Yes");
    }
    else
    {
        Console.WriteLine("No");
    }
}
}

// This code is contributed by akhilsaini

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to check if it is possible to merge
// the two given arrays with given conditions
function checkIfPossibleMerge(A, B, N)
{

    // Stores index of
    // the array A[]
    let i = 0;

    // Stores index of
    // the array  B[]
    let j = 0;

    // Check if the previous element are from
    // the array A[] or from the array B[]
    let prev = -1;

    // Check if it is possible to merge the two
    // given sorted arrays with given conditions
    let flag = true;

    // Traverse both the arrays
    while (i < N && j < N)
    {

        // If A[i] is less than B[j] and
        // previous element are not from A[]
        if (A[i] < B[j] && prev != 0)
        {

            // Update prev
            prev = 0;

            // Update i
            i++;
        }

        // If B[j] is less than A[i] and
        // previous element are not from B[]
        else if (B[j] < A[i] && prev != 1)
        {

            // Update prev
            prev = 1;

            // Update j
            j++;
        }

        // If A[i] equal to B[j]
        else if (A[i] == B[j])
        {

            // If previous element
            // are not from B[]
            if (prev != 1)
            {

                // Update prev
                prev = 1;

                // Update j
                j++;
            }

            // If previous element is
            // not from A[]
            else
            {

                // Update prev
                prev = 0;

                // Update i
                i++;
            }
        }

        // If it is not possible to merge two
        // sorted arrays with given conditions
        else
        {

            // Update flag
            flag = false;
            break;
        }
    }
    return flag;
}

    // Driver Code

    let A = [ 3, 5, 8 ];
    let B = [ 2, 4, 6 ];
    let N = A.length;

    if (checkIfPossibleMerge(A, B, N))
    {
        document.write("Yes");
    }
    else
    {
        document.write("No");
    }

// This code is contributed by splevel62.
</script>

Output

Yes

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

Approach 2: Dynamic Programming:

The given problem can be solved using a dynamic programming approach. We can create a 2D boolean table dp[][] of size (N+1)x(N+1) where dp[i][j] represents if it is possible to merge the first i elements of array A and the first j elements of array B with given conditions.

• The base case is dp[0][0] = true, as we can merge 0 elements from both arrays.
• For each (i,j) such that i>0 and j>0, we can calculate dp[i][j] as follows:
• If A[i-1] == B[j-1], then we can merge both the elements into the resulting array, and the previous element can be from either array. So, dp[i][j] = dp[i-1][j-1].
• If A[i-1] < B[j-1], then we can only merge the element A[i-1] into the resulting array if the previous element is from array B. So, dp[i][j] = dp[i][j-1].
• If A[i-1] > B[j-1], then we can only merge the element B[j-1] into the resulting array if the previous element is from array A. So, dp[i][j] = dp[i-1][j].
  Finally, the answer is dp[N][N]. If dp[N][N] is true, it means it is possible to merge the entire arrays A and B with given conditions.

C++

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

// Function to check if it is possible to merge
// the two given arrays with given conditions
bool checkIfPossibleMerge(int A[], int B[], int N)
{
    // Create a 2D boolean table
    bool dp[N+1][N+1];

    // Base case
    dp[0][0] = true;

    // Initialize the first row and column
    for (int i = 1; i <= N; i++) {
        dp[i][0] = (A[i-1] > A[i-2]) && dp[i-1][0];
        dp[0][i] = (B[i-1] > B[i-2]) && dp[0][i-1];
    }

    // Fill the remaining table
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            if (A[i-1] == B[j-1]) {
                dp[i][j] = dp[i-1][j-1];
            }
            else if (A[i-1] < B[j-1]) {
                dp[i][j] = dp[i][j-1] && (A[i-1] > B[j-2]);
            }
            else {
                dp[i][j] = dp[i-1][j] && (B[j-1] > A[i-2]);
            }
        }
    }

    return dp[N][N];
}

// Driver Code
int main()
{
    int A[3] = { 3, 5, 8 };
    int B[3] = { 2, 4, 6 };
    int N = sizeof(A) / sizeof(A[0]);

    if (checkIfPossibleMerge(A, B, N)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
    return 0;
}

Python3

def checkIfPossibleMerge(A, B, N):
    # Create a 2D boolean table
    dp = [[False]*(N+1) for _ in range(N+1)]

    # Base case
    dp[0][0] = True

    # Initialize the first row and column
    for i in range(1, N+1):
        dp[i][0] = (A[i-1] > A[i-2]) and dp[i-1][0]
        dp[0][i] = (B[i-1] > B[i-2]) and dp[0][i-1]

    # Fill the remaining table
    for i in range(1, N+1):
        for j in range(1, N+1):
            if A[i-1] == B[j-1]:
                dp[i][j] = dp[i-1][j-1]
            elif A[i-1] < B[j-1]:
                dp[i][j] = dp[i][j-1] and (A[i-1] > B[j-2])
            else:
                dp[i][j] = dp[i-1][j] and (B[j-1] > A[i-2])

    return dp[N][N]

# Driver Code
if __name__ == '__main__':
    A = [3, 5, 8]
    B = [2, 4, 6]
    N = len(A)

    if checkIfPossibleMerge(A, B, N):
        print("No")
    else:
        print("Yes")

Output

Yes

Time Complexity: O(N^2)
Auxiliary Space: O(N)