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

Given an array arr[] of length N and another array P[] containing {a₁, a₂, ... a_k} 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[a_i], arr[a_i+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++ 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 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 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# 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

<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>    

Yes

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

Space Complexity: O(N) as pos vector has been created. Here, N is the size of the array.