Given a permutation P of size N, having values from 1 to N. the task is to find the minimum number of adjacent swaps required such that for all i in the range [1, N], P[i] does not equal i.
Examples:
Input: P = [1, 4, 3, 5, 2]
Output: 2
Explanation:
Here P = [1, 4, 3, 5, 2] at index 1, 2, 3, 4, 5. As we can see, P[1] = 1 and P[3] = 3. Hence, we need to get rid of this invariant.
Swap 1: Swap index 1 and index 2 => [4, 1, 3, 5, 2]
Swap 2: Swap index 2 and index 3 => [4, 3, 1, 5, 2]
The final array has no i where P[i] = i. Hence, a minimum of 2 swaps is required.
Input: P = [1, 2, 4, 9, 5, 8, 7, 3, 6]
Output: 3
Explanation:
Swap 1: Swap index 1 and index 2 => [2, 1, 4, 9, 5, 8, 7, 3, 6]
Swap 2: Swap index 5 and index 6 => [2, 1, 4, 9, 8, 5, 7, 3, 6]
Swap 2: Swap index 7 and index 8 => [2, 1, 4, 9, 8, 5, 3, 7, 6]
Hence, a minimum of 3 swaps is required.
Approach: Let us consider the positions where P[i] = i be denoted by X and the other positions by O. Below are three basic observation for the question:
- If values at any two adjacent index of the permutation is of the form XO, we can simply swap the 2 indexes to get ‘OO’.
- If values at any two adjacent index of the permutation is of the form XX, we can simply swap the 2 indexes to get ‘OO’.
- If values at any two adjacent index of the permutation is of the form OX, it is simply ‘XO’ or ‘XX’ once the pointer reaches index at X.
Below are the steps:
- Iterate from 1 to N – 1 and check if P[i] = i then we simply swap(P[i], P[i + 1]), otherwise continue the process for the next adjacent pairs.
- The Corner Case for the given question is when i = N, if P[i] = i, then we swap(P[i], P[i – 1]).
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void solve(vector<int>& P, int n)
{
vector<int> arr;
arr.push_back(0);
for (auto x : P)
arr.push_back(x);
int cnt = 0;
for (int i = 1; i < n; i++) {
if (arr[i] == i) {
swap(arr[i], arr[i + 1]);
cnt++;
}
}
if (arr[n] == n) {
swap(arr[n - 1], arr[n]);
cnt++;
}
cout << cnt << endl;
}
signed main()
{
int N = 9;
vector<int> P = { 1, 2, 4, 9, 5,
8, 7, 3, 6 };
solve(P, N);
return 0;
}
|
Java
import java.io.*;
class GFG{
static void solve(int P[], int n)
{
int arr[] = new int[n + 1];
arr[0] = 0;
for(int i = 0; i < n; i++)
arr[i + 1] = P[i];
int cnt = 0;
for(int i = 1; i < n; i++)
{
if (arr[i] == i)
{
int t = arr[i + 1];
arr[i + 1] = arr[i];
arr[i] = t;
cnt++;
}
}
if (arr[n] == n)
{
int t = arr[n - 1];
arr[n - 1] = arr[n];
arr[n] = t;
cnt++;
}
System.out.println(cnt);
}
public static void main(String[] args)
{
int N = 9;
int P[] = new int[]{ 1, 2, 4, 9, 5,
8, 7, 3, 6 };
solve(P, N);
}
}
|
Python3
def solve(P, n):
arr = []
arr.append(0)
for x in P:
arr.append(x)
cnt = 0
for i in range(1, n):
if (arr[i] == i):
arr[i], arr[i + 1] = arr[i + 1], arr[i]
cnt += 1
if (arr[n] == n):
arr[n - 1], arr[n] = arr[n] , arr[n - 1]
cnt += 1
print(cnt)
N = 9
P = [ 1, 2, 4, 9, 5,
8, 7, 3, 6 ]
solve(P, N)
|
C#
using System;
class GFG{
static void solve(int []P, int n)
{
int []arr = new int[n + 1];
arr[0] = 0;
for(int i = 0; i < n; i++)
arr[i + 1] = P[i];
int cnt = 0;
for(int i = 1; i < n; i++)
{
if (arr[i] == i)
{
int t = arr[i + 1];
arr[i + 1] = arr[i];
arr[i] = t;
cnt++;
}
}
if (arr[n] == n)
{
int t = arr[n - 1];
arr[n - 1] = arr[n];
arr[n] = t;
cnt++;
}
Console.WriteLine(cnt);
}
public static void Main(String[] args)
{
int N = 9;
int []P = { 1, 2, 4, 9, 5,
8, 7, 3, 6 };
solve(P, N);
}
}
|
Javascript
<script>
function solve(P, n)
{
let arr = Array.from({length: n+1}, (_, i) => 0);
arr[0] = 0;
for(let i = 0; i < n; i++)
arr[i + 1] = P[i];
let cnt = 0;
for(let i = 1; i < n; i++)
{
if (arr[i] == i)
{
let t = arr[i + 1];
arr[i + 1] = arr[i];
arr[i] = t;
cnt++;
}
}
if (arr[n] == n)
{
let t = arr[n - 1];
arr[n - 1] = arr[n];
arr[n] = t;
cnt++;
}
document.write(cnt);
}
let N = 9;
let P = [ 1, 2, 4, 9, 5,
8, 7, 3, 6 ];
solve(P, N);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)