Number of ways to merge two arrays such retaining order
Last Updated :
17 Jan, 2023
Given two array of size n and m. The task is to find the number of ways we can merge the given arrays into one array such that order of elements of each array doesn’t change.
Examples:
Input : n = 2, m = 2
Output : 6
Let first array of size n = 2 be [1, 2] and second array of size m = 2 be [3, 4].
So, possible merged array of n + m elements can be:
[1, 2, 3, 4]
[1, 3, 2, 4]
[3, 4, 1, 2]
[3, 1, 4, 2]
[1, 3, 4, 2]
[3, 1, 2, 4]
Input : n = 4, m = 6
Output : 210
The idea is to use the concept of combinatorics. Suppose we have two array A{a1, a2, …., am} and B{b1, b2, …., bn} having m and n elements respectively and now we have to merge them without losing their order.
After merging we know that the total number of element will be (m + n) element after merging. So, now we just need the ways to choose m places out of (m + n) where you will place element of array A in its actual order, which is m + nCn.
After placing m element of array A, n spaces will be left, which can be filled by the n elements of B array in its actual order.
So, total number of ways to merge two array such that their order in merged array is same is m + nCn
Below is the implementation of this approach:
C++
#include <bits/stdc++.h>
using namespace std;
int binomialCoeff( int n, int k)
{
int C[k + 1];
memset (C, 0, sizeof (C));
C[0] = 1;
for ( int i = 1; i <= n; i++) {
for ( int j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
int numOfWays( int n, int m)
{
return binomialCoeff(m + n, m);
}
int main()
{
int n = 2, m = 2;
cout << numOfWays(n, m) << endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
static int binomialCoeff( int n, int k)
{
int C[] = new int [k + 1 ];
C[ 0 ] = 1 ;
for ( int i = 1 ; i <= n; i++) {
for ( int j = Math.min(i, k);
j > 0 ; j--)
C[j] = C[j] + C[j - 1 ];
}
return C[k];
}
static int numOfWays( int n, int m)
{
return binomialCoeff(m + n, m);
}
public static void main (String[] args)
{
int n = 2 , m = 2 ;
System.out.println(numOfWays(n, m));
}
}
|
Python3
def binomialCoeff(n, k):
C = [ 0 for i in range (k + 1 )]
C[ 0 ] = 1
for i in range ( 1 , n + 1 , 1 ):
j = min (i, k)
while (j > 0 ):
C[j] = C[j] + C[j - 1 ]
j - = 1
return C[k]
def numOfWays(n, m):
return binomialCoeff(m + n, m)
if __name__ = = '__main__' :
n = 2
m = 2
print (numOfWays(n, m))
|
C#
using System;
class GFG {
static int binomialCoeff( int n, int k)
{
int []C = new int [k + 1];
C[0] = 1;
for ( int i = 1; i <= n; i++) {
for ( int j = Math.Min(i, k);
j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
static int numOfWays( int n, int m)
{
return binomialCoeff(m + n, m);
}
public static void Main ()
{
int n = 2, m = 2;
Console.WriteLine(numOfWays(n, m));
}
}
|
PHP
<?php
function binomialCoeff( $n , $k )
{
$C = array ( $k + 1);
for ( $i =0; $i < count ( $C ); $i ++)
$C [ $i ] = 0;
$C [0] = 1;
for ( $i = 1; $i <= $n ; $i ++) {
for ( $j = min( $i , $k ); $j > 0; $j --)
$C [ $j ] = $C [ $j ] + $C [ $j - 1 ];
}
return $C [ $k ];
}
function numOfWays( $n , $m )
{
return binomialCoeff( $m + $n , $m );
}
$n = 2; $m = 2;
echo numOfWays( $n , $m );
?>
|
Javascript
<script>
function binomialCoeff(n, k)
{
let C = new Array(k + 1);
C.fill(0);
C[0] = 1;
for (let i = 1; i <= n; i++) {
for (let j = Math.min(i, k); j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
function numOfWays(n, m)
{
return binomialCoeff(m + n, m);
}
let n = 2, m = 2;
document.write(numOfWays(n, m));
</script>
|
Time Complexity: O((m+n)*m)
Auxiliary Space: O(m)
We can solve above problem in linear time using linear time implementation of binomial coefficient.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...