# Minimum steps for increasing and decreasing Array to reach either 0 or N

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++ 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 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 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# 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`

Output:
```6

```

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

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.

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.

Article Tags :
Practice Tags :