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

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

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

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

## Javascript

 ``

Output:

`88`

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.