Get the Maximum Score

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 = 1+4+5+8+9 = 27, nums2 sum = 2+3+6+7 = 18, so we choose nums1 entirely for a total of 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

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

✓ Recursive Path Exploration

⏱️ Time: O(2^k) Space: O(k)

Generate all possible paths by recursively choosing between arrays at each intersection point. This approach explores every valid combination of path switches, which grows exponentially with the number of common elements.

Two Pointers (Optimal)

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

Since both arrays are sorted, we can use two pointers to traverse them simultaneously. At each intersection point (common element), we compare the cumulative sums from both paths and choose the better one. This greedy approach works because past decisions don't affect future optimal choices.

Recursive Path Exploration — Algorithm Steps

Find all intersection points (common elements) between arrays
For each intersection, recursively explore both path choices
Calculate sum for each complete path
Return maximum sum found across all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with both arrays and two possible starting paths

First Intersection

At common element 4, branch into two recursive calls

Recursive Branching

Each intersection creates exponential branches

Path Completion

Base case reached, return path sum

Code -

solution.c — C

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

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

typedef struct {
    int i1, i2, val;
} Intersection;

int* parseInput(char* line, int* size) {
    int* result = malloc(100000 * sizeof(int));
    *size = 0;
    char* token = strtok(line, ",");
    while (token != NULL) {
        result[(*size)++] = atoi(token);
        token = strtok(NULL, ",");
    }
    return result;
}

int maxSum(int* nums1, int size1, int* nums2, int size2) {
    Intersection intersections[100000];
    int intersectionCount = 0;
    
    int i = 0, j = 0;
    // Find all intersection points
    while (i < size1 && j < size2) {
        if (nums1[i] == nums2[j]) {
            intersections[intersectionCount++] = (Intersection){i, j, nums1[i]};
            i++;
            j++;
        } else if (nums1[i] < nums2[j]) {
            i++;
        } else {
            j++;
        }
    }
    
    // If no intersections, choose the array with larger sum
    if (intersectionCount == 0) {
        long long sum1 = 0, sum2 = 0;
        for (int k = 0; k < size1; k++) sum1 += nums1[k];
        for (int k = 0; k < size2; k++) sum2 += nums2[k];
        return max(sum1, sum2) % MOD;
    }
    
    // Calculate segments and find maximum path
    long long result = 0;
    int prevI1 = 0, prevI2 = 0;
    
    for (int k = 0; k < intersectionCount; k++) {
        // Sum segment before this intersection
        long long sum1 = 0, sum2 = 0;
        for (int idx = prevI1; idx < intersections[k].i1; idx++) sum1 += nums1[idx];
        for (int idx = prevI2; idx < intersections[k].i2; idx++) sum2 += nums2[idx];
        
        result += max(sum1, sum2) + intersections[k].val;
        
        prevI1 = intersections[k].i1 + 1;
        prevI2 = intersections[k].i2 + 1;
    }
    
    // Add remaining elements after last intersection
    long long sum1 = 0, sum2 = 0;
    for (int idx = prevI1; idx < size1; idx++) sum1 += nums1[idx];
    for (int idx = prevI2; idx < size2; idx++) sum2 += nums2[idx];
    result += max(sum1, sum2);
    
    return result % MOD;
}

int main() {
    char line1[1000000], line2[1000000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int size1, size2;
    int* nums1 = parseInput(line1, &size1);
    int* nums2 = parseInput(line2, &size2);
    
    printf("%d\n", maxSum(nums1, size1, nums2, size2));
    
    free(nums1);
    free(nums2);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k)

Where k is the number of common elements. Each intersection creates 2 choices, leading to exponential paths

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is bounded by number of intersection points

✓ 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

Recursive Path Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler