# 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 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++ 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 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 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# 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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

I am currently pursuing B Tech (Hons) in Computer Science I love technology and explore new things I want to become a very good programmer I love to travel and meet new peoples

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :