Related Articles

# Minimum sum possible by assigning every increasing/decreasing consecutive pair with values in that order

• Last Updated : 06 Sep, 2021

Given an array arr[] of size N, the task is to find the minimum sum of positive integers that can be assigned to each array element arr[i], such that if arr[i] > arr[i+1] or arr[i – 1], then the positive integer assigned to arr[i] must exceed the integer assigned to arr[i + 1] or arr[i – 1].

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 0, 2}
Output: 5
Explanation: One possible way to assign positive integers is ans[] = {2, 1, 2} such that the following conditions are satisfied:

• arr > arr and ans > ans
• arr < arr and ans < ans

Therefore, minimum possible sum = 2 + 1 + 2 = 5.

Input: arr[] = {1, 2, 2}
Output: 4
Explanation: One possible way to assign positive integers is ans[] = {1, 2, 1}. Therefore, the minimum possible sum = 1 + 2 + 1 = 4.

Approach: The idea is to traverse the given array from left to right and from right to left to update the answer for each element arr[i] such that the answer for arr[i] is greater than the answers for arr[i+1] and arr[i – 1] if arr[i] is greater than arr[i + 1] and arr[i – 1].  Follow the below steps to solve the problem:

• Initialize a vector ans of size N that stores the minimum positive integer that can be assigned to each element.
• Initialize the vector ans with 1 as each element must be assigned some positive integer.
• Traverse the array from left to right using variable i and if arr[i] is greater than arr[i – 1] then update ans[i] as ans[i] = ans[i – 1] + 1.
• Now, traverse the array from right to left using variable i if arr[i] is greater than arr[i+1], then update ans[i] as ans[i] = max(ans[i], ans[i + 1] + 1).
• Now, find the sum of positive integers present in the vector ans and print it as the minimum possible sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to print the minimum sum``// of values assigned to each element``// of the array as per given conditions``void` `minSum(``int``* arr, ``int` `n)``{``    ``// Initialize vectors with value 1``    ``vector<``int``> ans(n, 1);` `    ``// Traverse from left to right``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Update if ans[i] > ans[i-1]``        ``if` `(arr[i] > arr[i - 1]) {``            ``ans[i] = max(ans[i],``                         ``ans[i - 1] + 1);``        ``}``    ``}` `    ``// Traverse from right to left``    ``for` `(``int` `i = n - 2; i >= 0; i--) {` `        ``// Update as ans[i] > ans[i+1]``        ``// if arr[i]> arr[i+1]``        ``if` `(arr[i] > arr[i + 1]) {``            ``ans[i] = max(ans[i],``                         ``ans[i + 1] + 1);``        ``}``    ``}` `    ``// Find the minimum sum``    ``int` `s = 0;``    ``for` `(``auto` `x : ans) {``        ``s = s + x;``    ``}` `    ``// Print the sum``    ``cout << s << endl;``}` `// Driver Code``int` `main()``{``    ``// Given array arr[]``    ``int` `arr[] = { 1, 2, 2 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``minSum(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to print the``// minimum sum of values``// assigned to each element``// of the array as per given``// conditions``static` `void` `minSum(``int``[] arr,``                   ``int` `n)``{``  ``// Initialize vectors``  ``// with value 1``  ``int``[] ans = ``new` `int``[n];``  ``Arrays.fill(ans, ``1``);` `  ``// Traverse from left``  ``// to right``  ``for` `(``int` `i = ``1``; i < n; i++)``  ``{``    ``// Update if ans[i] > ans[i-1]``    ``if` `(arr[i] > arr[i - ``1``])``    ``{``      ``ans[i] = Math.max(ans[i],``                        ``ans[i - ``1``] + ``1``);``    ``}``  ``}` `  ``// Traverse from right to left``  ``for` `(``int` `i = n - ``2``; i >= ``0``; i--)``  ``{``    ``// Update as ans[i] > ans[i+1]``    ``// if arr[i]> arr[i+1]``    ``if` `(arr[i] > arr[i + ``1``])``    ``{``      ``ans[i] = Math.max(ans[i],``                        ``ans[i + ``1``] + ``1``);``    ``}``  ``}` `  ``// Find the minimum sum``  ``int` `s = ``0``;``  ``for` `(``int` `x : ans)``  ``{``    ``s = s + x;``  ``}` `  ``// Print the sum``  ``System.out.print(s + ``"\n"``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given array arr[]``  ``int` `arr[] = {``1``, ``2``, ``2``};` `  ``int` `N = arr.length;` `  ``// Function Call``  ``minSum(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the``# above approach` `# Function to print the minimum``# sum of values assigned to each``# element of the array as per``# given conditions``def` `minSum(arr, n):` `    ``# Initialize vectors with``    ``# value 1``    ``ans ``=` `[``1``] ``*` `(n)` `    ``# Traverse from left to``    ``# right``    ``for` `i ``in` `range``(``1``, n):` `        ``# Update if ans[i] >``        ``# ans[i-1]``        ``if` `(arr[i] > arr[i ``-` `1``]):``            ``ans[i] ``=` `max``(ans[i],``                         ``ans[i ``-` `1``] ``+` `1``)` `    ``# Traverse from right``    ``# to left``    ``for` `i ``in` `range``(n ``-` `2``,``                   ``-``1``, ``-``1``):` `        ``# Update as ans[i] >``        ``# ans[i+1] if arr[i] >``        ``# arr[i+1]``        ``if` `(arr[i] > arr[i ``+` `1``]):``            ``ans[i] ``=` `max``(ans[i],``                         ``ans[i ``+` `1``] ``+` `1``)` `    ``# Find the minimum sum``    ``s ``=` `0``    ``for` `x ``in` `ans:``        ``s ``=` `s ``+` `x` `    ``# Print the sum``    ``print``(s)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Given array arr[]``    ``arr ``=` `[``1``, ``2``, ``2``]` `    ``N ``=` `len``(arr)` `    ``# Function Call``    ``minSum(arr, N)` `# This code is contributed by Chitranayal`

## C#

 `// C# program for the``// above approach``using` `System;``class` `GFG{` `// Function to print the``// minimum sum of values``// assigned to each element``// of the array as per given``// conditions``static` `void` `minSum(``int``[] arr,``                   ``int` `n)``{``  ``// Initialize vectors``  ``// with value 1``  ``int``[] ans = ``new` `int``[n];``  ` `  ``for``(``int` `i = 0; i < n; i++)``    ``ans[i] = 1;` `  ``// Traverse from left``  ``// to right``  ``for` `(``int` `i = 1; i < n; i++)``  ``{``    ``// Update if ans[i] > ans[i-1]``    ``if` `(arr[i] > arr[i - 1])``    ``{``      ``ans[i] = Math.Max(ans[i],``                        ``ans[i - 1] + 1);``    ``}``  ``}` `  ``// Traverse from right to left``  ``for` `(``int` `i = n - 2; i >= 0; i--)``  ``{``    ``// Update as ans[i] > ans[i+1]``    ``// if arr[i]> arr[i+1]``    ``if` `(arr[i] > arr[i + 1])``    ``{``      ``ans[i] = Math.Max(ans[i],``                        ``ans[i + 1] + 1);``    ``}``  ``}` `  ``// Find the minimum sum``  ``int` `s = 0;``  ``foreach` `(``int` `x ``in` `ans)``  ``{``    ``s = s + x;``  ``}` `  ``// Print the sum``  ``Console.Write(s + ``"\n"``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``// Given array []arr``  ``int` `[]arr = {1, 2, 2};` `  ``int` `N = arr.Length;` `  ``// Function Call``  ``minSum(arr, N);``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``
Output
`4`

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

My Personal Notes arrow_drop_up