Skip to content
Related Articles

Related Articles

Improve Article

Check if the array can be sorted only if the elements on given positions can be swapped

  • Last Updated : 08 Sep, 2021

Given an array arr[] of length N and another array P[] containing {a1, a2, … ak} which represents the positions of the given array arr[], the task is to check if the array can be sorted by only swapping the elements’ arr[ai], arr[ai+1] where ‘i’ is some element in the array P[].
Examples: 

Input: arr[] = {3, 2, 1}, P[] = {1, 2} 
Output: Yes 
Explanation: 
Initially, i = 1 (i.e.) first element and second element are swapped. Therefore, arr[0] <=> arr[1]. arr[] = {2, 3, 1}. 
Similarly, i = 2 (i.e.) second element and third element are swapped. arr[] = {2, 1, 3}. 
Finally, i = 1 (i.e.) first element and second element are swapped. arr[] = {1, 2, 3}. 
Since this array is sorted, therefore, the given array can be sorted. 
Input: arr[] = {5, 3, -4, 1, 12}, P[] = {2, 4, 3} 
Output: No 
 

Approach: The idea is to use two pointer approach to check if the array can be sorted or not.  

  • Initially, we create a position array pos[] of size N. This array will be used to mark the given positions in the array P[]. That is:
if j = ai (1 ≤ i ≤ K)
then the element pos[ai-1] will be 1
else 0
  • Now, iterate through the array and check if pos[i] = 1 or not.
  • If we encounter the pos[i]=1, we store the iterator in a temporary variable, and then we increment the iterator with value 1, till we have pos[i]=1 continuously, i.e.,
j = i
while (j < N and pos[j]) 
    j=j+1
  • After this increment, we sort this segment that we obtained from i to j+1 and finally, check after the position j, in the vector that we have to check, because we have sorted till this segment.
Sort(arr[i] to arr[j+1])
i=j
  • Finally, after this loop completion, we have to check if the array has been sorted or not.

Below is the implementation of the above approach: 
 

C++




// C++ program to check if the array
// can be sorted only if the elements
// on the given positions can be swapped
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the array can
// be sorted only if the elements on
// the given positions can be swapped
void check_vector(vector<int> A, int n,
                vector<int> p)
{
 
    // Creating an array for marking
    // the positions
    vector<int> pos(A.size());
 
    // Iterating through the array and
    // mark the positions
    for (int i = 0; i < p.size(); i++) {
        pos[p[i] - 1] = 1;
    }
 
    int flag = 1;
 
    // Iterating through the given array
    for (int i = 0; i < n; i++) {
        if (pos[i] == 0)
            continue;
        int j = i;
 
        // If pos[i] is 1, then incrementing
        // till 1 is continuously present in pos
        while (j < n && pos[j])
            ++j;
 
        // Sorting the required segment
        sort(A.begin() + i, A.begin() + j + 1);
        i = j;
    }
 
    // Checking if the vector is sorted or not
    for (int i = 0; i < n - 1; i++) {
        if (A[i] > A[i + 1]) {
            flag = 0;
            break;
        }
    }
 
    // Print yes if it is sorted
    if (flag == 1)
        cout << "Yes";
    else
        cout << "No";
}
 
// Driver code
int main()
{
    vector<int> A{ 3, 2, 1 };
    vector<int> p{ 1, 2 };
 
    check_vector(A, A.size(), p);
    return 0;
}

Java




// Java program to check if the array
// can be sorted only if the elements
// on the given positions can be swapped
import java.util.Arrays;
 
class GFG{
     
// Function to check if the array can
// be sorted only if the elements on
// the given positions can be swapped
public static void check_vector(int[] A,
                                int n,
                                int[] p)
{
 
    // Creating an array for marking
    // the positions
    int[] pos = new int[A.length];
 
    // Iterating through the array and
    // mark the positions
    for(int i = 0; i < p.length; i++)
    {
        pos[p[i] - 1] = 1;
    }
 
    int flag = 1;
 
    // Iterating through the given array
    for(int i = 0; i < n; i++)
    {
        if (pos[i] == 0)
            continue;
             
        int j = i;
 
        // If pos[i] is 1, then incrementing
        // till 1 is continuously present in pos
        while (j < n && pos[j] != 0)
            ++j;
 
        // Sorting the required segment
        Arrays.sort(A, i, j + 1);
        i = j;
    }
 
    // Checking if the vector is sorted or not
    for(int i = 0; i < n - 1; i++)
    {
        if (A[i] > A[i + 1])
        {
            flag = 0;
            break;
        }
    }
 
    // Print yes if it is sorted
    if (flag == 1)
        System.out.print("Yes");
    else
        System.out.print("No");
}
 
// Driver code
public static void main(String[] args)
{
    int A[] = { 3, 2, 1 };
    int p[] = { 1, 2 };
     
    check_vector(A, A.length, p);
}
}
 
// This code is contributed by divyeshrabadiya07

Python3




# Python3 program to check if the array
# can be sorted only if the elements
# on the given positions can be swapped
 
# Function to check if the array can
# be sorted only if the elements on
# the given positions can be swapped
def check_vector(A, n, p):
     
    # Creating an array for marking
    # the positions
    pos = [0 for i in range(len(A))]
 
    # Iterating through the array and
    # mark the positions
    for i in range(len(p)):
        pos[p[i] - 1] = 1
 
    flag = 1
 
    # Iterating through the given array
    for i in range(n):
        if (pos[i] == 0):
            continue
        j = i
 
        # If pos[i] is 1, then incrementing
        # till 1 is continuously present in pos
        while (j < n and pos[j]):
            j += 1
 
        # Sorting the required segment
        p = A[: i]
        q = A[i : i + j + 1]
        r = A[i + j + 1 : len(A)]
         
        q.sort(reverse = False)
        A = p + q + r
        i = j
 
    # Checking if the vector is sorted or not
    for i in range(n - 1):
        if (A[i] > A[i + 1]):
            flag = 0
            break
 
    # Print yes if it is sorted
    if (flag == 1):
        print("Yes")
    else:
        print("No");
 
# Driver code
if __name__ == '__main__':
     
    A = [ 3, 2, 1 ]
    p = [ 1, 2 ]
 
    check_vector(A,len(A), p)
 
# This code is contributed by Samarth

C#




// C# program to check
// if the array can be
// sorted only if the
// elements on the given
// positions can be swapped
using System;
class GFG{
     
// Function to check if the array can
// be sorted only if the elements on
// the given positions can be swapped
public static void check_vector(int[] A,
                                int n,
                                int[] p)
{
  // Creating an array for marking
  // the positions
  int[] pos = new int[A.Length];
 
  // Iterating through the array and
  // mark the positions
  for(int i = 0; i < p.Length; i++)
  {
    pos[p[i] - 1] = 1;
  }
 
  int flag = 1;
 
  // Iterating through the given array
  for(int i = 0; i < n; i++)
  {
    if (pos[i] == 0)
      continue;
 
    int j = i;
 
    // If pos[i] is 1, then
    // incrementing till 1
    // is continuously present in pos
    while (j < n && pos[j] != 0)
      ++j;
 
    // Sorting the required segment
    Array.Sort(A, i, j + 1);
    i = j;
  }
 
  // Checking if the vector
  // is sorted or not
  for(int i = 0; i < n - 1; i++)
  {
    if (A[i] > A[i + 1])
    {
      flag = 0;
      break;
    }
  }
 
  // Print yes if it is sorted
  if (flag == 1)
    Console.Write("Yes");
  else
    Console.Write("No");
}
 
// Driver code
public static void Main()
{
  int[] A = {3, 2, 1};
  int[] p = {1, 2};
  check_vector(A, A.Length, p);
}
}
 
// This code is contributed by Chitranayal

Javascript




<script>
// Javascript program to check if the array
// can be sorted only if the elements
// on the given positions can be swapped
 
// Function to check if the array can
// be sorted only if the elements on
// the given positions can be swapped
function check_vector(A, n, p)
{
 
    // Creating an array for marking
    // the positions
    var pos = A.length;
 
    // Iterating through the array and
    // mark the positions
    for (var i = 0; i < p.length; i++) {
        pos[p[i] - 1] = 1;
    }
 
    var flag = 1;
 
    // Iterating through the given array
    for (var i = 0; i < n; i++) {
        if (pos[i] == 0)
            continue;
        var j = i;
 
        // If pos[i] is 1, then incrementing
        // till 1 is continuously present in pos
        while (j < n && pos[j])
            ++j;
 
        // Sorting the required segment
         A = Array.prototype.concat(
         A.slice(0, i),
         A.slice(i+1, j+1).sort((a,b)=>a-b),
         A.slice(j+2).sort((a,b)=>a-b));
         
        i = j;
    }
 
    // Checking if the vector is sorted or not
    for (var i = 0; i < n - 1; i++) {
        if (A[i] > A[i + 1]) {
            flag = 0;
            break;
        }
    }
 
    // Print yes if it is sorted
    if (flag == 1)
        document.write( "Yes");
    else
        document.write( "No");
}
 
// Driver code
var A = [ 3, 2, 1 ];
var p = [ 1, 2 ];
check_vector(A, A.length, p);
 
// This code is contributed by noob2000.
</script>
Output: 



Yes

 

Time Complexity: O(N * log(N)), where N is the size of the array.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :