Open in App
Not now

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

• Difficulty Level : Basic
• 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[0](= 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[0](= 10) is less than or equal to -1.
2. For array element B[1](= 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[1](= 6) is less than or equal to 6.
3. For array element B[2](= 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[2](= 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[0]);` `    ``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)

My Personal Notes arrow_drop_up
Related Articles