Maximize Array sum by replacing middle elements with min of Subarray corners
Last Updated :
04 Dec, 2023
Given an array A[] of length N. Then your task is to output the maximum sum that can be achieved by using the given operation at any number of times (possibly zero):
- Select a subarray, whose length is at least 3.
- Replace all the middle elements (Except the first and last) with a minimum of elements at both ends.
Examples:
Input: N = 3, A[] = {8, 1, 7}
Output: 22
Explanation: Let us take the subarray A[1, 3] = {8, 1, 7}. Middle element(s) are: {1}. Now minimum of A[1] and A[3] is = min(A[1], A[3]) = min(8, 7) = 7. Then, we replaced all the middle elements equal to min according to the operation. So, updated A[] = {8, 7, 7}. The sum of updated A[] = 22. Which is the maximum possible using a given operation. Therefore, output is 22.
Input: N = 2, A[] = {5, 2}
Output: 7
Explanation: No subarray of length at least 3 can be chosen, Thus can't apply any operation. So the maximum possible sum is 7.
Approach: Implement the idea below to solve the problem
The problem is based on the observations and can be solved using the Prefix and Suffix arrays. It must be noticed that for any index i, we can not make the element A[i] to be anything more than the minimum of the greatest element to its left and the greatest element to its right.
Steps were taken to solve the problem:
- Create two arrays let say Prefix[] and Suffix[]
- Set prefix[0] = A[0]
- Run a loop for i = 1 to i < N and follow the below-mentioned steps under the scope of the loop
- prefix[i] = max(prefix[i - 1], A[i])
- Set suffix[N - 1] = A[N - 1]
- Run a loop for i = N - 2 to I >=0 and follow the below-mentioned steps under the scope of the loop
- suffix[i] = max(suffix[i + 1], A[i])
- Create a variable let say Sum to store the max possible sum.
- Run a loop for i = 1 to i < N - 1 and follow below mentioned steps under the scope of loop
- Max1 = Prefix[i]
- Max2 = Suffix[i]
- sum += min(Max1, Max2)
- Sum += A[0] + A[N - 1]
- Output the value store in Sum.
Code to implement the approach:
C++
//code by FLutterfly
#include <iostream>
#include <algorithm>
using namespace std;
// Function prototype
void Max_sum(int N, int A[]);
int main()
{
// Input
int N = 2;
int A[] = {5, 2};
// Function call
Max_sum(N, A);
return 0;
}
void Max_sum(int N, int A[])
{
// Prefix and Suffix Arrays
int prefix[N];
int suffix[N];
// Initializing prefix array
prefix[0] = A[0];
for (int i = 1; i < N; i++)
{
prefix[i] = max(prefix[i - 1], A[i]);
}
// Initializing suffix array
suffix[N - 1] = A[N - 1];
for (int i = N - 2; i >= 0; i--)
{
suffix[i] = max(suffix[i + 1], A[i]);
}
// Variable to store max sum
long long sum = 0;
// Calculating sum for all middle elements
for (int i = 1; i < N - 1; i++)
{
int maxi1 = prefix[i], maxi2 = suffix[i];
sum += min(maxi1, maxi2);
}
// Adding last elements of both ends into sum
sum += A[0] + A[N - 1];
// Printing the value of sum
cout << sum << endl;
}
// Java code to implement the approach
import java.util.*;
class Main {
public static void main(String[] args)
{
// Input
int N = 2;
int A[] = { 5, 2 };
// Function call
Max_sum(N, A);
}
public static void Max_sum(int N, int[] A)
{
// Prefix and Suffix Arrays
int[] prefix = new int[N];
int[] suffix = new int[N];
// Initializing prefix array
prefix[0] = A[0];
for (int i = 1; i < N; i++) {
prefix[i] = Math.max(prefix[i - 1], A[i]);
}
// Initializing suffix array
suffix[N - 1] = A[N - 1];
for (int i = N - 2; i >= 0; i--) {
suffix[i] = Math.max(suffix[i + 1], A[i]);
}
// Variable to store max sum
long sum = 0;
// Calculating sum for all middle elements
for (int i = 1; i < N - 1; i++) {
int maxi1 = prefix[i], maxi2 = suffix[i];
sum += Math.min(maxi1, maxi2);
}
// Adding last elements of both ends into sum
sum += A[0] + A[N - 1];
// Printing the value of sum
System.out.println(sum);
}
}
# code by flutterfly
def Max_sum(N, A):
# Prefix and Suffix Arrays
prefix = [0] * N
suffix = [0] * N
# Initializing prefix array
prefix[0] = A[0]
for i in range(1, N):
prefix[i] = max(prefix[i - 1], A[i])
# Initializing suffix array
suffix[N - 1] = A[N - 1]
for i in range(N - 2, -1, -1):
suffix[i] = max(suffix[i + 1], A[i])
# Variable to store max sum
sum_val = 0
# Calculating sum for all middle elements
for i in range(1, N - 1):
maxi1, maxi2 = prefix[i], suffix[i]
sum_val += min(maxi1, maxi2)
# Adding last elements of both ends into sum
sum_val += A[0] + A[N - 1]
# Printing the value of sum
print(sum_val)
# Input
N = 2
A = [5, 2]
# Function call
Max_sum(N, A)
//code by flutterfly
using System;
class Program
{
static void Main()
{
// Input
int N = 2;
int[] A = { 5, 2 };
// Function call
Max_sum(N, A);
}
static void Max_sum(int N, int[] A)
{
// Prefix and Suffix Arrays
int[] prefix = new int[N];
int[] suffix = new int[N];
// Initializing prefix array
prefix[0] = A[0];
for (int i = 1; i < N; i++)
{
prefix[i] = Math.Max(prefix[i - 1], A[i]);
}
// Initializing suffix array
suffix[N - 1] = A[N - 1];
for (int i = N - 2; i >= 0; i--)
{
suffix[i] = Math.Max(suffix[i + 1], A[i]);
}
// Variable to store max sum
long sum = 0;
// Calculating sum for all middle elements
for (int i = 1; i < N - 1; i++)
{
int maxi1 = prefix[i], maxi2 = suffix[i];
sum += Math.Min(maxi1, maxi2);
}
// Adding last elements of both ends into sum
sum += A[0] + A[N - 1];
// Printing the value of sum
Console.WriteLine(sum);
}
}
function Max_sum(N, A) {
// Prefix and Suffix Arrays
let prefix = new Array(N);
let suffix = new Array(N);
// Initializing prefix array
prefix[0] = A[0];
for (let i = 1; i < N; i++) {
prefix[i] = Math.max(prefix[i - 1], A[i]);
}
// Initializing suffix array
suffix[N - 1] = A[N - 1];
for (let i = N - 2; i >= 0; i--) {
suffix[i] = Math.max(suffix[i + 1], A[i]);
}
// Variable to store max sum
let sum = 0;
// Calculating sum for all middle elements
for (let i = 1; i < N - 1; i++) {
let maxi1 = prefix[i], maxi2 = suffix[i];
sum += Math.min(maxi1, maxi2);
}
// Adding last elements of both ends into sum
sum += A[0] + A[N - 1];
// Printing the value of sum
console.log(sum);
}
// Input
let N = 2;
let A = [5, 2];
// Function call
Max_sum(N, A);
Time Complexity: O(N)
Auxiliary Space: O(2*N), As Prefix and Suffix arrays of length N are used.
Similar Reads
Maximize non decreasing Array size by replacing Subarray with sum Given an array arr[] of size N. In one operation only one subarray can be selected and replaced with the sum of the subarray. The task is to find the maximum size of the array after making it non-decreasing.Examples:Input: N = 5, arr[] = {5, 1, 6, 6, 6}Output: 4Explanation: maximum size non-decreasi
15+ min read
Maximize point to reduce Array by replacing Subarray with its sum Given an array arr[] of size, N, the task is to maximize the score to reduce the array to a single element by replacing any subarray with its sum where the score of one such operation is the product of subarray length and the minimum value of that subarray. Examples:Input: N = 2, arr[] = {1, 5}Outpu
15 min read
Rearrange array elements to maximize the sum of MEX of all prefix arrays Given an array arr[] of size N, the task is to rearrange the array elements such that the sum of MEX of all prefix arrays is the maximum possible. Note: MEX of a sequence is the minimum non-negative number not present in the sequence. Examples: Input: arr[] = {2, 0, 1}Output: 0, 1, 2Explanation:Sum
7 min read
Maximize product of subarray sum with its minimum element Given an array arr[] consisting of N positive integers, the task is to find the maximum product of subarray sum with the minimum element of that subarray. Examples: Input: arr[] = {3, 1, 6, 4, 5, 2}Output: 60Explanation:The required maximum product can be obtained using subarray {6, 4, 5}Therefore,
10 min read
Maximum sum of Array formed by replacing each element with sum of adjacent elements Given an array arr[] of size N, the task is to find the maximum sum of the Array formed by replacing each element of the original array with the sum of adjacent elements.Examples: Input: arr = [4, 2, 1, 3] Output: 23 Explanation: Replacing each element of the original array with the sum of adjacent
9 min read
Maximize the minimum array element by M subarray increments of size S Given an array arr[] of N integers and two integers S and M, the task is to maximize the minimum array element by incrementing any subarray of size S by 1, M number of times. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6}, S = 2, M = 3Output: 3Explanation:Below are the operations performed:Operation 1:
10 min read
Maximize array sum by replacing at most L elements to R for Q queries Given an array arr[] consisting of N integers and an array Query[][] consisting of M pairs of the type {L, R}, the task is to find the maximum sum of the array by performing the queries Query[][] such that for each query {L, R} replace at most L array elements to the value R. Examples: Input: arr[]=
7 min read
Find maximum sum by replacing the Subarray in given range Given an array arr[], the task is to find the maximum sum possible such that any subarray of the indices from [l, r] i.e all subarray elements from arr[l] to arr[r] can be replaced with |arr[l] - arr[r]| any number of times. Examples: Input: arr[] = { 9, 1}Output: 16Explanation: The subarray [l, r]
9 min read
Maximize sum of K corner elements in Array Given an array arr[] and an integer K, the task is to find the maximize the sum of K elements in the Array by taking only corner elements. A corner element is an element from the start of the array or from the end of the array. Examples: Input: arr[] = {8, 4, 4, 8, 12, 3, 2, 9}, K = 3 Output: 21 Exp
13 min read
Minimize the sum of MEX by removing all elements of array Given an array of integers arr[] of size N. You can perform the following operation N times: Pick any index i, and remove arr[i] from the array and add MEX(arr[]) i.e., Minimum Excluded of the array arr[] to your total score. Your task is to minimize the total score. Examples: Input: N = 8, arr[] =
7 min read