Maximum sum of Array formed by replacing each element with sum of adjacent elements
Last Updated :
06 Jun, 2022
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 elements:
4 + 2 = 6
6 + 1 = 7
7 + 3 = 10
Array formed by replacing each element of the original array with the sum of adjacent elements: [6, 7, 10]
Therefore, Sum = 6 + 7 + 10 = 23
Input: arr = [2, 3, 9, 8, 4]
Output: 88
Explanation:
Replacing each element of the original array with the sum of adjacent elements to get maximum sum:
9 + 8 = 17
17 + 4 = 21
21 + 3 = 24
24 + 2 = 26
Array formed by replacing each element of the original array with the sum of adjacent elements: [17, 21, 24, 26]
Therefore, Sum = 17 + 21 + 24 + 26 = 88.
Approach:
- Scan through the array to pick the adjacent pair with the highest sum.
- From there on, using Greedy algorithm, pick the left or right integer, whichever is greater.
- Repeat the process till only a single element is left in the array.
Below is the implementation of the above approach:
C++
// C++ program to find the maximum sum
// of Array formed by replacing each
// element with sum of adjacent elements
#include <bits/stdc++.h>
using namespace std;
// Function to calculate the possible
// maximum cost of the array
int getTotalTime(vector<int>& arr)
{
// Check if array size is 0
if (arr.size() == 0)
return 0;
// Initialise left and right variables
int l = -1, r = -1;
for (int i = 1; i < arr.size(); i++) {
if (l == -1
|| (arr[i - 1] + arr[i])
> (arr[l] + arr[r])) {
l = i - 1;
r = i;
}
}
// Calculate the current cost
int currCost = arr[l] + arr[r];
int totalCost = currCost;
l--;
r++;
// Iterate until left variable reaches 0
// and right variable is less than array size
while (l >= 0 || r < arr.size()) {
int left = l < 0
? INT_MIN
: arr[l];
int right = r >= arr.size()
? INT_MIN
: arr[r];
// Check if left integer is greater
// than the right then add left integer
// to the current cost and
// decrement the left variable
if (left > right) {
currCost += left;
totalCost += currCost;
l--;
}
// Executes if right integer is
// greater than left then add
// right integer to the current cost
// and increment the right variable
else {
currCost += right;
totalCost += currCost;
r++;
}
}
// Return the final answer
return totalCost;
}
// Driver code
int main(int argc, char* argv[])
{
vector<int> arr = { 2, 3, 9, 8, 4 };
cout << getTotalTime(arr) << endl;
return 0;
}
// Java program to find the maximum sum
// of array formed by replacing each
// element with sum of adjacent elements
class GFG{
// Function to calculate the possible
// maximum cost of the array
static int getTotalTime(int []arr)
{
// Check if array size is 0
if (arr.length == 0)
return 0;
// Initialise left and right variables
int l = -1, r = -1;
for(int i = 1; i < arr.length; i++)
{
if (l == -1 || (arr[i - 1] + arr[i]) >
(arr[l] + arr[r]))
{
l = i - 1;
r = i;
}
}
// Calculate the current cost
int currCost = arr[l] + arr[r];
int totalCost = currCost;
l--;
r++;
// Iterate until left variable reaches 0
// and right variable is less than array size
while (l >= 0 || r < arr.length)
{
int left = (l < 0 ?
Integer.MIN_VALUE : arr[l]);
int right = (r >= arr.length ?
Integer.MIN_VALUE : arr[r]);
// Check if left integer is greater
// than the right then add left integer
// to the current cost and
// decrement the left variable
if (left > right)
{
currCost += left;
totalCost += currCost;
l--;
}
// Executes if right integer is
// greater than left then add
// right integer to the current cost
// and increment the right variable
else
{
currCost += right;
totalCost += currCost;
r++;
}
}
// Return the final answer
return totalCost;
}
// Driver code
public static void main(String[] args)
{
int []arr = { 2, 3, 9, 8, 4 };
System.out.print(getTotalTime(arr) + "\n");
}
}
// This code is contributed by PrinciRaj1992
# Python3 program to find the maximum sum
# of Array formed by replacing each
# element with sum of adjacent elements
import sys
# Function to calculate the possible
# maximum cost of the array
def getTotalTime(arr):
# Check if array size is 0
if (len(arr) == 0):
return 0
# Initialise left and right variables
l = -1
r = -1
for i in range(1, len(arr), 1):
if (l == -1 or (arr[i - 1] + arr[i]) > (arr[l] + arr[r])):
l = i - 1
r = i
# Calculate the current cost
currCost = arr[l] + arr[r]
totalCost = currCost
l -= 1
r += 1
# Iterate until left variable reaches 0
# and right variable is less than array size
while (l >= 0 or r < len(arr)):
if(l < 0):
left = sys.maxsize
else:
left = arr[l]
if (r >= len(arr)):
right = -sys.maxsize - 1
else:
right = arr[r]
# Check if left integer is greater
# than the right then add left integer
# to the current cost and
# decrement the left variable
if (left > right):
currCost += left
totalCost += currCost
l -= 1
# Executes if right integer is
# greater than left then add
# right integer to the current cost
# and increment the right variable
else:
currCost += right
totalCost += currCost
r += 1
# Return the final answer
return totalCost
# Driver code
if __name__ == '__main__':
arr = [2, 3, 9, 8, 4]
print(getTotalTime(arr))
# This code is contributed by Surendra_Gangwar
// C# program to find the maximum sum
// of array formed by replacing each
// element with sum of adjacent elements
using System;
class GFG{
// Function to calculate the possible
// maximum cost of the array
static int getTotalTime(int []arr)
{
// Check if array size is 0
if (arr.Length == 0)
return 0;
// Initialise left and right variables
int l = -1, r = -1;
for(int i = 1; i < arr.Length; i++)
{
if (l == -1 || (arr[i - 1] + arr[i]) >
(arr[l] + arr[r]))
{
l = i - 1;
r = i;
}
}
// Calculate the current cost
int currCost = arr[l] + arr[r];
int totalCost = currCost;
l--;
r++;
// Iterate until left variable reaches 0
// and right variable is less than array size
while (l >= 0 || r < arr.Length)
{
int left = (l < 0 ?
int.MinValue : arr[l]);
int right = (r >= arr.Length ?
int.MinValue : arr[r]);
// Check if left integer is greater
// than the right then add left integer
// to the current cost and
// decrement the left variable
if (left > right)
{
currCost += left;
totalCost += currCost;
l--;
}
// Executes if right integer is
// greater than left then add
// right integer to the current cost
// and increment the right variable
else
{
currCost += right;
totalCost += currCost;
r++;
}
}
// Return the readonly answer
return totalCost;
}
// Driver code
public static void Main(String[] args)
{
int []arr = { 2, 3, 9, 8, 4 };
Console.Write(getTotalTime(arr) + "\n");
}
}
// This code is contributed by PrinciRaj1992
<script>
// Javascript program to find the maximum sum
// of Array formed by replacing each
// element with sum of adjacent elements
// Function to calculate the possible
// maximum cost of the array
function getTotalTime(arr)
{
// Check if array size is 0
if (arr.length == 0)
return 0;
// Initialise left and right variables
var l = -1, r = -1;
for (var i = 1; i < arr.length; i++) {
if (l == -1
|| (arr[i - 1] + arr[i])
> (arr[l] + arr[r])) {
l = i - 1;
r = i;
}
}
// Calculate the current cost
var currCost = arr[l] + arr[r];
var totalCost = currCost;
l--;
r++;
// Iterate until left variable reaches 0
// and right variable is less than array size
while (l >= 0 || r < arr.length) {
var left = l < 0
? -1000000000
: arr[l];
var right = r >= arr.length
? -1000000000
: arr[r];
// Check if left integer is greater
// than the right then add left integer
// to the current cost and
// decrement the left variable
if (left > right) {
currCost += left;
totalCost += currCost;
l--;
}
// Executes if right integer is
// greater than left then add
// right integer to the current cost
// and increment the right variable
else {
currCost += right;
totalCost += currCost;
r++;
}
}
// Return the final answer
return totalCost;
}
// Driver code
var arr = [2, 3, 9, 8, 4];
document.write( getTotalTime(arr));
// This code is contributed by noob2000.
</script>
Time Complexity: O(N), as we are using a loop to traverse N times.
Auxiliary Space: O(1), as we are not using any extra space.
Similar Reads
Minimize Array sum by replacing elements such that Relation among adjacent elements in maintained Given an array arr[] of size N, the task is to minimize the array sum after replacing array elements with positive integers in a way such the relation among the adjacent elements (pattern of the array)is maintained. Note: If arr[i] = arr[i+1] then in the new array they both can be the same or one ca
7 min read
Maximize the count of adjacent element pairs with even sum by rearranging the Array Given an array, arr[] of N integers, the task is to find the maximum possible count of adjacent pairs with an even sum, rearranging the array arr[]. Examples: Input: arr[] = {5, 5, 1}Output: 2Explanation:The given array is already arranged to give the maximum count of adjacent pairs with an even sum
6 min read
Rearrange given Array by replacing every element with the element located at mean of adjacent elements Given an array arr[]. The array contains numbers from 0 to N-1 only, where N is the size of arr[]. The task is to modify the array in such that for each i from 0≤i<N, arr[i] = arr[ (arr[i-1] + arr[i+1]) / 2 ] There are a few exceptions: For first element of the array, arr[i-1] = 0; because previo
9 min read
Make all array elements equal by replacing adjacent pairs by their sum Given an array arr[] consisting of N integers, the task is to replace a minimum number of pairs of adjacent elements by their sum to make all array elements equal. Print the minimum number of such operations required. Examples: Input: arr[] = {1, 2, 3}Output: 1Explanation: Replace arr[0] and arr[1]
8 min read
Maximum subarray sum with same first and last element formed by removing elements Given an array arr[] of N integers, the task is to find the maximum sum of subarray having length an at least 2 whose first and last elements are the same after removing any number of array elements. If there exists no such array, then print 0. Examples: Input: arr[] = {-1, -3, -2, 4, -1, 3}Output:
6 min read