Related Articles

# Generate an array of maximum sum such that each element exceeds all elements present either on its left or right

• Last Updated : 06 Sep, 2021

Given an array A[] consisting of N positive integers, the task is to construct an array B[] of size N having maximum possible sum of array elements satisfying the following criteria for every index i:

• The array element B[i] must be less than or equal to A[i].
• For every index i, B[i] must be greater than all elements present either on its left or its right.

Examples:

Input: A[] = {10, 6, 8}
Output: 10 6 6
Explanation:
Consider the array B[] as {10, 6, 6} that satisfy the given criteria as shown below having the maximum sum of elements:

1. For array element B(= 10): The maximum element to the left and the right of the index 0 in the array B[] is -1 and 6 respectively and B(= 10) is less than or equal to -1.
2. For array element B(= 6): The maximum element to the left and the right of the index 1 in the array B[] is 10 and 6 respectively and B(= 6) is less than or equal to 6.
3. For array element B(= 6): The maximum element to the left and the right of the index 2 in the array B[] is 10 and -1 respectively and B(= 6) is less than or equal to -1.

Input: A[ ] = {1, 2, 3, 1}
Output: 1 2 3 1

Approach: The given problem can be solved by observing the fact that there is always a maximum element in the array which is first increasing and then monotonically decreasing. Therefore, the idea is to make every array element of the new array B[] maximum one by one and then check for the maximum sum. Follow the steps below to solve the given problem:

• Initialize the arrays, say arrA[] and ans[] that stores the array elements A[] and the resultant array respectively.
• Initialize a variable, say maxSum as 0 that stores the maximum sum of array elements.
• Iterate over the range [0, N] and perform the following steps:
• Initialize an array, say arrB[] that can stores the resultant array.
• Assign all the array element arrB[i] in the monotonically increasing order till every index i.
• Assign all the array element arrB[i] in the monotonically decreasing order over then range [i, N].
• Now, find the sum of array arrB[] and if the sum is greater than maxSum then update the maxSum and the array ans[] to the current sum and current array arrB[] constructed.
• After completing the above steps, print the array arrB[] as the resultant array.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Function to construct the array``// having maximum sum satisfying the``// given criteria``void` `maximumSumArray(``int` `arr[], ``int` `N)``{``    ``// Declaration of the array arrA[]``    ``// and ans[]``    ``vector<``int``> arrA(N), ans(N);` `    ``// Stores the maximum sum of the``    ``// resultant array``    ``int` `maxSum = 0;` `    ``// Initialize the array arrA[]``    ``for` `(``int` `i = 0; i < N; i++)``        ``arrA[i] = arr[i];` `    ``// Traversing the array arrA[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Initialize the array arrB[]``        ``vector<``int``> arrB(N);``        ``int` `maximum = arrA[i];` `        ``// Assign the maximum element``        ``// to the current element``        ``arrB[i] = maximum;` `        ``// Form the first increasing``        ``// till every index i``        ``for` `(``int` `j = i - 1; j >= 0; j--) {``            ``arrB[j] = min(maximum, arrA[j]);``            ``maximum = arrB[j];``        ``}` `        ``// Make the current element``        ``// as the maximum element``        ``maximum = arrA[i];` `        ``// Forming decreasing from the``        ``// index i + 1 to the index N``        ``for` `(``int` `j = i + 1; j < N; j++) {``            ``arrB[j] = min(maximum, arrA[j]);``            ``maximum = arrB[j];``        ``}` `        ``// Initialize the sum``        ``int` `sum = 0;` `        ``// Find the total sum``        ``for` `(``int` `j = 0; j < N; j++)``            ``sum += arrB[j];` `        ``// Check if the total sum is``        ``// at least the sum found``        ``// then make ans as ansB``        ``if` `(sum > maxSum) {``            ``maxSum = sum;``            ``ans = arrB;``        ``}``    ``}` `    ``// Print the final array formed``    ``for` `(``int` `val : ans) {``        ``cout << val << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 10, 6, 8 };``    ``int` `N = ``sizeof``(A) / ``sizeof``(A);``    ``maximumSumArray(A, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {` `// Function to construct the array``// having maximum sum satisfying the``// given criteria``static` `void` `maximumSumArray(``int` `arr[], ``int` `N)``{``    ``// Declaration of the array arrA[]``    ``// and ans[]``    ``int``[] arrA  = ``new` `int``[(N)];``    ``int``[] ans  = ``new` `int``[(N)];` `    ``// Stores the maximum sum of the``    ``// resultant array``    ``int` `maxSum = ``0``;` `    ``// Initialize the array arrA[]``    ``for` `(``int` `i = ``0``; i < N; i++)``        ``arrA[i] = arr[i];` `    ``// Traversing the array arrA[]``    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// Initialize the array arrB[]``        ``int``[] arrB = ``new` `int``[(N)];``        ``int` `maximum = arrA[i];` `        ``// Assign the maximum element``        ``// to the current element``        ``arrB[i] = maximum;` `        ``// Form the first increasing``        ``// till every index i``        ``for` `(``int` `j = i - ``1``; j >= ``0``; j--) {``            ``arrB[j] = Math.min(maximum, arrA[j]);``            ``maximum = arrB[j];``        ``}` `        ``// Make the current element``        ``// as the maximum element``        ``maximum = arrA[i];` `        ``// Forming decreasing from the``        ``// index i + 1 to the index N``        ``for` `(``int` `j = i + ``1``; j < N; j++) {``            ``arrB[j] = Math.min(maximum, arrA[j]);``            ``maximum = arrB[j];``        ``}` `        ``// Initialize the sum``        ``int` `sum = ``0``;` `        ``// Find the total sum``        ``for` `(``int` `j = ``0``; j < N; j++)``            ``sum += arrB[j];` `        ``// Check if the total sum is``        ``// at least the sum found``        ``// then make ans as ansB``        ``if` `(sum > maxSum) {``            ``maxSum = sum;``            ``ans = arrB;``        ``}``    ``}` `    ``// Print the final array formed``    ``for` `(``int` `val : ans) {``        ``System.out.print(val + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``10``, ``6``, ``8` `};``    ``int` `N = A.length;``    ``maximumSumArray(A, N);``}``}` `// This code is contributed by splevel62.`

## Python3

 `# Python program for the above approach;` `# Function to construct the array``# having maximum sum satisfying the``# given criteria``def` `maximumSumArray(arr, N):``    ` `    ``# Declaration of the array arrA[]``    ``# and ans[]``    ``arrA ``=` `[``0``] ``*` `N``    ``ans ``=` `[``0``] ``*` `N` `    ``# Stores the maximum sum of the``    ``# resultant array``    ``maxSum ``=` `0``;` `    ``# Initialize the array arrA[]``    ``for` `i ``in` `range``(N):``        ``arrA[i] ``=` `arr[i];` `    ``# Traversing the array arrA[]``    ``for` `i ``in` `range``(N):``        ` `        ``# Initialize the array arrB[]``        ``arrB ``=` `[``0``] ``*` `N``        ``maximum ``=` `arrA[i];` `        ``# Assign the maximum element``        ``# to the current element``        ``arrB[i] ``=` `maximum;` `        ``temp ``=` `0``        ` `        ``# Form the first increasing``        ``# till every index i``        ``for` `j ``in` `range``(i ``-` `1``, ``-``1``, ``-``1``):``            ``arrB[j] ``=` `min``(maximum, arrA[j]);``            ``maximum ``=` `arrB[j];``            ``temp ``=` `j``        `  `        ``# Make the current element``        ``# as the maximum element``        ``maximum ``=` `arrA[i];` `        ``# Forming decreasing from the``        ``# index i + 1 to the index N``        ``for` `j ``in` `range``(i ``+` `1``, N):``            ``arrB[j] ``=` `min``(maximum, arrA[j]);``            ``maximum ``=` `arrB[j];``        `  `        ``# Initialize the sum``        ``sum` `=` `0``;` `        ``# Find the total sum``        ``for` `j ``in` `range``(N):``            ``sum` `+``=` `arrB[j];` `        ``# Check if the total sum is``        ``# at least the sum found``        ``# then make ans as ansB``        ``if` `(``sum` `> maxSum):``            ``maxSum ``=` `sum``;``            ``ans ``=` `arrB;``        ` `    ``# Print the final array formed``    ``for` `val ``in` `ans:``        ``print``(val);``    ` `# Driver Code``A ``=` `[ ``10``, ``6``, ``8` `];``N ``=` `len``(A)` `maximumSumArray(A, N);` `# This code is contributed by _Saurabh_Jaiswal`

## C#

 `// C# code for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to construct the array``// having maximum sum satisfying the``// given criteria``static` `void` `maximumSumArray(``int` `[]arr, ``int` `N)``{``    ``// Declaration of the array arrA[]``    ``// and ans[]``    ``int` `[]arrA = ``new` `int``[N];``    ``int` `[]ans = ``new` `int``[N];` `    ``// Stores the maximum sum of the``    ``// resultant array``    ``int` `maxSum = 0;` `    ``// Initialize the array arrA[]``    ``for` `(``int` `i = 0; i < N; i++)``        ``arrA[i] = arr[i];` `    ``// Traversing the array arrA[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Initialize the array arrB[]``        ``int` `[]arrB = ``new` `int``[N];``        ``int` `maximum = arrA[i];` `        ``// Assign the maximum element``        ``// to the current element``        ``arrB[i] = maximum;` `        ``// Form the first increasing``        ``// till every index i``        ``for` `(``int` `j = i - 1; j >= 0; j--) {``            ``arrB[j] = Math.Min(maximum, arrA[j]);``            ``maximum = arrB[j];``        ``}` `        ``// Make the current element``        ``// as the maximum element``        ``maximum = arrA[i];` `        ``// Forming decreasing from the``        ``// index i + 1 to the index N``        ``for` `(``int` `j = i + 1; j < N; j++) {``            ``arrB[j] = Math.Min(maximum, arrA[j]);``            ``maximum = arrB[j];``        ``}` `        ``// Initialize the sum``        ``int` `sum = 0;` `        ``// Find the total sum``        ``for` `(``int` `j = 0; j < N; j++)``            ``sum += arrB[j];` `        ``// Check if the total sum is``        ``// at least the sum found``        ``// then make ans as ansB``        ``if` `(sum > maxSum) {``            ``maxSum = sum;``            ``ans = arrB;``        ``}``    ``}` `    ``// Print the final array formed``    ``foreach` `(``int` `val ``in` `ans) {``        ``Console.Write(val + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `[]A = { 10, 6, 8 };``    ``int` `N = A.Length;``    ``maximumSumArray(A, N);``}``}` `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``
Output:
`10 6 6`

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

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