# 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 <=> arr. 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 `// C++ program to check if the array ` `// can be sorted only if the elements ` `// on the given positions can be swapped ` ` `  `#include ` `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; ` `} `

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

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.