Minimum number of adjacent swaps for arranging similar elements together
Last Updated :
26 Aug, 2022
Given an array of 2 * N positive integers where each array element lies between 1 to N and appears exactly twice in the array. The task is to find the minimum number of adjacent swaps required to arrange all similar array elements together.
Note: It is not necessary that the final array (after performing swaps) should be sorted.
Examples:
Input: arr[] = { 1, 2, 3, 3, 1, 2 }
Output: 5
After first swapping, array will be arr[] = { 1, 2, 3, 1, 3, 2 },
after second arr[] = { 1, 2, 1, 3, 3, 2 }, after third arr[] = { 1, 1, 2, 3, 3, 2 },
after fourth arr[] = { 1, 1, 2, 3, 2, 3 }, after fifth arr[] = { 1, 1, 2, 2, 3, 3 }
Input: arr[] = { 1, 2, 1, 2 }
Output: 1
arr[2] can be swapped with arr[1] to get the required position.
Approach: This problem can be solved using greedy approach. Following are the steps :
- Keep an array visited[] which tells that visited[curr_ele] is false if swap operation has not been performed on curr_ele.
- Traverse through the original array and if the current array element has not been visited yet i.e. visited[arr[curr_ele]] = false, set it to true and iterate over another loop starting from the current position to the end of array.
- Initialize a variable count which will determine the number of swaps required to place the current element’s partner at its correct position.
- In nested loop, increment count only if the visited[curr_ele] is false (since if it is true, means curr_ele has already been placed at its correct position).
- If the current element’s partner is found in the nested loop, add up the value of count to the total answer.
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int findMinimumAdjacentSwaps( int arr[], int N)
{
bool visited[N + 1];
int minimumSwaps = 0;
memset (visited, false , sizeof (visited));
for ( int i = 0; i < 2 * N; i++) {
if (visited[arr[i]] == false ) {
visited[arr[i]] = true ;
int count = 0;
for ( int j = i + 1; j < 2 * N; j++) {
if (visited[arr[j]] == false )
count++;
else if (arr[i] == arr[j])
minimumSwaps += count;
}
}
}
return minimumSwaps;
}
int main()
{
int arr[] = { 1, 2, 3, 3, 1, 2 };
int N = sizeof (arr) / sizeof (arr[0]);
N /= 2;
cout << findMinimumAdjacentSwaps(arr, N) << endl;
return 0;
}
|
Java
import java.util.*;
class solution
{
static int findMinimumAdjacentSwaps( int arr[], int N)
{
boolean [] visited = new boolean [N + 1 ];
int minimumSwaps = 0 ;
Arrays.fill(visited, false );
for ( int i = 0 ; i < 2 * N; i++) {
if (visited[arr[i]] == false ) {
visited[arr[i]] = true ;
int count = 0 ;
for ( int j = i + 1 ; j < 2 * N; j++) {
if (visited[arr[j]] == false )
count++;
else if (arr[i] == arr[j])
minimumSwaps += count;
}
}
}
return minimumSwaps;
}
public static void main(String args[])
{
int arr[] = { 1 , 2 , 3 , 3 , 1 , 2 };
int N = arr.length;
N /= 2 ;
System.out.println(findMinimumAdjacentSwaps(arr, N));
}
}
|
Python3
def findMinimumAdjacentSwaps(arr, N) :
visited = [ False ] * (N + 1 )
minimumSwaps = 0
for i in range ( 2 * N) :
if (visited[arr[i]] = = False ) :
visited[arr[i]] = True
count = 0
for j in range ( i + 1 , 2 * N) :
if (visited[arr[j]] = = False ) :
count + = 1
elif (arr[i] = = arr[j]) :
minimumSwaps + = count
return minimumSwaps
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 3 , 1 , 2 ]
N = len (arr)
N / / = 2
print (findMinimumAdjacentSwaps(arr, N))
|
C#
using System;
class GFG
{
static int findMinimumAdjacentSwaps( int []arr, int N)
{
bool [] visited = new bool [N + 1];
int minimumSwaps = 0;
for ( int i = 0; i < 2 * N; i++)
{
if (visited[arr[i]] == false )
{
visited[arr[i]] = true ;
int count = 0;
for ( int j = i + 1; j < 2 * N; j++)
{
if (visited[arr[j]] == false )
count++;
else if (arr[i] == arr[j])
minimumSwaps += count;
}
}
}
return minimumSwaps;
}
public static void Main(String []args)
{
int []arr = { 1, 2, 3, 3, 1, 2 };
int N = arr.Length;
N /= 2;
Console.WriteLine(findMinimumAdjacentSwaps(arr, N));
}
}
|
Javascript
<script>
function findMinimumAdjacentSwaps(arr, N)
{
let visited = Array(N + 1).fill( false );
let minimumSwaps = 0;
for (let i = 0; i < 2 * N; i++) {
if (visited[arr[i]] == false ) {
visited[arr[i]] = true ;
let count = 0;
for (let j = i + 1; j < 2 * N; j++) {
if (visited[arr[j]] == false )
count++;
else if (arr[i] == arr[j])
minimumSwaps += count;
}
}
}
return minimumSwaps;
}
let arr = [ 1, 2, 3, 3, 1, 2 ];
let N = arr.length;
N = Math.floor(N / 2);
document.write(findMinimumAdjacentSwaps(arr, N));
</script>
|
Complexity Analysis:
- Time Complexity: O(N2)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...