Get the Maximum Score - Practice Coding Problems

Get the Maximum Score - Problem

Path Navigation with Maximum Score

You are given two sorted arrays of distinct integers nums1 and nums2. Your goal is to find a path through these arrays that maximizes the sum of values you collect.

🛣️ Path Rules:

Start at index 0 of either array
Move left-to-right within your current array
When you encounter a value that exists in both arrays, you can switch paths
Each unique value is counted only once in your score

Example: If nums1 = [2,4,5,8,10] and nums2 = [4,6,8,9], you could take path: 2 → 4 → 6 → 8 → 9 for score = 29, or 2 → 4 → 5 → 8 → 10 for score = 29.

Return the maximum possible score modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Path Selection

$ Input: nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]

› Output: 30

💡 Note: Optimal path: 2 → 4 → 6 → 8 → 10. At intersection 4, both paths have equal sum (2 vs 0), so we can choose either. At intersection 8, path through nums2 gives us 4+6=10 vs nums1's 4+5=9, so we switch to nums2, then continue to get the maximum ending.

example_2.py — Multiple Intersections

$ Input: nums1 = [1,3,5,7,9], nums2 = [3,5,100]

› Output: 109

💡 Note: Optimal path: 1 → 3 → 5 → 100. Start with nums1 to get 1, then at intersection 3, nums1 path has sum 1 vs nums2's 0, so continue on nums1. At intersection 5, both have equal recent sums, but we can switch to nums2 to get the large value 100.

example_3.py — No Intersections

$ Input: nums1 = [1,4,5,8,9], nums2 = [2,3,6,7]

› Output: 35

💡 Note: Since there are no common elements, we must choose one complete array. nums1 sum = 27, nums2 sum = 18, so we choose nums1 entirely. Wait, that's wrong calculation. nums1=27, nums2=18, but we need to take the path that gives us maximum, which could involve taking some from each. Actually, with no intersections, we take the array with larger sum: nums1 = 1+4+5+8+9 = 27.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁷
nums1 and nums2 are strictly increasing
All elements in each array are distinct

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin on either highway, tracking toll collections separately

Collect Tolls

As you drive, accumulate tolls from your current highway

Bridge Decision

At each bridge, compare total tolls and switch to the better highway

Reset & Continue

After switching, reset toll counters and continue the journey

Final Choice

At journey's end, add the better of the two remaining highway segments

Key Takeaway

🎯 Key Insight: At each intersection, greedily choose the path segment with higher accumulated value. This works because sorted arrays ensure no future intersection will be missed, and past optimal choices remain optimal.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25

The optimal solution uses two pointers to traverse both sorted arrays simultaneously. At each intersection point (common element), we greedily choose the path segment with the higher cumulative sum. This works because the arrays are sorted, and past decisions don't affect future optimal choices. The algorithm runs in O(n+m) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to traverse both arrays simultaneously, making optimal choices at intersections
Recursive Path Exploration	O(2^k)	O(k)	Recursively explore all possible paths with memoization

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers at the start of both arrays
Maintain running sums for both current path segments
When pointers point to equal values (intersection), choose the path with higher sum
Add the intersection value and reset both running sums
Continue until both arrays are exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Two pointers start at beginning of both arrays

Advance Smaller

Move pointer with smaller value, add to running sum

Intersection Found

Equal values found - choose better path and reset

Continue Process

Repeat until all elements processed

Code -

solution.c — C

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

#define MOD 1000000007
#define max(a,b) ((a) > (b) ? (a) : (b))

int maxSum(int* nums1, int size1, int* nums2, int size2) {
    long long sum1 = 0, sum2 = 0, result = 0;
    int i = 0, j = 0;
    
    while (i < size1 && j < size2) {
        if (nums1[i] < nums2[j]) {
            sum1 += nums1[i++];
        } else if (nums1[i] > nums2[j]) {
            sum2 += nums2[j++];
        } else {
            result += max(sum1, sum2) + nums1[i];
            sum1 = sum2 = 0;
            i++;
            j++;
        }
    }
    
    while (i < size1) {
        sum1 += nums1[i++];
    }
    
    while (j < size2) {
        sum2 += nums2[j++];
    }
    
    result += max(sum1, sum2);
    
    return result % MOD;
}

int main() {
    int nums1[] = {2, 4, 5, 8, 10};
    int nums2[] = {4, 6, 8, 9};
    printf("%d\n", maxSum(nums1, 5, nums2, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both arrays with two pointers, where n and m are array lengths

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and running sums

✓ Linear Space

41.2K Views

High Frequency

~25 min Avg. Time

1.2K 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler