Merge Operations to Turn Array Into a Palindrome

Merge Operations to Turn Array Into a Palindrome - Problem

You are given an array nums consisting of positive integers. You can perform the following operation on the array any number of times:

Choose any two adjacent elements and replace them with their sum.

For example, if nums = [1,2,3,1], you can apply one operation to make it [1,5,1].

Return the minimum number of operations needed to turn the array into a palindrome.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Step by step: [4,3,2,1,2,3,1] → merge last two: [4,3,2,1,2,4] → equal ends, move inward → [4,3,2,1,2,4] → merge middle elements: [4,3,2,3,4] → palindrome achieved in 2 operations

Example 2 — Already Palindrome

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

› Output: 0

💡 Note: Array is already a palindrome, so no operations needed

Example 3 — Single Element

$ Input: nums = [1]

› Output: 0

💡 Note: Single element is always a palindrome, return 0

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to use a greedy two-pointer approach where we compare elements from both ends and merge the side with the smaller value when they don't match. This minimizes operations because merging the smaller side creates a better chance for future matches. Best approach uses Two Pointers Greedy with Time: O(n), Space: O(1).

Common Approaches

✓ Optimized Two Pointers

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

Similar to two pointers but with additional optimizations for edge cases and better handling of equal adjacent elements. This approach ensures we always make the most efficient merge decision.

Recursive Backtracking

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

Recursively try merging every pair of adjacent elements and find the minimum operations needed. This explores all possible ways to transform the array into a palindrome.

Two Pointers Greedy

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

Place pointers at both ends of the array. When values don't match, merge the side with the smaller value with its neighbor. This greedy approach minimizes operations by always choosing the most beneficial merge.

Optimized Two Pointers — Algorithm Steps

Set left=0, right=n-1 pointers
While left < right, compare arr[left] vs arr[right]
If equal: move both pointers inward
If left < right: merge left with next element
If left > right: merge right with previous element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set pointers at both ends

Compare & Decide

Make optimal merge decision

Complete

Return minimum operations

Code -

solution.c — C

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

int solution(int* nums, int size) {
    int left = 0, right = size - 1;
    int operations = 0;
    
    while (left < right) {
        if (nums[left] == nums[right]) {
            left++;
            right--;
        } else if (nums[left] < nums[right]) {
            nums[left + 1] += nums[left];
            left++;
            operations++;
        } else {
            nums[right - 1] += nums[right];
            right--;
            operations++;
        }
    }
    
    return operations;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass with two pointers moving toward each other

✓ Linear Growth

Space Complexity

O(1)

Only uses pointers and operation counter, no extra arrays needed

✓ Linear Space

24.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Optimized Two Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler