Largest Element in an Array after Merge Operations

Largest Element in an Array after Merge Operations - Problem

Array Greedy Medium

Problem: Given an array of positive integers, you can repeatedly perform a merge operation to grow elements and find the maximum possible value.

The Merge Rule: Choose any index i where nums[i] ≤ nums[i+1], then:

Replace nums[i+1] with nums[i] + nums[i+1]
Remove nums[i] from the array

Goal: Return the largest element you can create through these merge operations.

Example: [2, 1, 4, 9] → We can merge 2+4=6, then 1+6=7, then 7+9=16 for a maximum of 16.

Input & Output

example_1.py — Basic Merge Operations

$ Input: [2, 1, 4, 9]

› Output: 14

💡 Note: Start from index 1: 1 ≤ 4, so merge to get [2, 5, 9]. Then 5 ≤ 9, merge to get [2, 14]. Maximum element is 14.

example_2.py — No Merges Possible

$ Input: [5, 3, 3]

› Output: 5

💡 Note: 5 > 3, so we can't merge indices 0,1. 3 ≤ 3, so we can merge indices 1,2 to get [5, 6]. Maximum is 6. Wait, let me recalculate... Actually, we try each starting position: from 0→5, from 1→3+3=6, from 2→3. So maximum is 6.

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: Array has only one element, so no merges are possible. The maximum (and only) element is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Survey the Terrain

Look at your rock piles: [2, 1, 4, 9]

Try Each Starting Point

Consider building from each position to see which gives the tallest mountain

Greedy Absorption

From each starting point, greedily absorb all rocks to the right that you can

Track the Tallest

Keep track of the tallest mountain you can build from any starting position

Key Takeaway

🎯 Key Insight: The greedy backwards approach works because we want to maximize the potential absorption from each starting position. By trying each position and greedily absorbing elements to the right, we find the optimal solution in O(n) time.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a greedy backwards approach. For each starting position, we greedily absorb all elements to the right where the merge condition is satisfied (current sum ≤ next element). The key insight is that we want to maximize absorption from each position, and the answer is the maximum across all possible starting positions.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Merge Sequences)	O(2^n)	O(n²)	Recursively try all possible merge operations and track the maximum result
Greedy Backwards Traversal (Optimal)	O(n)	O(1)	Work backwards from right to left, greedily absorbing all possible elements

Brute Force (Try All Merge Sequences) — Algorithm Steps

Find all valid merge positions (where nums[i] <= nums[i+1])
For each valid position, create new array with merge applied
Recursively solve the subproblem
Return maximum result across all possibilities
Base case: when no merges are possible, return max element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [2,1,4,9]

Find Valid Merges

Identify positions where nums[i] <= nums[i+1]

Branch for Each Option

Create recursive branches for each valid merge

Continue Recursively

Repeat process on each resulting array

Track Maximum

Keep track of maximum element found across all paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

long long max(long long a, long long b) {
    return a > b ? a : b;
}

long long solve(long long* arr, int size) {
    if (size <= 1) {
        return size == 0 ? 0 : arr[0];
    }
    
    long long maxResult = arr[0];
    for (int i = 1; i < size; i++) {
        maxResult = max(maxResult, arr[i]);
    }
    
    // Try all possible merges
    for (int i = 0; i < size - 1; i++) {
        if (arr[i] <= arr[i + 1]) {
            // Create new array with merge
            long long* newArr = (long long*)malloc((size - 1) * sizeof(long long));
            int idx = 0;
            for (int j = 0; j < i; j++) {
                newArr[idx++] = arr[j];
            }
            newArr[idx++] = arr[i] + arr[i + 1];
            for (int j = i + 2; j < size; j++) {
                newArr[idx++] = arr[j];
            }
            
            long long result = solve(newArr, size - 1);
            maxResult = max(maxResult, result);
            free(newArr);
        }
    }
    
    return maxResult;
}

long long largestElementAfterMerge(int* nums, int size) {
    long long* arr = (long long*)malloc(size * sizeof(long long));
    for (int i = 0; i < size; i++) {
        arr[i] = nums[i];
    }
    long long result = solve(arr, size);
    free(arr);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    printf("%lld\n", largestElementAfterMerge(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, each position can lead to multiple recursive branches, creating exponential possibilities

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive call stack depth times array copying overhead

⚠ Quadratic Space

25.4K Views

Medium Frequency

~18 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Merge Sequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler