Related Articles
Maximum sum of Array formed by replacing each element with sum of adjacent elements
• Difficulty Level : Expert
• Last Updated : 28 Aug, 2020

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.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ``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 ;eft 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

 `// 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 ;eft 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

 `# 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 ;eft 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#

 `// 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 ;eft 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`
Output:
```88
```

Time complexity: O(N)

space complexity: O(N)

My Personal Notes arrow_drop_up