Related Articles
Minimum steps for increasing and decreasing Array to reach either 0 or N
• Difficulty Level : Expert
• Last Updated : 27 Apr, 2021

Given an integer N and two arrays increasing[] and decreasing[], such that they have elements from 1 to N only. The task is to find the minimum number of steps for each element of the two arrays to reach either 0 or N. A step is defined as follows:

• In one step, all the elements of the increasing[] array increases by 1, and all the elements of the decreasing[] array decreases by 1.
• When an element becomes either 0 or N, no more increase or decrease operation is performed on it.

Examples:

Input: N = 5, increasing[] = {1, 2}, decreasing[] = {3, 4}
Output: 4
Explanation:
Step 1: increasing[] array becomes {2, 3}, decreasing[] = {2, 3}
Step 2: increasing[] array becomes {3, 4}, decreasing[] = {1, 2}
Step 3: increasing[] array becomes {4, 5}, decreasing[] = {0, 1}
Step 4: increasing[] array becomes {5, 5}, decreasing[] = {0, 0}
4 Steps are required for all elements to become either 0 or N. Hence, the output is 4.

Input: N = 7, increasing[] = {3, 5}, decreasing[] = {6}
Output: 6

Approach: The idea is to find the maximum between the steps required by all the elements of the increasing[] array and the decreasing[] array to reach N and 0 respectively. Below are the steps:

1. Find the minimum element of the array increasing[].
2. The maximum steps taken by all the elements of the increasing[] array to reach N is given by N – min(increasing[]).
3. Find the maximum element of the array decreasing[].
4. The maximum steps taken by all the elements of the decreasing[] array to reach 0 is given by max(decreasing[]).
5. Therefore, the minimum number of steps when all the elements become either 0 or N is given by max(N – min(increasing[]), max(decreasing[])).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function that finds the minimum``// steps to reach either 0 or N for``// given increasing and decreasing``// arrays``void` `minSteps(``int` `N, ``int` `increasing[],``              ``int` `decreasing[], ``int` `m1, ``int` `m2)``{` `    ``// Initialize variable to``    ``// find the minimum element``    ``int` `mini = INT_MAX;` `    ``// Find minimum element in``    ``// increasing[] array``    ``for``(``int` `i = 0; i < m1; i++)``    ``{``        ``if` `(mini > increasing[i])``            ``mini = increasing[i];``    ``}` `    ``// Initialize variable to``    ``// find the maximum element``    ``int` `maxi = INT_MIN;` `    ``// Find maximum element in``    ``// decreasing[] array``    ``for``(``int` `i = 0; i < m2; i++)``    ``{``        ``if` `(maxi < decreasing[i])``            ``maxi = decreasing[i];``    ``}` `    ``// Find the minimum steps``    ``int` `minSteps = max(maxi,``                       ``N - mini);` `    ``// Print the minimum steps``    ``cout << minSteps << endl;``}` `// Driver code``int` `main()``{``    ` `    ``// Given N``    ``int` `N = 7;` `    ``// Given increasing``    ``// and decreasing array``    ``int` `increasing[] = { 3, 5 };``    ``int` `decreasing[] = { 6 };``    ` `    ``// Find length of arrays``    ``// increasing and decreasing``    ``int` `m1 = ``sizeof``(increasing) /``sizeof``(increasing);``    ``int` `m2 = ``sizeof``(decreasing) / ``sizeof``(decreasing);``    ` `    ``// Function call``    ``minSteps(N, increasing, decreasing, m1, m2);``}` `// This code is contributed by Manne Sree Charan`

## Java

 `// Java program for the above approach``import` `java.util.*;` `public` `class` `GFG {` `    ``// Function that finds the minimum``    ``// steps to reach either 0 or N for``    ``// given increasing and decreasing``    ``// arrays``    ``public` `static` `void``    ``minSteps(``int` `N, ``int``[] increasing,``            ``int``[] decreasing)``    ``{` `        ``// Initialize variable to``        ``// find the minimum element``        ``int` `min = Integer.MAX_VALUE;` `        ``// Find minimum element in``        ``// increasing[] array``        ``for` `(``int` `i : increasing) {``            ``if` `(min > i)``                ``min = i;``        ``}` `        ``// Initialize variable to``        ``// find the maximum element``        ``int` `max = Integer.MIN_VALUE;` `        ``// Find maximum element in``        ``// decreasing[] array``        ``for` `(``int` `i : decreasing) {``            ``if` `(max < i)``                ``max = i;``        ``}` `        ``// Find the minimum steps``        ``int` `minSteps = Math.max(max,``                                ``N - min);` `        ``// Print the minimum steps``        ``System.out.println(minSteps);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given N``        ``int` `N = ``7``;` `        ``// Given increasing``        ``// and decreasing array``        ``int` `increasing[] = { ``3``, ``5` `};``        ``int` `decreasing[] = { ``6` `};` `        ``// Function call``        ``minSteps(N, increasing, decreasing);``    ``}``}`

## Python3

 `# Python3 program for``# the above approach``import` `sys` `# Function that finds the minimum``# steps to reach either 0 or N for``# given increasing and decreasing``# arrays``def` `minSteps(N, increasing, decreasing):``    ``# Initialize variable to``    ``# find the minimum element``    ``Min` `=` `sys.maxsize;` `    ``# Find minimum element in``    ``# increasing array``    ``for` `i ``in` `increasing:``        ``if` `(``Min` `> i):``            ``Min` `=` `i;` `    ``# Initialize variable to``    ``# find the maximum element``    ``Max` `=` `-``sys.maxsize;` `    ``# Find maximum element in``    ``# decreasing array``    ``for` `i ``in` `decreasing:``        ``if` `(``Max` `< i):``            ``Max` `=` `i;` `    ``# Find the minimum steps``    ``minSteps ``=` `max``(``Max``, N ``-` `Min``);` `    ``# Prthe minimum steps``    ``print``(minSteps);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given N``    ``N ``=` `7``;` `    ``# Given increasing``    ``# and decreasing array``    ``increasing ``=` `[``3``, ``5``];``    ``decreasing ``=` `[``6``];` `    ``# Function call``    ``minSteps(N, increasing, decreasing);` `# This code contributed by Rajput-Ji`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function that finds the minimum``// steps to reach either 0 or N for``// given increasing and decreasing``// arrays``public` `static` `void` `minSteps(``int` `N, ``int``[] increasing,``                                   ``int``[] decreasing)``{` `    ``// Initialize variable to``    ``// find the minimum element``    ``int` `min = ``int``.MaxValue;` `    ``// Find minimum element in``    ``// increasing[] array``    ``foreach``(``int` `i ``in` `increasing)``    ``{``        ``if` `(min > i)``            ``min = i;``    ``}` `    ``// Initialize variable to``    ``// find the maximum element``    ``int` `max = ``int``.MinValue;` `    ``// Find maximum element in``    ``// decreasing[] array``    ``foreach``(``int` `i ``in` `decreasing)``    ``{``        ``if` `(max < i)``            ``max = i;``    ``}` `    ``// Find the minimum steps``    ``int` `minSteps = Math.Max(max,``                            ``N - min);` `    ``// Print the minimum steps``    ``Console.WriteLine(minSteps);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given N``    ``int` `N = 7;` `    ``// Given increasing``    ``// and decreasing array``    ``int` `[]increasing = { 3, 5 };``    ``int` `[]decreasing = { 6 };` `    ``// Function call``    ``minSteps(N, increasing, decreasing);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
`6`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up