给定两个分别包含整数元素及其各自类型(类型0或类型1)的数组a []和b [] ,任务是检查是否有可能通过交换元素以非降序对数组进行排序仅限不同类型。
例子:
Input: a[] = {30, 20, 20, 10}, b[] = {1, 1, 1, 1}
Output: No
Explanation:
Since all elements are of same type, no swaps are allowed and the given array is not sorted in non-decreasing order.
Input: a[] = {6, 5, 4}, b[] = {1, 1, 0}
Output: Yes
Explanation:
Swap 4 and 6 to convert the array into non-decreasing order.
方法:
为了解决上述问题,需要注意以下几点:
- 如果数组a []已经以非降序排序,那么答案是是。
- 如果数组a []没有排序,并且所有元素都属于同一类型,则答案为“否”,因为不可能进行交换。
- 在其他情况下,答案是肯定的,因为我们可以随时对数组进行排序。这是因为我们将至少拥有一个其类型与其他元素不同的元素,因此我们可以与所有其他元素进行多次交换,直到所有元素都处于其排序位置。
下面是上述方法的实现:
C++
// C++ program to check if it
// is possible to sort the
// array in non-decreasing
// order by swapping
// elements of different types
#include
using namespace std;
// Function to check if it is
// possible to sort the array
// in non-decreasing order by
// swapping elements of
// different types
bool sorting_possible(int a[],
int b[], int n)
{
// Consider the array
// to be already sorted
bool sorted = true;
int type1 = 0, type0 = 0, i;
// checking if array is
// already sorted
for (i = 1; i < n; i++) {
// Check for a pair which
// is in decreasing order
if (a[i] < a[i - 1]) {
sorted = false;
break;
}
}
// Count the frequency of
// each type of element
for (i = 0; i < n; i++) {
// type0 stores count
// of elements of type 0
if (b[i] == 0)
type0++;
// type1 stores count
// of elements of type 1
else
type1++;
}
// Return true if array
// is already sorted
if (sorted)
return true;
// Return false if all
// elements are of same
// type and array
// is unsorted
else if (type1 == n
|| type0 == n)
return false;
// Possible for all
// other cases
else
return true;
}
// Driver Program
int main()
{
int a[] = { 15, 1, 2, 17, 6 };
int b[] = { 1, 1, 0, 1, 1 };
int n = sizeof(a) / sizeof(a[0]);
bool res = sorting_possible(a, b, n);
if (res)
cout << "Yes";
else
cout << "No";
}
Java
// Java program to check if it is
// possible to sort the array in
// non-decreasing order by swapping
// elements of different types
import java.util.*;
class GFG{
// Function to check if it is
// possible to sort the array
// in non-decreasing order by
// swapping elements of
// different types
static boolean sorting_possible(int a[],
int b[],
int n)
{
// Consider the array
// to be already sorted
boolean sorted = true;
int type1 = 0, type0 = 0, i;
// Checking if array is
// already sorted
for(i = 1; i < n; i++)
{
// Check for a pair which
// is in decreasing order
if (a[i] < a[i - 1])
{
sorted = false;
break;
}
}
// Count the frequency of
// each type of element
for(i = 0; i < n; i++)
{
// type0 stores count
// of elements of type 0
if (b[i] == 0)
type0++;
// type1 stores count
// of elements of type 1
else
type1++;
}
// Return true if array
// is already sorted
if (sorted)
return true;
// Return false if all elements
// are of same type and array
// is unsorted
else if (type1 == n || type0 == n)
return false;
// Possible for all
// other cases
else
return true;
}
// Driver code
public static void main(String[] args)
{
int a[] = { 15, 1, 2, 17, 6 };
int b[] = { 1, 1, 0, 1, 1 };
int n = a.length;
boolean res = sorting_possible(a, b, n);
if (res)
System.out.print("Yes");
else
System.out.print("No");
}
}
// This code is contributed by Rajput-Ji
Python3
# Python3 program to check if it
# is possible to sort the
# array in non-decreasing
# order by swapping
# elements of different types
# Function to check if it is
# possible to sort the array
# in non-decreasing order by
# swapping elements of different types
def sorting_possible(a, b, n):
# Consider the array
# to be already sorted
sorted = True
type1 = 0
type0 = 0
# Checking if array is
# already sorted
for i in range(1, n):
# Check for a pair which
# is in decreasing order
if (a[i] < a[i - 1]):
sorted = False
break
# Count the frequency of
# each type of element
for i in range(n):
# type0 stores count
# of elements of type 0
if (b[i] == 0):
type0 += 1
# type1 stores count
# of elements of type 1
else:
type1 += 1
# Return true if array
# is already sorted
if (sorted != False):
return True
# Return false if all elements
# are of same type and array
# is unsorted
elif (type1 == n or type0 == n):
return False
# Possible for all
# other cases
else:
return True
# Driver code
a = [ 15, 1, 2, 17, 6 ]
b = [ 1, 1, 0, 1, 1 ]
n = len(a)
res = sorting_possible(a, b, n)
if (res != False):
print("Yes")
else:
print("No")
# This code is contributed by sanjoy_62
C#
// C# program to check if it is
// possible to sort the array in
// non-decreasing order by swapping
// elements of different types
using System;
class GFG{
// Function to check if it is
// possible to sort the array
// in non-decreasing order by
// swapping elements of
// different types
static bool sorting_possible(int []a,
int []b,
int n)
{
// Consider the array
// to be already sorted
bool sorted = true;
int type1 = 0, type0 = 0, i;
// Checking if array is
// already sorted
for(i = 1; i < n; i++)
{
// Check for a pair which
// is in decreasing order
if (a[i] < a[i - 1])
{
sorted = false;
break;
}
}
// Count the frequency of
// each type of element
for(i = 0; i < n; i++)
{
// type0 stores count
// of elements of type 0
if (b[i] == 0)
type0++;
// type1 stores count
// of elements of type 1
else
type1++;
}
// Return true if array
// is already sorted
if (sorted)
return true;
// Return false if all elements
// are of same type and array
// is unsorted
else if (type1 == n || type0 == n)
return false;
// Possible for all
// other cases
else
return true;
}
// Driver code
public static void Main(String[] args)
{
int []a = { 15, 1, 2, 17, 6 };
int []b = { 1, 1, 0, 1, 1 };
int n = a.Length;
bool res = sorting_possible(a, b, n);
if (res)
Console.Write("Yes");
else
Console.Write("No");
}
}
// This code is contributed by Rajput-Ji
Javascript
Yes
插图:
a[] = {15, 1, 2, 17, 6}
Only 2 is of type 0 and rest are of type 1.
Hence the following steps leads to a sorted array:
15, 1, 2, 17, 6 – > 15, 1, 6, 17, 2
15, 1, 6, 17, 2 -> 15, 1, 6, 2, 17
15, 1, 6, 2, 17 -> 2, 1, 6, 15, 17
2, 1, 6, 15, 17 -> 1, 2, 6, 15, 17
如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。