Related Articles

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.

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 ;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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :