Maximum Score Of Spliced Array - Practice Coding Problems

Maximum Score Of Spliced Array - Problem

Imagine you have two integer arrays of equal length, and you're given a special power: you can choose any contiguous subarray from the first array and swap it with the corresponding subarray from the second array.

Your goal is to maximize the score, which is defined as the maximum sum between the two arrays after the optional swap operation.

The Challenge: Given two arrays nums1 and nums2, determine the highest possible score you can achieve by either:

Performing exactly one subarray swap between the arrays, OR
Leaving both arrays unchanged

Example: If nums1 = [1,2,3,4,5] and nums2 = [11,12,13,14,15], and you swap the subarray from index 1 to 2, you get:
• nums1 = [1,12,13,4,5] (sum = 35)
• nums2 = [11,2,3,14,15] (sum = 45)
The score would be max(35, 45) = 45

Input & Output

example_1.py — Basic Swap

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

› Output: 210

💡 Note: Swapping nums1[1] with nums2[1] gives nums1=[60,90,60] (sum=210) and nums2=[10,60,10] (sum=80). The maximum score is 210.

example_2.py — No Swap Better

$ Input: nums1 = [100,20,5], nums2 = [1,2,3]

› Output: 125

💡 Note: The original sum of nums1 (125) is already optimal. No swap can improve the score.

example_3.py — Multi-element Swap

$ Input: nums1 = [7,11,13], nums2 = [1,1,1]

› Output: 31

💡 Note: No beneficial swap exists. The original sum of nums1 (31) remains the maximum score.

Visualization

Tap to expand

Understanding the Visualization

Analyze Collections

We have two collections with different values per position

Calculate Differences

For each position, calculate the potential gain/loss from swapping

Find Best Sequence

Use Kadane's algorithm to find the consecutive sequence with maximum gain

Determine Final Score

Add the maximum gain to the original sum to get the optimal score

Key Takeaway

🎯 Key Insight: Transform the swapping problem into a maximum subarray problem using Kadane's algorithm on the difference array.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through arrays to apply Kadane's algorithm

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

Constraints

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

Asked in

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

The optimal solution uses Kadane's algorithm to find the maximum subarray sum in the difference array. By treating the problem as finding the maximum gain from swapping, we can solve it in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Subarray Swaps)	O(n³)	O(1)	Try all possible subarray swaps and find the maximum score
Kadane's Algorithm (Optimal)	O(n)	O(1)	Use modified Kadane's algorithm to find maximum subarray sum of differences

Brute Force (All Subarray Swaps) — Algorithm Steps

Calculate initial sums of both arrays
Try all possible left and right boundaries (O(n²) combinations)
For each subarray, swap elements and calculate new sums
Track the maximum score across all possibilities
Return the maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Calculate original sums of both arrays

Generate Subarrays

Try all O(n²) possible left-right combinations

Calculate Difference

For each subarray, sum up the differences

Update Score

Track maximum score across all swaps

Code -

solution.c — C

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

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

int maximumsSplicedArray(int* nums1, int* nums2, int n) {
    int originalSum1 = 0, originalSum2 = 0;
    
    for (int i = 0; i < n; i++) {
        originalSum1 += nums1[i];
        originalSum2 += nums2[i];
    }
    
    int maxScore = max(originalSum1, originalSum2);
    
    for (int left = 0; left < n; left++) {
        for (int right = left; right < n; right++) {
            int diff = 0;
            for (int i = left; i <= right; i++) {
                diff += nums2[i] - nums1[i];
            }
            
            int newSum1 = originalSum1 + diff;
            int newSum2 = originalSum2 - diff;
            
            maxScore = max(maxScore, max(newSum1, newSum2));
        }
    }
    
    return maxScore;
}

int main() {
    int nums1[] = {60, 60, 60};
    int nums2[] = {10, 90, 10};
    int n = 3;
    printf("%d\n", maximumsSplicedArray(nums1, nums2, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for all subarray combinations × O(n) to calculate sums

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

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

23.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Subarray Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler