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