Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

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

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

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)


My Personal Notes arrow_drop_up
Last Updated : 22 Mar, 2023
Like Article
Save Article
Similar Reads
Related Tutorials