Minimize Steps required to obtain Sorted Order of an Array

Given an array arr[] consisting of a permutation of integers [1, N], derived by rearranging the sorted order [1, N], the task is to find the minimum number of steps after which the sorted order [1, N] is repeated, by repeating the same process by which arr[] is obtained from the sorted sequence at each step.
Examples: 

Input: arr[ ] = {3, 6, 5, 4, 1, 2} 
Output:
Explanation: 
Increasing Permutation: {1, 2, 3, 4, 5, 6} 
Step 1 : arr[] = {3, 6, 5, 4, 1, 2} (Given array) 
Step 2 : arr[] = {5, 2, 1, 4, 3, 6} 
Step 3 : arr[] = {1, 6, 3, 4, 5, 2} 
Step 4 : arr[] = {3, 2, 5, 4, 1, 6} 
Step 5 : arr[] = {5, 6, 1, 4, 3, 2} 
Step 6 : arr[] = {1, 2, 3, 4, 5, 6} (Increasing Permutation) 
Therefore, the total number of steps required are 6.

Input: arr[ ] = [5, 1, 4, 3, 2] 
Output:
 

Approach: 
This problem can be solved simply by using the concept of Direct Addressing. Follow the steps given below to solve the problem: 

Below is the implementation of the above approach:



filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement 
// the above approach 
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to find 
// GCD of two numbers 
int gcd(int a, int b) 
    if (b == 0) 
        return a; 
  
    return gcd(b, a % b); 
  
// Function to calculate the 
// LCM of array elements 
int findlcm(int arr[], int n) 
    // Initialize result 
    int ans = 1; 
  
    for (int i = 1; i <= n; i++) 
        ans = (((arr[i] * ans)) 
            / (gcd(arr[i], ans))); 
  
    return ans; 
  
// Function to find minimum steps 
// required to obtain sorted sequence 
void minimumSteps(int arr[], int n) 
  
    // Inititalize dat[] array for 
    // Direct Address Table. 
    int i, dat[n + 1]; 
  
    for (i = 1; i <= n; i++) 
  
        dat[arr[i - 1]] = i; 
  
    int b[n + 1], j = 0, c; 
  
    // Calculating steps required 
    // for each element to reach 
    // its sorted position 
    for (i = 1; i <= n; i++) { 
        c = 1; 
        j = dat[i]; 
        while (j != i) { 
            c++; 
            j = dat[j]; 
        
        b[i] = c; 
    
  
    // Calculate LCM of the array 
    cout << findlcm(b, n); 
  
// Driver Code 
int main() 
  
    int arr[] = { 5, 1, 4, 3, 2, 7, 6 }; 
  
    int N = sizeof(arr) / sizeof(arr[0]); 
  
    minimumSteps(arr, N); 
  
    return 0; 
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
class GFG{
      
// Function to find
// GCD of two numbers
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
  
    return gcd(b, a % b);
}
  
// Function to calculate the
// LCM of array elements
static int findlcm(int arr[], int n)
{
      
    // Initialize result
    int ans = 1;
  
    for(int i = 1; i <= n; i++)
        ans = (((arr[i] * ans)) / 
            (gcd(arr[i], ans)));
  
    return ans;
}
  
// Function to find minimum steps
// required to obtain sorted sequence
static void minimumSteps(int arr[], int n)
{
  
    // Inititalize dat[] array for
    // Direct Address Table.
    int i;
    int dat[] = new int[n + 1];
  
    for(i = 1; i <= n; i++)
        dat[arr[i - 1]] = i;
  
    int b[] = new int[n + 1];
    int j = 0, c;
  
    // Calculating steps required
    // for each element to reach
    // its sorted position
    for(i = 1; i <= n; i++)
    {
        c = 1;
        j = dat[i];
          
        while (j != i) 
        {
            c++;
            j = dat[j];
        }
        b[i] = c;
    }
  
    // Calculate LCM of the array
    System.out.println(findlcm(b, n));
}
  
// Driver code    
public static void main(String[] args)
{
    int arr[] = { 5, 1, 4, 3, 2, 7, 6 };
  
    int N = arr.length;
  
    minimumSteps(arr, N);
}
}
  
// This code is contributed by rutvik_56
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement 
# the above approach 
  
# Function to find 
# GCD of two numbers 
def gcd(a, b): 
  
    if(b == 0): 
        return
  
    return gcd(b, a % b) 
  
# Function to calculate the 
# LCM of array elements 
def findlcm(arr, n): 
  
    # Initialize result 
    ans = 1
  
    for i in range(1, n + 1): 
        ans = ((arr[i] * ans) //
            (gcd(arr[i], ans))) 
  
    return ans 
  
# Function to find minimum steps 
# required to obtain sorted sequence 
def minimumSteps(arr, n): 
  
    # Inititalize dat[] array for 
    # Direct Address Table. 
    dat = [0] * (n + 1
  
    for i in range(1, n + 1): 
        dat[arr[i - 1]] =
  
    b = [0] * (n + 1
    j = 0
  
    # Calculating steps required 
    # for each element to reach 
    # its sorted position 
    for i in range(1, n + 1): 
        c = 1
        j = dat[i] 
        while(j != i): 
            c += 1
            j = dat[j] 
  
        b[i] =
  
    # Calculate LCM of the array 
    print(findlcm(b, n)) 
  
# Driver Code 
arr = [ 5, 1, 4, 3, 2, 7, 6
  
N = len(arr) 
  
minimumSteps(arr, N) 
  
# This code is contributed by Shivam Singh 
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
  
class GFG{
      
// Function to find
// GCD of two numbers
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
  
    return gcd(b, a % b);
}
  
// Function to calculate the
// LCM of array elements
static int findlcm(int []arr, int n)
{
      
    // Initialize result
    int ans = 1;
  
    for(int i = 1; i <= n; i++)
        ans = (((arr[i] * ans)) / 
            (gcd(arr[i], ans)));
  
    return ans;
}
  
// Function to find minimum steps
// required to obtain sorted sequence
static void minimumSteps(int []arr, int n)
{
  
    // Inititalize dat[] array for
    // Direct Address Table.
    int i;
    int []dat = new int[n + 1];
  
    for(i = 1; i <= n; i++)
        dat[arr[i - 1]] = i;
  
    int []b = new int[n + 1];
    int j = 0, c;
  
    // Calculating steps required
    // for each element to reach
    // its sorted position
    for(i = 1; i <= n; i++)
    {
        c = 1;
        j = dat[i];
          
        while (j != i) 
        {
            c++;
            j = dat[j];
        }
        b[i] = c;
    }
  
    // Calculate LCM of the array
    Console.WriteLine(findlcm(b, n));
}
  
// Driver code 
public static void Main(String[] args)
{
    int []arr = { 5, 1, 4, 3, 2, 7, 6 };
  
    int N = arr.Length;
  
    minimumSteps(arr, N);
}
}
  
// This code is contributed by gauravrajput1 
chevron_right

Output: 
6

Time Complexity: O(NlogN) 
Auxiliary Space: O(N)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.





Exploring the Coding World

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :
Practice Tags :