Rearrange an Array such that Sum of same-indexed subsets differ from their Sum in the original Array

Given an array A[] consisting of N distinct integers, the task is to rearrange the given array such that the sum of every same-indexed non-empty subsets of size less than N, is not equal to their sum in the original array.

Examples:

Input: A[] = {1000, 100, 10, 1}
Output: 100 10 1 1000
Explanation:
Original Array A[] = {1000, 100, 10, 1}
Final Array B[] = {100, 10, 1, 1000}
Subsets of size 1:

A[0] = 1000  B[0] = 100
A[1] = 100   B[1] = 10
A[2] = 10    B[2] = 1
A[3] = 1     B[3] = 1000

Subsets of size 2:

{A[0], A[1]} = 1100  {B[0], B[1]} = 110
{A[0], A[2]} = 1010  {B[0], B[2]} = 101
{A[1], A[2]} = 110   {B[1], B[2]} = 11
.....
Similarly, all same-indexed subsets of size 2 have a different sum.

Subsets of size 3:



{A[0], A[1], A[2]} = 1110  {B[0], B[1], B[2]} = 111
{A[0], A[2], A[3]} = 1011 {B[0], B[2], B[3]} = 1101
{A[1], A[2], A[3]} = 111  {B[1], B[2], B[3]} = 1011

Therefore, no same-indexed subsets have equal sum.

Input: A[] = {1, 2, 3, 4, 5}
Output: 5 1 2 3 4

Approach:
The idea is to simply replace every array element except one, by a smaller element. Follow the steps below to solve the problem:

  • Store the array elements in pairs of {A[i], i}.
  • Sort the pairs in ascending order of the array elements
  • Now, traverse the sorted order, and insert each element at the original index of its next greater element(i.e. at the index v[(i + 1) % n].second). This ensures that every index except one, now has a smaller element than the previous value stored in it.

Proof:
Let S = { arr1, arr2, …, arrk } be a subset.
If u does not belong to S initially, upon insertion of u into S, the sum of the subset changes.
Similarly, if u belongs to S, let S’ contains all the elements not present in S. This means that u do not belong to S’. Then, by the same reasoning above, the sum of the subset S’ differs from its original sum.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to rearrange the array such
// that no same-indexed subset have sum
// equal to that in the original array
void printNewArray(vector<int> a, int n)
{
    // Initialize a vector
    vector<pair<int, int> > v;
  
    // Iterate the array
    for (int i = 0; i < n; i++) {
  
        v.push_back({ a[i], i });
    }
  
    // Sort the vector
    sort(v.begin(), v.end());
  
    int ans[n];
  
    // Shift of elements to the
    // index of its next cyclic element
    for (int i = 0; i < n; i++) {
        ans[v[(i + 1) % n].second]
            = v[i].first;
    }
  
    // Print the answer
    for (int i = 0; i < n; i++) {
        cout << ans[i] << " ";
    }
}
  
// Driver Code
int main()
{
    vector<int> a = { 4, 1, 2, 5, 3 };
  
    int n = a.size();
  
    printNewArray(a, n);
  
    return 0;
}

chevron_right


Output:

3 5 1 4 2

Time Complexity: O(N log N)
Auxiliary Space: O(N)

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.