Largest Element in an Array after Merge Operations

Largest Element in an Array after Merge Operations - Problem

Array Greedy Medium

You are given a 0-indexed array nums consisting of positive integers.

You can perform the following operation on the array any number of times:

Choose an index i such that 0 <= i < nums.length - 1 and nums[i] <= nums[i + 1]
Replace the element nums[i + 1] with nums[i] + nums[i + 1] and delete the element nums[i] from the array

Return the largest element that you can possibly obtain in the final array after performing the merge operations optimally.

Input & Output

Example 1 — Basic Merging

$ Input: nums = [2,1,3,4]

› Output: 10

💡 Note: Working right-to-left: Start with 4. Since 3 ≤ 4, merge to get 7. Since 1 ≤ 7, merge to get 8. Since 2 ≤ 8, merge to get 10. Final answer is 10.

Example 2 — Cannot Merge All

$ Input: nums = [5,3,3]

› Output: 6

💡 Note: Start with 3. Since 3 ≤ 3, merge to get 6. Since 5 > 6, cannot merge. Maximum between 5 and 6 is 6.

Example 3 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Only one element, so the maximum possible value is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The key insight is to process the array from right to left. Each element can potentially absorb all smaller elements to its left through merge operations. The optimal greedy approach achieves O(n) time and O(1) space by maintaining the current accumulated value and tracking the maximum seen.

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(2ⁿ) Space: O(n)

Repeatedly scan the array looking for valid merge positions (where nums[i] <= nums[i+1]), perform all possible merges, and track the maximum element seen. Continue until no more merges are possible.

Greedy Right-to-Left

⏱️ Time: O(n) Space: O(1)

The key insight is that we should process from right to left. Each element can potentially absorb all smaller elements to its left. We maintain the maximum possible value at each position by greedily merging when beneficial.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int parseArray(char* line, long long* arr) {
    int size = 0;
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    
    if (!start || !end || start >= end) return 0;
    
    start++; // Skip '['
    
    char* token_start = start;
    while (token_start < end) {
        while (token_start < end && (*token_start == ' ' || *token_start == ',')) {
            token_start++;
        }
        
        if (token_start >= end) break;
        
        char* token_end = token_start;
        while (token_end < end && *token_end != ',' && *token_end != ']') {
            token_end++;
        }
        
        if (token_end > token_start) {
            char temp = *token_end;
            *token_end = '\0';
            arr[size++] = atoll(token_start);
            *token_end = temp;
        }
        
        token_start = token_end;
    }
    
    return size;
}

long long largestElement(long long* nums, int numsSize) {
    if (numsSize == 0) return 0;
    if (numsSize == 1) return nums[0];
    
    // Work backwards through the array
    for (int i = numsSize - 2; i >= 0; i--) {
        // If we can merge nums[i] with nums[i+1]
        if (nums[i] <= nums[i+1]) {
            nums[i] = nums[i] + nums[i+1];
        }
    }
    
    // Find the maximum element in the array
    long long maxElement = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > maxElement) {
            maxElement = nums[i];
        }
    }
    
    return maxElement;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    static long long nums[1000];
    int numsSize = parseArray(line, nums);
    
    long long result = largestElement(nums, numsSize);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 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