Maximum Score Of Spliced Array

Maximum Score Of Spliced Array - Problem

You are given two 0-indexed integer arrays nums1 and nums2, both of length n.

You can choose two integers left and right where 0 <= left <= right < n and swap the subarray nums1[left...right] with the subarray nums2[left...right].

For example, if nums1 = [1,2,3,4,5] and nums2 = [11,12,13,14,15] and you choose left = 1 and right = 2, nums1 becomes [1,12,13,4,5] and nums2 becomes [11,2,3,14,15].

You may choose to apply the mentioned operation once or not do anything.

The score of the arrays is the maximum of sum(nums1) and sum(nums2), where sum(arr) is the sum of all the elements in the array arr.

Return the maximum possible score.

Input & Output

Example 1 — Basic Swap

$ Input: nums1 = [60,60,60], nums2 = [10,90,10]

› Output: 210

💡 Note: Swap index 1: nums1 becomes [60,90,60] with sum 210, nums2 becomes [10,60,10] with sum 80. Maximum is 210.

Example 2 — No Swap Better

$ Input: nums1 = [20,40,20,70,30], nums2 = [50,20,50,40,20]

› Output: 220

💡 Note: Original sums are both 180. Using Kadane's algorithm to find optimal subarray swap: the maximum benefit from swapping is 40, achieved by swapping subarray [0,2] giving nums1=[50,20,50,70,30] (sum=220) and nums2=[20,40,20,40,20] (sum=140). Maximum is 220.

Example 3 — Single Element

$ Input: nums1 = [100], nums2 = [50]

› Output: 100

💡 Note: Can swap to get nums1=[50], nums2=[100], but original nums1 sum of 100 is already maximum.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
nums1.length == nums2.length
-10⁴ ≤ nums1[i], nums2[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use Kadane's algorithm on the difference array to find the optimal subarray to swap. Instead of trying all O(n²) possible swaps, we calculate the benefit of each position swap and find the maximum subarray benefit in O(n) time. Best approach uses Kadane's algorithm: Time O(n), Space O(1).

Common Approaches

✓ Brute Force - Try All Swaps

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

For each possible left and right boundary, swap the subarrays between nums1 and nums2, calculate both array sums, and track the maximum score achieved.

Kadane's Algorithm - Optimal Solution

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

Create difference arrays (nums2[i] - nums1[i]) and (nums1[i] - nums2[i]), then use Kadane's algorithm to find the maximum subarray sum. This represents the maximum benefit we can get by swapping subarrays.

Brute Force - Try All Swaps — Algorithm Steps

Try all possible left and right boundaries
For each pair, swap subarrays and calculate sums
Track the maximum score from all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Arrays

Start with nums1 and nums2

Try All Swaps

Test every left,right boundary pair

Maximum Score

Return the highest score found

Code -

solution.c — C

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

long long solution(int* nums1, int* nums2, int n) {
    // Calculate initial sums
    long long sum1 = 0, sum2 = 0;
    for (int i = 0; i < n; i++) {
        sum1 += nums1[i];
        sum2 += nums2[i];
    }
    long long maxScore = sum1 > sum2 ? sum1 : sum2;
    
    // Try all possible swaps
    for (int left = 0; left < n; left++) {
        for (int right = left; right < n; right++) {
            // Calculate the change in sums after swapping subarray [left, right]
            long long swapDiff = 0;
            for (int i = left; i <= right; i++) {
                swapDiff += nums2[i] - nums1[i];
            }
            
            // After swapping: nums1 sum becomes sum1 + swapDiff, nums2 sum becomes sum2 - swapDiff
            long long newSum1 = sum1 + swapDiff;
            long long newSum2 = sum2 - swapDiff;
            
            long long score = newSum1 > newSum2 ? newSum1 : newSum2;
            maxScore = score > maxScore ? score : maxScore;
        }
    }
    
    return maxScore;
}

int main() {
    char line[10000];
    int nums1[1000], nums2[1000];
    int n1 = 0, n2 = 0;
    
    // Parse nums1
    fgets(line, sizeof(line), stdin);
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums1[n1++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Parse nums2
    fgets(line, sizeof(line), stdin);
    ptr = strchr(line, '[') + 1;
    token = strtok(ptr, ",]");
    while (token != NULL) {
        nums2[n2++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%lld\n", solution(nums1, nums2, n1));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops for left/right boundaries (O(n²)) and sum calculation for each swap (O(n))

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track maximum score and current sums

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

423 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 Swaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler