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



  1. 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
    
  2. Now, iterate through the array and check if pos[i] = 1 or not.
  3. 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
    
  4. 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
    
  5. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


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.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.



Improved By : ipg2016107

Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.