Skip to content
Related Articles

Related Articles

Remove minimum elements from either side such that 2*min becomes more than max | Set 2

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 24 Mar, 2020

Given an unsorted array, trim the array such that twice of minimum is greater than the maximum in the trimmed array. Elements should be removed from either end of the array. The number of removals should be minimum.

Examples:

Input: arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200}
Output: 4
We need to remove 4 elements (4, 5, 100, 200)
so that 2*min becomes more than max.

Input: arr[] = {4, 7, 5, 6}
Output: 0
We don’t need to remove any element as
4*2 > 7

Input: arr[] = {20, 7, 5, 6}
Output: 1

Approach: We have discussed various approaches to solve this problem in O(n3), O(n2 * logn), and O(n2) time in previous article. In this articles, we are going to discuss a O(n * logn) time solution using Sliding Window and Segment Tree concepts.

  1. Construct Segment Tree for RangeMinimumQuery and RangeMaximumQuery for the given input array.
  2. Take two pointers start and end, and initialize both to 0.
  3. While end is less than the length of the input array, do the following:
    • Find min and max in the current window using Segment Trees constructed in step 1.
    • Check if 2 * min ≤ max, if so then increment start pointer else update max valid length so far, if required
    • Increment end
  4. length(arr[]) – maxValidLength is the required answer.

Below is the implementation of the above approach:

Java




// Java implementation of the approach
public class GFG {
  
    // Function to return the minimum removals
    // required so that the array satisfy
    // the given condition
    public int removeMinElements(int[] a)
    {
        int n = a.length;
  
        RangeMinimumQuery rMimQ = new RangeMinimumQuery();
        int[] minTree = rMimQ.createSegmentTree(a);
  
        RangeMaximumQuery rMaxQ = new RangeMaximumQuery();
        int[] maxTree = rMaxQ.createSegmentTree(a);
  
        int start = 0, end = 0;
  
        // To store min and max in the current window
        int min, max;
        int maxValidLen = 0;
  
        while (end < n) {
            min = rMimQ.rangeMinimumQuery(minTree,
                                          start, end, n);
            max = rMaxQ.rangeMaximumQuery(maxTree,
                                          start, end, n);
            if (2 * min <= max)
                start++;
            else
                maxValidLen = Math.max(maxValidLen,
                                       end - start + 1);
            end++;
        }
        return n - maxValidLen;
    }
  
    class RangeMinimumQuery {
  
        // Creates a new segment tree from
        // the given input array
        public int[] createSegmentTree(int[] input)
        {
            int n = input.length;
            int segTreeSize = 2 * getNextPowerOfTwo(n) - 1;
            int[] segmentTree = new int[segTreeSize];
  
            createSegmentTreeUtil(segmentTree, input,
                                  0, n - 1, 0);
            return segmentTree;
        }
  
        private void createSegmentTreeUtil(int[] segmentTree,
                                           int[] input, int low,
                                           int high, int pos)
        {
            if (low == high) {
  
                // Its a leaf node
                segmentTree[pos] = input[low];
                return;
            }
  
            // Construct left and right subtrees and then
            // update value for current node
            int mid = (low + high) / 2;
            createSegmentTreeUtil(segmentTree, input, low,
                                  mid, (2 * pos + 1));
            createSegmentTreeUtil(segmentTree, input,
                                  mid + 1, high, (2 * pos + 2));
            segmentTree[pos] = Math.min(segmentTree[2 * pos + 1],
                                        segmentTree[2 * pos + 2]);
        }
  
        public int rangeMinimumQuery(int[] segmentTree, int from,
                                     int to, int inputSize)
        {
            return rangeMinimumQueryUtil(segmentTree, 0,
                                         inputSize - 1, from, to, 0);
        }
  
        private int rangeMinimumQueryUtil(int[] segmentTree, int low,
                                        int high, int from, int to, int pos)
        {
            // Total overlap
            if (from <= low && to >= high) {
                return segmentTree[pos];
            }
  
            // No overlap
            if (from > high || to < low) {
                return Integer.MAX_VALUE;
            }
  
            // Partial overlap
            int mid = (low + high) / 2;
            int left = rangeMinimumQueryUtil(segmentTree, low,
                                             mid, from, to,
                                             (2 * pos + 1));
            int right = rangeMinimumQueryUtil(segmentTree,
                                              mid + 1, high, from,
                                              to, (2 * pos + 2));
            return Math.min(left, right);
        }
    }
  
    class RangeMaximumQuery {
  
        // Creates a new segment tree from given input array
        public int[] createSegmentTree(int[] input)
        {
            int n = input.length;
            int segTreeSize = 2 * getNextPowerOfTwo(n) - 1;
            int[] segmentTree = new int[segTreeSize];
  
            createSegmentTreeUtil(segmentTree, input, 0, n - 1, 0);
            return segmentTree;
        }
  
        private void createSegmentTreeUtil(int[] segmentTree, int[] input,
                                           int low, int high, int pos)
        {
            if (low == high) {
  
                // Its a leaf node
                segmentTree[pos] = input[low];
                return;
            }
  
            // Construct left and right subtrees and then
            // update value for current node
            int mid = (low + high) / 2;
            createSegmentTreeUtil(segmentTree, input, low,
                                  mid, (2 * pos + 1));
            createSegmentTreeUtil(segmentTree, input,
                                  mid + 1, high, (2 * pos + 2));
            segmentTree[pos] = Math.max(segmentTree[2 * pos + 1],
                                        segmentTree[2 * pos + 2]);
        }
  
        public int rangeMaximumQuery(int[] segmentTree,
                                     int from, int to, int inputSize)
        {
            return rangeMaximumQueryUtil(segmentTree, 0,
                                         inputSize - 1, from, to, 0);
        }
  
        private int rangeMaximumQueryUtil(int[] segmentTree, int low,
                                 int high, int from, int to, int pos)
        {
            // Total overlap
            if (from <= low && to >= high) {
                return segmentTree[pos];
            }
  
            // No overlap
            if (from > high || to < low) {
                return Integer.MIN_VALUE;
            }
  
            // Partial overlap
            int mid = (low + high) / 2;
            int left = rangeMaximumQueryUtil(segmentTree, low,
                                             mid, from, to,
                                             (2 * pos + 1));
            int right = rangeMaximumQueryUtil(segmentTree,
                                              mid + 1, high, from,
                                              to, (2 * pos + 2));
            return Math.max(left, right);
        }
    }
  
    // Function to return the minimum power of 2
    // which is greater than n
    private int getNextPowerOfTwo(int n)
    {
        int logPart = (int)Math.ceil(Math.log(n)
                                     / Math.log(2));
        return (int)Math.pow(2, logPart);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int[] a = { 4, 5, 100, 9, 10, 11, 12, 15, 200 };
        GFG gfg = new GFG();
        System.out.println(gfg.removeMinElements(a));
    }
}

C#



// C# implementation of the approach
using System;
  
class GFG
{
  
    // Function to return the minimum removals
    // required so that the array satisfy
    // the given condition
    static int removeMinElements(int[] a)
    {
        int n = a.Length;
  
        RangeMinimumQuery rMimQ = new RangeMinimumQuery();
        int[] minTree = rMimQ.createSegmentTree(a);
  
        RangeMaximumQuery rMaxQ = new RangeMaximumQuery();
        int[] maxTree = rMaxQ.createSegmentTree(a);
  
        int start = 0, end = 0;
  
        // To store min and max in the current window
        int min, max;
        int maxValidLen = 0;
  
        while (end < n) 
        {
            min = rMimQ.rangeMinimumQuery(minTree,
                                        start, end, n);
            max = rMaxQ.rangeMaximumQuery(maxTree,
                                        start, end, n);
            if (2 * min <= max)
                start++;
            else
                maxValidLen = Math.Max(maxValidLen,
                                    end - start + 1);
            end++;
        }
        return n - maxValidLen;
    }
  
    class RangeMinimumQuery {
  
        // Creates a new segment tree from
        // the given input array
        public int[] createSegmentTree(int[] input)
        {
            int n = input.Length;
            int segTreeSize = 2 * getNextPowerOfTwo(n) - 1;
            int[] segmentTree = new int[segTreeSize];
  
            createSegmentTreeUtil(segmentTree, input,
                                0, n - 1, 0);
            return segmentTree;
        }
  
        public void createSegmentTreeUtil(int[] segmentTree,
                                        int[] input, int low,
                                        int high, int pos)
        {
            if (low == high) {
  
                // Its a leaf node
                segmentTree[pos] = input[low];
                return;
            }
  
            // Construct left and right subtrees and then
            // update value for current node
            int mid = (low + high) / 2;
            createSegmentTreeUtil(segmentTree, input, low,
                                mid, (2 * pos + 1));
            createSegmentTreeUtil(segmentTree, input,
                                mid + 1, high, (2 * pos + 2));
            segmentTree[pos] = Math.Min(segmentTree[2 * pos + 1],
                                        segmentTree[2 * pos + 2]);
        }
  
        public int rangeMinimumQuery(int[] segmentTree, int from,
                                    int to, int inputSize)
        {
            return rangeMinimumQueryUtil(segmentTree, 0,
                                        inputSize - 1, from, to, 0);
        }
  
        static int rangeMinimumQueryUtil(int[] segmentTree, int low,
                                        int high, int from, int to, int pos)
        {
            // Total overlap
            if (from <= low && to >= high) {
                return segmentTree[pos];
            }
  
            // No overlap
            if (from > high || to < low) {
                return int.MaxValue;
            }
  
            // Partial overlap
            int mid = (low + high) / 2;
            int left = rangeMinimumQueryUtil(segmentTree, low,
                                            mid, from, to,
                                            (2 * pos + 1));
            int right = rangeMinimumQueryUtil(segmentTree,
                                            mid + 1, high, from,
                                            to, (2 * pos + 2));
            return Math.Min(left, right);
        }
    }
  
    class RangeMaximumQuery {
  
        // Creates a new segment tree from given input array
        public int[] createSegmentTree(int[] input)
        {
            int n = input.Length;
            int segTreeSize = 2 * getNextPowerOfTwo(n) - 1;
            int[] segmentTree = new int[segTreeSize];
  
            createSegmentTreeUtil(segmentTree, input, 0, n - 1, 0);
            return segmentTree;
        }
  
        public void createSegmentTreeUtil(int[] segmentTree, int[] input,
                                        int low, int high, int pos)
        {
            if (low == high) {
  
                // Its a leaf node
                segmentTree[pos] = input[low];
                return;
            }
  
            // Construct left and right subtrees and then
            // update value for current node
            int mid = (low + high) / 2;
            createSegmentTreeUtil(segmentTree, input, low,
                                mid, (2 * pos + 1));
            createSegmentTreeUtil(segmentTree, input,
                                mid + 1, high, (2 * pos + 2));
            segmentTree[pos] = Math.Max(segmentTree[2 * pos + 1],
                                        segmentTree[2 * pos + 2]);
        }
  
        public int rangeMaximumQuery(int[] segmentTree,
                                    int from, int to, int inputSize)
        {
            return rangeMaximumQueryUtil(segmentTree, 0,
                                        inputSize - 1, from, to, 0);
        }
  
        public int rangeMaximumQueryUtil(int[] segmentTree, int low,
                                int high, int from, int to, int pos)
        {
            // Total overlap
            if (from <= low && to >= high) {
                return segmentTree[pos];
            }
  
            // No overlap
            if (from > high || to < low) {
                return int.MinValue;
            }
  
            // Partial overlap
            int mid = (low + high) / 2;
            int left = rangeMaximumQueryUtil(segmentTree, low,
                                            mid, from, to,
                                            (2 * pos + 1));
            int right = rangeMaximumQueryUtil(segmentTree,
                                            mid + 1, high, from,
                                            to, (2 * pos + 2));
            return Math.Max(left, right);
        }
    }
  
    // Function to return the minimum power of 2
    // which is greater than n
    static int getNextPowerOfTwo(int n)
    {
        int logPart = (int)Math.Ceiling(Math.Log(n)
                                    / Math.Log(2));
        return (int)Math.Pow(2, logPart);
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int[] a = { 4, 5, 100, 9, 10, 11, 12, 15, 200 };
        Console.WriteLine(removeMinElements(a));
    }
}
  
// This code is contributed by Rajput-Ji
Output:
4


My Personal Notes
arrow_drop_up
Previous
Maximum count of pairs which generate the same sum
Next

Find a pair from the given array with maximum nCr value
Recommended Articles
Page :
Remove minimum elements from either side such that 2*min becomes more than max
03, May 14
Remove minimum elements from the array such that 2*min becomes more than max
18, Jul 19
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Check if there exists a pair (a, b) such that for all the N pairs either of the element should be equal to either a or b
04, Jul 21
Remove minimum elements from array such that no three consecutive element are either increasing or decreasing
12, May 17
Minimum value to be assigned to the elements so that sum becomes greater than initial sum
09, Oct 19
Count smaller elements on right side and greater elements on left side using Binary Index Tree
09, Aug 19
Remove elements from the array which appear more than k times
10, Nov 18
For each A[i] find smallest subset with all elements less than A[i] sum more than B[i]
21, Mar 22
Adding elements of an array until every element becomes greater than or equal to k
24, Aug 17
Remove exactly one element from the array such that max - min is minimum
02, Jan 19
Minimum number of Nodes to be removed such that no subtree has more than K nodes
10, Aug 20
Minimize deletions from either end to remove Minimum and Maximum from Array
02, Dec 21
Count distinct ways to replace array elements such that product of the array becomes even
09, Mar 21
Rearrange an array such that 'arr[j]' becomes 'i' if 'arr[i]' is 'j' | Set 1
25, Feb 15
Remove minimum elements from array so that max <= 2 * min
01, Dec 18
Find minimum value to assign all array elements so that array product becomes greater
21, Jun 17
Longest Subsequence such that difference between adjacent elements is either A or B
13, Dec 21
Generate an array of maximum sum such that each element exceeds all elements present either on its left or right
03, Aug 21
Largest set of numbers upto N such that either i or i/2 is present
21, Dec 21
Minimize number of rotations on array A such that it becomes equal to B
11, Jan 22
Convert the array such that the GCD of the array becomes 1
04, Jun 18
Minimum and maximum count of elements at D distance from arr[i] in either direction
15, Oct 21
Minimum value of X to make all array elements equal by either decreasing or increasing by X
22, Apr 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Narendra_Jha
@Narendra_Jha
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!