Count of possible unique arrays after swapping elements at same index of given Arrays
Last Updated :
18 Nov, 2021
Given two arrays arr1[] and arr2[] with distinct elements of size N.The task is to count the total number of possible combinations after swapping elements at the same index of both the arrays such that there are no duplicates in both the arrays after performing the operation.
Examples:
Input: arr1[] = {1, 2, 3, 4}, arr2[] = {2, 1, 4, 3}, N = 4
Output: 4
Explanation: Possible combinations of arrays are:
- {1, 2, 3, 4} and {2, 1, 4, 3}
- {2, 1, 3, 4} and {1, 2, 4, 3}
- {1, 2, 4, 3} and {2, 1, 3, 4}
- {2, 1, 4, 3} and {1, 2, 3, 4}
The bold ones are swapped elements. So, total number of combinations = 4.
Input: arr1[] = {3, 6, 5, 2, 1, 4, 7}, arr2[] = {1, 7, 2, 4, 3, 5, 6}, N = 7
Output: 8
Approach: The idea is to iterate the array for every element and make a swap, then find for swapping of the current element, how many extra swaps are needed to make the array free from duplicates. Count every different combination as a group(set) i.e for each group there are two possibilities either to make a swap or to not make a swap, so the answer will be the sum of 2 raised to the power of the number of groups. Follow the below steps to solve the problem:
- Create an unordered map to store elements of both arrays in key-value pairs
- Take a variable say count for the count of possible combinations and also take a vector for track of elements say visited.
- Iterate over the map and check if the element is not visited, each time create a set and run a loop till the current index is not equal to i. In each iteration, insert the element of the current index of the map in the set and also update the current index. Mark all the elements as visited in the set.
- After each iteration, while making groups(set), multiply the count by 2 as there are two possibilities for each group of swapping or not swapping of elements.
- In the end, return the count.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int possibleCombinations( int arr1[], int arr2[], int N)
{
unordered_map< int , int > mp;
for ( int i = 0; i < N; i++) {
mp[arr1[i]] = arr2[i];
}
int count = 1;
vector< bool > visited(N + 1, 0);
for ( int i = 1; i <= N; i++) {
if (!visited[i]) {
set< int > s;
int curr_index = i;
do {
s.insert(mp[curr_index]);
curr_index = mp[curr_index];
} while (curr_index != i);
for ( auto it : s) {
visited[it] = 1;
}
count *= 2;
}
}
return count;
}
int main()
{
int arr1[] = { 3, 6, 5, 2, 1, 4, 7 };
int arr2[] = { 1, 7, 2, 4, 3, 5, 6 };
int N = sizeof (arr1) / sizeof (arr1[0]);
cout << possibleCombinations(arr1, arr2, N);
return 0;
}
|
Java
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
class GFG
{
public static int possibleCombinations( int arr1[], int arr2[], int N)
{
HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
for ( int i = 0 ; i < N; i++) {
mp.put(arr1[i], arr2[i]);
}
int count = 1 ;
int [] visited = new int [N + 1 ];
Arrays.fill(visited, 0 );
for ( int i = 1 ; i <= N; i++) {
if (visited[i] <= 0 ) {
HashSet<Integer> s = new HashSet<Integer>();
int curr_index = i;
do {
s.add(mp.get(curr_index));
curr_index = mp.get(curr_index);
} while (curr_index != i);
for ( int it : s) {
visited[it] = 1 ;
}
count *= 2 ;
}
}
return count;
}
public static void main(String args[]) {
int arr1[] = { 3 , 6 , 5 , 2 , 1 , 4 , 7 };
int arr2[] = { 1 , 7 , 2 , 4 , 3 , 5 , 6 };
int N = arr1.length;
System.out.println(possibleCombinations(arr1, arr2, N));
}
}
|
Python3
def possibleCombinations(arr1, arr2, N) :
mp = {};
for i in range (N) :
mp[arr1[i]] = arr2[i];
count = 1 ;
visited = [ 0 ] * (N + 1 );
for i in range ( 1 , N + 1 ) :
if ( not visited[i]) :
s = set ();
curr_index = i;
while True :
s.add(mp[curr_index]);
curr_index = mp[curr_index];
if (curr_index = = i) :
break
for it in s :
visited[it] = 1 ;
count * = 2 ;
return count;
if __name__ = = "__main__" :
arr1 = [ 3 , 6 , 5 , 2 , 1 , 4 , 7 ];
arr2 = [ 1 , 7 , 2 , 4 , 3 , 5 , 6 ];
N = len (arr1);
print (possibleCombinations(arr1, arr2, N));
|
C#
using System;
using System.Collections.Generic;
class GFG {
public static int
possibleCombinations( int [] arr1, int [] arr2, int N)
{
Dictionary< int , int > mp
= new Dictionary< int , int >();
for ( int i = 0; i < N; i++) {
mp[arr1[i]] = arr2[i];
}
int count = 1;
int [] visited = new int [N + 1];
for ( int i = 1; i <= N; i++) {
if (visited[i] <= 0) {
HashSet< int > s = new HashSet< int >();
int curr_index = i;
do {
s.Add(mp[curr_index]);
curr_index = mp[curr_index];
} while (curr_index != i);
foreach ( int it in s) { visited[it] = 1; }
count *= 2;
}
}
return count;
}
public static void Main( string [] args)
{
int [] arr1 = { 3, 6, 5, 2, 1, 4, 7 };
int [] arr2 = { 1, 7, 2, 4, 3, 5, 6 };
int N = arr1.Length;
Console.WriteLine(
possibleCombinations(arr1, arr2, N));
}
}
|
Javascript
<script>
function possibleCombinations(arr1, arr2, N)
{
var mp = new Map();
for ( var i = 0; i < N; i++) {
mp.set(arr1[i], arr2[i]);
}
var count = 1;
var visited = Array(N + 1).fill( false );
for ( var i = 1; i <= N; i++) {
if (!visited[i]) {
var s = new Set();
var curr_index = i;
do {
s.add(mp.get(curr_index));
curr_index = mp.get(curr_index);
} while (curr_index != i);
for ( var it of [...s]) {
visited[it] = true ;
}
count *= 2;
}
}
return count;
}
var arr1 = [3, 6, 5, 2, 1, 4, 7];
var arr2 = [1, 7, 2, 4, 3, 5, 6];
var N = arr1.length;
document.write(possibleCombinations(arr1, arr2, N));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...