Related Articles
Reduce array to a single element by repeatedly removing an element from any increasing pair
• Difficulty Level : Medium
• Last Updated : 07 Dec, 2020

Given an array arr[] consisting of permutation in the range [1, N], the task is to check if the given array can be reduced to a single non-zero element by performing the following operations:

Select indices i and j such that i < j and arr[i] < arr[j] and convert one of the two elements to 0.

If it is possible to reduce the array to a single element, then print “Yes” followed by the chosen indices along with the index of the replaced element in each operation. Otherwise, print “No”.

Examples:

Input: arr[] = {2, 4, 6, 1, 3, 5}
Output:
Yes
0 1 1
0 2 2
3 4 3
0 4 4
0 5 5
Explanation:
In the first operation choose the elements 2 and 4 at indices 0 and 1. Convert the element 4 at index 1 to 0, arr[] = {2, 0, 6, 1, 3, 5}
In the second operation choose the elements 2 and 6 at indices 0 and 2. Convert the element 6 at index 2 to 0, arr[] = {2, 0, 0, 1, 3, 5}
In the third operation choose the elements 1 and 3 at indices 3 and 4. Convert the element 1 at index 3 to 0, arr[] = {2, 0, 0, 0, 3, 5}
In the forth operation choose the elements 2 and 3 at indices 0 and 4. Convert the element 3 at index 4 to 0, arr[] = {2, 0, 0, 0, 0, 5}
In the fifth operation choose the elements 2 and 5 at indices 0 and 5. Convert the element 5 at index 5 to 0, arr[] = {2, 0, 0, 0, 0, 0}
So, the array is reduced to a single positive element in 5 operations.

Input: arr[] = {2, 3, 1}
Output: No
Explanation:
There is not set of operations in which the given array can be converted to a single element.

Approach: The idea is to convert all elements from indices [1, N – 2] first to 0 and then eliminate one of either the 0th or (N – 1)th element in the last move to obtain the singleton array. Below are the steps to solve the problem:

1. Choose a valid set of indices on which the given operation can be performed.
2. Now to choose which element to be converted to 0 check the following conditions:
• If the 0th index of the array is a part of these indices, then convert the element at the other index to 0.
• If 0th index is not a part of the chosen indices, then replace the smaller of the two elements to 0.
3. Continue this process until a single positive element remains in the array.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to print the order of` `// indices of converted numbers` `void` `order_of_removal(``int` `a[], ``int` `n)` `{` `    ``// Stores the values of indices` `    ``// with numbers > first index` `    ``queue<``int``> greater_indices;`   `    ``int` `first = a[0];`   `    ``// Stores the index of the closest` `    ``// consecutive number to index 0` `    ``int` `previous_index = 0;`   `    ``// Push the indices into the queue` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``if` `(a[i] > first)` `            ``greater_indices.push(i);` `    ``}`   `    ``// Traverse the queue` `    ``while` `(greater_indices.size() > 0) {`   `        ``// Stores the index of the` `        ``// closest number > arr[0]` `        ``int` `index = greater_indices.front();`   `        ``greater_indices.pop();`   `        ``int` `to_remove = index;`   `        ``// Remove elements present in` `        ``// indices [1, to_remove - 1]` `        ``while` `(--to_remove > previous_index) {`   `            ``cout << to_remove << ``" "` `                 ``<< index << ``" "` `                 ``<< to_remove << endl;` `        ``}`   `        ``cout << 0 << ``" "` `<< index << ``" "` `             ``<< index << endl;`   `        ``// Update the previous_index` `        ``// to index` `        ``previous_index = index;` `    ``}` `}`   `// Function to check if array arr[] can` `// be reduced to single element or not` `void` `canReduced(``int` `arr[], ``int` `N)` `{` `    ``// If array element can't be` `    ``// reduced to single element` `    ``if` `(arr[0] > arr[N - 1]) {` `        ``cout << ``"No"` `<< endl;` `    ``}`   `    ``// Otherwise find the order` `    ``else` `{` `        ``cout << ``"Yes"` `<< endl;` `        ``order_of_removal(arr, N);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 1, 2, 3, 4 };`   `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function Call` `    ``canReduced(arr, N);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach ` `import` `java.util.*;`   `class` `GFG{` `    `  `// Function to print the order of ` `// indices of converted numbers ` `public` `static` `void` `order_of_removal(``int``[] a, ``int` `n) ` `{ ` `    `  `    ``// Stores the values of indices ` `    ``// with numbers > first index` `    ``Queue greater_indices = ``new` `LinkedList<>();` `  `  `    ``int` `first = a[``0``]; ` `  `  `    ``// Stores the index of the closest ` `    ``// consecutive number to index 0 ` `    ``int` `previous_index = ``0``; ` `  `  `    ``// Push the indices into the queue ` `    ``for``(``int` `i = ``1``; i < n; i++) ` `    ``{ ` `        ``if` `(a[i] > first) ` `            ``greater_indices.add(i); ` `    ``} ` `  `  `    ``// Traverse the queue ` `    ``while` `(greater_indices.size() > ``0``) ` `    ``{ ` `        `  `        ``// Stores the index of the ` `        ``// closest number > arr[0] ` `        ``int` `index = greater_indices.peek(); ` `  `  `        ``greater_indices.remove(); ` `  `  `        ``int` `to_remove = index; ` `  `  `        ``// Remove elements present in ` `        ``// indices [1, to_remove - 1] ` `        ``while` `(--to_remove > previous_index) ` `        ``{ ` `            ``System.out.println(to_remove + ``" "` `+` `                                   ``index + ``" "` `+ ` `                                   ``to_remove);` `        ``} ` `  `  `        ``System.out.println(``0` `+ ``" "` `+ index +` `                               ``" "` `+ index);` `  `  `        ``// Update the previous_index ` `        ``// to index ` `        ``previous_index = index; ` `    ``} ` `} ` `  `  `// Function to check if array arr[] can ` `// be reduced to single element or not ` `public` `static` `void` `canReduced(``int``[] arr, ``int` `N) ` `{ ` `    `  `    ``// If array element can't be ` `    ``// reduced to single element ` `    ``if` `(arr[``0``] > arr[N - ``1``]) ` `    ``{ ` `        ``System.out.println(``"No"``);` `    ``} ` `  `  `    ``// Otherwise find the order ` `    ``else` `    ``{ ` `        ``System.out.println(``"Yes"``);` `        ``order_of_removal(arr, N); ` `    ``} ` `}  `   `// Driver Code ` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given array arr[] ` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `}; ` `  `  `    ``int` `N = arr.length;` `  `  `    ``// Function call ` `    ``canReduced(arr, N); ` `}` `}`   `// This code is contributed divyeshrabadiya07`

## Python3

 `# Python3 program for the above approach`   `# Function to print the order of` `# indices of converted numbers` `def` `order_of_removal(a, n) :`   `    ``# Stores the values of indices` `    ``# with numbers > first index` `    ``greater_indices ``=` `[]`   `    ``first ``=` `a[``0``]`   `    ``# Stores the index of the closest` `    ``# consecutive number to index 0` `    ``previous_index ``=` `0`   `    ``# Push the indices into the queue` `    ``for` `i ``in` `range``(``1``, n) :` `        ``if` `(a[i] > first) :` `            ``greater_indices.append(i)`   `    ``# Traverse the queue` `    ``while` `(``len``(greater_indices) > ``0``) :`   `        ``# Stores the index of the` `        ``# closest number > arr[0]` `        ``index ``=` `greater_indices[``0``];`   `        ``greater_indices.pop(``0``)`   `        ``to_remove ``=` `index`   `        ``# Remove elements present in` `        ``# indices [1, to_remove - 1]` `        ``to_remove ``=``-` `1` `        ``while` `(to_remove > previous_index) :`   `            ``print``(to_remove, index, to_remove)`   `        ``print``(``0``, index, index)`   `        ``# Update the previous_index` `        ``# to index` `        ``previous_index ``=` `index`   `# Function to check if array arr[] can` `# be reduced to single element or not` `def` `canReduced(arr, N) :`   `    ``# If array element can't be` `    ``# reduced to single element` `    ``if` `(arr[``0``] > arr[N ``-` `1``]) :` `        ``print``(``"No"``)`   `    ``# Otherwise find the order` `    ``else` `: ` `        ``print``(``"Yes"``)` `        ``order_of_removal(arr, N)`   `# Given array arr[]` `arr ``=` `[ ``1``, ``2``, ``3``, ``4` `]`   `N ``=` `len``(arr)`   `# Function Call` `canReduced(arr, N)`   `# This code is contributed by divyesh072019`

## C#

 `// C# program for ` `// the above approach ` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `    `  `// Function to print the order of ` `// indices of converted numbers ` `public` `static` `void` `order_of_removal(``int``[] a, ` `                                    ``int` `n) ` `{ ` `  ``// Stores the values of indices ` `  ``// with numbers > first index` `  ``Queue<``int``> greater_indices = ``new` `Queue<``int``>();`   `  ``int` `first = a[0]; `   `  ``// Stores the index of the closest ` `  ``// consecutive number to index 0 ` `  ``int` `previous_index = 0; `   `  ``// Push the indices into the queue ` `  ``for``(``int` `i = 1; i < n; i++) ` `  ``{ ` `    ``if` `(a[i] > first) ` `      ``greater_indices.Enqueue(i); ` `  ``} `   `  ``// Traverse the queue ` `  ``while` `(greater_indices.Count > 0) ` `  ``{ ` `    ``// Stores the index of the ` `    ``// closest number > arr[0] ` `    ``int` `index = greater_indices.Peek(); `   `    ``greater_indices.Dequeue(); `   `    ``int` `to_remove = index; `   `    ``// Remove elements present in ` `    ``// indices [1, to_remove - 1] ` `    ``while` `(--to_remove > previous_index) ` `    ``{ ` `      ``Console.WriteLine(to_remove + ``" "` `+ ` `                        ``index + ``" "` `+ to_remove);` `    ``} `   `    ``Console.WriteLine(0 + ``" "` `+ index + ` `                      ``" "` `+ index);`   `    ``// Update the previous_index ` `    ``// to index ` `    ``previous_index = index; ` `  ``} ` `} `   `// Function to check if array []arr can ` `// be reduced to single element or not ` `public` `static` `void` `canReduced(``int``[] arr, ` `                              ``int` `N) ` `{` `  ``// If array element can't be ` `  ``// reduced to single element ` `  ``if` `(arr[0] > arr[N - 1]) ` `  ``{ ` `    ``Console.WriteLine(``"No"``);` `  ``} `   `  ``// Otherwise find the order ` `  ``else` `  ``{ ` `    ``Console.WriteLine(``"Yes"``);` `    ``order_of_removal(arr, N); ` `  ``} ` `}  `   `// Driver Code ` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given array []arr ` `  ``int` `[]arr = {1, 2, 3, 4}; `   `  ``int` `N = arr.Length;`   `  ``// Function call ` `  ``canReduced(arr, N); ` `}` `}`   `// This code is contributed by Rajput-Ji`

Output:

```Yes
0 1 1
0 2 2
0 3 3```

Time Complexity: O(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
Recommended Articles
Page :