给定一个正整数数组arr[] ，任务是找到数组的排列，使得相邻元素的总和不能被 3 整除。
注意：如果没有这种排列的数组打印-1。
例子：
Input: arr[] = {1, 2, 3, 4, 5}
Output: 4 1 3 5 2
Explanation:
Sum of adjacent elements =>
arr[0] + arr[1] = 4 + 1 = 5 % 3 != 0
arr[1] + arr[2] = 1 + 3 = 4 % 3 != 0
arr[2] + arr[3] = 3 + 5 = 8 % 3 != 0
arr[3] + arr[4] = 5 + 2 = 7 % 3 != 0
Input: arr[] = {1, 24, 30, 42, 51}
Output: -1
方法：问题中的关键观察是对于所有类型的数字只能存在三种类型的余数，即{0, 1, 2}。因此，我们可以将数字分成三部分，如果我们将余数为 0 的数与余数为 1 或 2 的数排列在一起，则它们的和不能被 3 整除。这样就没有排列，使得它们的相邻元素的总和不能被 3 整除。
下面是上述方法的实现：
C++
// C++ implementation to find the
// permutation of the array such that
// sum of adjacent elements is not
// divisible by 3
#include
using namespace std;
#define hell 1000000007
#define N 100005
// Function to segregate numbers
// based on their remainder
// when divided by three
void count_k(
vector& arr, int& c_0,
int& c_1, int& c_2,
stack& ones,
stack& twos,
stack& zeros)
{
// Loop to iterate over the elements
// of the given array
for (int i = 0; i < arr.size(); i++) {
// Condition to check the
// remainder of the number
if (arr[i] % 3 == 0) {
c_0++;
zeros.push(arr[i]);
}
else if (arr[i] % 3 == 1) {
c_1++;
ones.push(arr[i]);
}
else {
c_2++;
twos.push(arr[i]);
}
}
return;
}
// Function to find the permutation
// of the array such that sum of
// adjacent elements is not divisible by 3
void printArrangement(
vector& arr,
int& c_0, int& c_1, int& c_2,
stack& ones,
stack& twos,
stack& zeros)
{
// Condition to check when
// it's impossible to arrange
if ((c_0 == 0 && c_1 != 0 && c_2 != 0)
or c_0 > c_1 + c_2 + 1) {
cout << "-1";
return;
}
// Condition to check when
// there are no zeros, and
// only ones or only twos
if (c_0 == 0) {
for (int i = 0; i < arr.size(); i++) {
cout << arr[i] << " ";
}
return;
}
// Array to store the permutation
int i, j, ans[N];
memset(ans, -1, sizeof(ans));
// Place the ones on alternate places
// in the answer array,
// leaving spaces for zeros remainder
// elements in the array
for (i = 1, j = 0; j < c_1; i += 2, j++) {
ans[i] = ones.top();
ones.pop();
}
// Adding a zero to
// connect it with a two
ans[i - 1] = zeros.top();
zeros.pop();
c_0--;
// Place the twos on alternate places
// in the answer array,
// leaving spaces for zeros
for (j = 0; j < c_2; j++, i += 2) {
ans[i] = twos.top();
twos.pop();
}
// Fill the zeros finally,
// between the ones and the twos
for (int k = 0; c_0 > 0; k += 2) {
if (ans[k] == -1) {
ans[k] = zeros.top();
c_0--;
}
}
// Print the arrangement of the array
for (int i = 0; i < N; i++) {
if (ans[i] != -1)
cout << ans[i] << " ";
}
return;
}
// Function to solve the problem
void solve(int n,
vector& arr)
{
// As there can be only 3 remainders
stack ones, zeros, twos;
int c_0 = 0, c_1 = 0, c_2 = 0;
count_k(arr, c_0, c_1, c_2,
ones, twos, zeros);
// Function Call
printArrangement(
arr, c_0, c_1, c_2,
ones, twos, zeros);
}
// Driver Code
signed main()
{
int n = 5;
vector arr{ 1, 2, 3, 4, 5 };
solve(n, arr);
return 0;
} Java
// Java implementation to find the
// permutation of the array such that
// sum of adjacent elements is not
// divisible by 3
import java.util.*;
class GFG{
static final int hell = 1000000007;
static final int N = 100005;
static int c_0, c_1, c_2;
// Function to segregate numbers
// based on their remainder
// when divided by three
static void count_k(int []arr,
Stack ones,
Stack twos,
Stack zeros)
{
// Loop to iterate over
// the elements of the
// given array
for (int i = 0; i < arr.length; i++)
{
// Condition to check the
// remainder of the number
if (arr[i] % 3 == 0)
{
c_0++;
zeros.add(arr[i]);
}
else if (arr[i] % 3 == 1)
{
c_1++;
ones.add(arr[i]);
}
else
{
c_2++;
twos.add(arr[i]);
}
}
return;
}
// Function to find the permutation
// of the array such that sum of
// adjacent elements is not divisible by 3
static void printArrangement(int []arr,
Stack ones,
Stack twos,
Stack zeros)
{
// Condition to check when
// it's impossible to arrange
if ((c_0 == 0 && c_1 != 0 && c_2 != 0) ||
c_0 > c_1 + c_2 + 1)
{
System.out.print("-1");
return;
}
// Condition to check when
// there are no zeros, and
// only ones or only twos
if (c_0 == 0)
{
for (int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + " ");
}
return;
}
// Array to store the permutation
int i, j;
int []ans = new int[N];
Arrays.fill(ans, -1);
// Place the ones on alternate places
// in the answer array,
// leaving spaces for zeros remainder
// elements in the array
for (i = 1, j = 0; j < c_1; i += 2, j++)
{
ans[i] = ones.peek();
ones.pop();
}
// Adding a zero to
// connect it with a two
ans[i - 1] = zeros.peek();
zeros.pop();
c_0--;
// Place the twos on alternate places
// in the answer array,
// leaving spaces for zeros
for (j = 0; j < c_2; j++, i += 2)
{
ans[i] = twos.peek();
twos.pop();
}
// Fill the zeros finally,
// between the ones and the twos
for (int k = 0; c_0 > 0; k += 2)
{
if (ans[k] == -1)
{
ans[k] = zeros.peek();
c_0--;
}
}
// Print the arrangement of the array
for (int i1 = 0; i1 < N; i1++)
{
if (ans[i1] != -1)
System.out.print(ans[i1] + " ");
}
return;
}
// Function to solve the problem
static void solve(int n, int []arr)
{
// As there can be only 3 remainders
Stack ones = new Stack();
Stack zeros = new Stack();
Stack twos = new Stack();
c_0 = 0;
c_1 = 0;
c_2 = 0;
count_k(arr, ones, twos, zeros);
// Function Call
printArrangement(arr, ones, twos, zeros);
}
// Driver Code
public static void main(String[] args)
{
int n = 5;
int []arr = {1, 2, 3, 4, 5};
solve(n, arr);
}
}
// This code is contributed by shikhasingrajput Python3
# Python3 implementation to find the
# permutation of the array such that
# sum of adjacent elements is not
# divisible by 3
hell = 1000000007
N = 100005
c_0 = 0
c_1 = 0
c_2 = 0
# Function to segregate numbers
# based on their remainder
# when divided by three
def count_k(arr, ones, twos, zeros):
global c_0, c_1, c_2
# Loop to iterate over
# the elements of the
# given array
for i in range(len(arr)):
# Condition to check the
# remainder of the number
if (arr[i] % 3 == 0):
c_0 += 1
zeros.append(arr[i])
elif (arr[i] % 3 == 1):
c_1 += 1
ones.append(arr[i])
else:
c_2 += 1
twos.append(arr[i])
# Function to find the permutation
# of the array such that sum of
# adjacent elements is not divisible by 3
def printArrangement(arr, ones, twos, zeros):
global c_0, c_1, c_2
# Condition to check when
# it's impossible to arrange
if ((c_0 == 0 and c_1 != 0 and
c_2 != 0) or c_0 > c_1 + c_2 + 1):
print("-1", end = "")
return
# Condition to check when
# there are no zeros, and
# only ones or only twos
if (c_0 == 0):
for i in range(len(arr)):
print(arr[i], end = " ")
return
# Array to store the permutation
ans = [-1] * N
# Place the ones on alternate places
# in the answer array,
# leaving spaces for zeros remainder
# elements in the array
i, j = 1, 0
while (j < c_1):
ans[i] = ones[-1]
ones.pop()
i += 2
j += 1
# Adding a zero to
# connect it with a two
ans[i - 1] = zeros[-1]
zeros.pop()
c_0 -= 1
# Place the twos on alternate
# places in the answer array,
# leaving spaces for zeros
j = 0
while (j < c_2):
ans[i] = twos[-1]
twos.pop()
j += 1
i += 2
# Fill the zeros finally,
# between the ones and the twos
k = 0
while c_0 > 0:
if (ans[k] == -1):
ans[k] = zeros[-1]
c_0 -= 1
k += 2
# Print the arrangement of the array
for i1 in range(N):
if (ans[i1] != -1):
print(ans[i1], end = " ")
return
# Function to solve the problem
def solve(n, arr):
# As there can be only 3 remainders
ones = []
zeros = []
twos = []
count_k(arr, ones, twos, zeros)
# Function Call
printArrangement(arr, ones, twos, zeros)
# Driver Code
n = 5
arr = [ 1, 2, 3, 4, 5 ]
solve(n, arr)
# This code is contributed by divyesh072019C#
// C# implementation to find the
// permutation of the array such that
// sum of adjacent elements is not
// divisible by 3
using System;
using System.Collections.Generic;
class GFG{
static readonly int hell = 1000000007;
static readonly int N = 100005;
static int c_0, c_1, c_2;
// Function to segregate numbers
// based on their remainder
// when divided by three
static void count_k(int []arr,
Stack ones,
Stack twos,
Stack zeros)
{
// Loop to iterate over
// the elements of the
// given array
for (int i = 0; i < arr.Length; i++)
{
// Condition to check the
// remainder of the number
if (arr[i] % 3 == 0)
{
c_0++;
zeros.Push(arr[i]);
}
else if (arr[i] % 3 == 1)
{
c_1++;
ones.Push(arr[i]);
}
else
{
c_2++;
twos.Push(arr[i]);
}
}
return;
}
// Function to find the permutation
// of the array such that sum of
// adjacent elements is not divisible by 3
static void printArrangement(int []arr,
Stack ones,
Stack twos,
Stack zeros)
{
// Condition to check when
// it's impossible to arrange
if ((c_0 == 0 && c_1 != 0 && c_2 != 0) ||
c_0 > c_1 + c_2 + 1)
{
Console.Write("-1");
return;
}
// Condition to check when
// there are no zeros, and
// only ones or only twos
int i;
if (c_0 == 0)
{
for (i = 0; i < arr.Length; i++)
{
Console.Write(arr[i] + " ");
}
return;
}
// Array to store the permutation
int j;
int []ans = new int[N];
for (i = 0; i < ans.Length; i++)
ans[i] = -1;
// Place the ones on alternate places
// in the answer array,
// leaving spaces for zeros remainder
// elements in the array
for (i = 1, j = 0; j < c_1; i += 2, j++)
{
ans[i] = ones.Peek();
ones.Pop();
}
// Adding a zero to
// connect it with a two
ans[i - 1] = zeros.Peek();
zeros.Pop();
c_0--;
// Place the twos on alternate places
// in the answer array,
// leaving spaces for zeros
for (j = 0; j < c_2; j++, i += 2)
{
ans[i] = twos.Peek();
twos.Pop();
}
// Fill the zeros finally,
// between the ones and the twos
for (int k = 0; c_0 > 0; k += 2)
{
if (ans[k] == -1)
{
ans[k] = zeros.Peek();
c_0--;
}
}
// Print the arrangement of the array
for (int i1 = 0; i1 < N; i1++)
{
if (ans[i1] != -1)
Console.Write(ans[i1] + " ");
}
return;
}
// Function to solve the problem
static void solve(int n, int []arr)
{
// As there can be only 3 remainders
Stack ones = new Stack();
Stack zeros = new Stack();
Stack twos = new Stack();
c_0 = 0;
c_1 = 0;
c_2 = 0;
count_k(arr, ones, twos, zeros);
// Function Call
printArrangement(arr, ones, twos, zeros);
}
// Driver Code
public static void Main(String[] args)
{
int n = 5;
int []arr = {1, 2, 3, 4, 5};
solve(n, arr);
}
}
// This code is contributed by Princi Singh 输出
4 1 3 5 2如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。