Maximum Coin Collection - Practice Coding Problems

Maximum Coin Collection - Problem

Imagine Mario driving down a bustling two-lane freeway where coins and tolls are scattered every mile! 🏎️💰

You're given two integer arrays lane1 and lane2, where each value represents the coins Mario gains (positive values) or the toll he pays (negative values) at that mile.

The Rules:

Mario always starts in lane 1 but can enter the freeway at any mile
He can switch lanes at most 2 times during his journey
He can switch lanes immediately upon entering or just before exiting
He must travel at least one mile before exiting
He can exit at any mile after traveling

Goal: Find the maximum number of coins Mario can collect by choosing the optimal entry point, exit point, and lane switching strategy.

Example: If lane1 = [1, -3, 4] and lane2 = [2, 5, -1], Mario could enter at mile 0, switch to lane 2 immediately, collect 2+5=7 coins in miles 0-1, then switch back to lane 1 for mile 2 to collect 4 more coins, totaling 11 coins with exactly 2 switches!

Input & Output

example_1.py — Basic Case

$ Input: lane1 = [1, -3, 4], lane2 = [2, 5, -1]

› Output: 11

💡 Note: Mario enters at mile 0, immediately switches to lane 2 (1 switch), collects 2+5=7 coins in miles 0-1, then switches back to lane 1 (2nd switch) to collect 4 coins in mile 2. Total: 7+4=11 coins with exactly 2 switches used.

example_2.py — No Switch Strategy

$ Input: lane1 = [5, 4, 3], lane2 = [1, 1, 1]

› Output: 12

💡 Note: Lane 1 has consistently better values, so Mario stays in lane 1 for the entire journey (0 switches), collecting 5+4+3=12 coins. This is better than any switching strategy.

example_3.py — Single Element

$ Input: lane1 = [10], lane2 = [-5]

› Output: 10

💡 Note: With only one mile available, Mario must choose the better option. He stays in lane 1 to collect 10 coins rather than switching to lane 2 which would cost him 5 coins.

Constraints

1 ≤ lane1.length, lane2.length ≤ 10³
lane1.length == lane2.length
-10³ ≤ lane1[i], lane2[i] ≤ 10³
Mario can make at most 2 lane switches
Mario must travel at least 1 mile

Visualization

Tap to expand

Understanding the Visualization

Analyze Both Lanes

Mario evaluates coin values in both lanes across all possible journey segments

Track All States

For each mile, track the maximum coins achievable in each lane with 0, 1, or 2 switches used

Make Optimal Decisions

At each position, decide whether to stay in current lane or switch (if switches remaining)

Choose Best Route

Select the journey segment and switching strategy that yields maximum total coins

Key Takeaway

🎯 Key Insight: Dynamic programming allows us to efficiently track all possible states (position + lane + switches used) and build the optimal solution by considering every valid journey segment and switching strategy.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming to track the maximum coins possible for each state: current position, current lane, and number of switches used. By trying all possible subarrays and using DP to handle lane switching optimally, we achieve O(n²) time complexity while considering all valid strategies with at most 2 lane switches.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n)	Track maximum coins for each state: position, lane, and switches used

Dynamic Programming (Optimal) — Algorithm Steps

For each possible starting position i
For each possible ending position j >= i
Use DP to track max coins with 0, 1, 2 switches used
At each position, decide whether to switch lanes or stay
Return the maximum across all possible subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create DP table tracking [position][lane][switches_used]

Base Case

Mario starts in lane1, can switch immediately to lane2

Fill States

For each position, calculate optimal coins for all valid states

Transition

Consider staying in lane or switching (if switches remaining)

Find Maximum

Return the best result across all final states

Code -

solution.c — C

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

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

int maxCoins(int* lane1, int* lane2, int n) {
    int maxResult = INT_MIN;
    
    // Try all possible subarrays
    for (int start = 0; start < n; start++) {
        for (int end = start; end < n; end++) {
            int length = end - start + 1;
            
            // Allocate 3D DP array
            int*** dp = (int***)malloc(length * sizeof(int**));
            for (int i = 0; i < length; i++) {
                dp[i] = (int**)malloc(2 * sizeof(int*));
                for (int j = 0; j < 2; j++) {
                    dp[i][j] = (int*)malloc(3 * sizeof(int));
                    for (int k = 0; k < 3; k++) {
                        dp[i][j][k] = INT_MIN;
                    }
                }
            }
            
            // Base case
            dp[0][0][0] = lane1[start];
            dp[0][1][1] = lane2[start];
            
            // Fill DP table
            for (int i = 1; i < length; i++) {
                int pos = start + i;
                
                // Stay in current lane
                for (int switches = 0; switches < 3; switches++) {
                    if (dp[i-1][0][switches] != INT_MIN) {
                        dp[i][0][switches] = max(dp[i][0][switches], 
                                               dp[i-1][0][switches] + lane1[pos]);
                    }
                    if (dp[i-1][1][switches] != INT_MIN) {
                        dp[i][1][switches] = max(dp[i][1][switches],
                                               dp[i-1][1][switches] + lane2[pos]);
                    }
                }
                
                // Switch lanes
                for (int switches = 0; switches < 2; switches++) {
                    if (dp[i-1][0][switches] != INT_MIN) {
                        dp[i][1][switches+1] = max(dp[i][1][switches+1],
                                                  dp[i-1][0][switches] + lane2[pos]);
                    }
                    if (dp[i-1][1][switches] != INT_MIN) {
                        dp[i][0][switches+1] = max(dp[i][0][switches+1],
                                                  dp[i-1][1][switches] + lane1[pos]);
                    }
                }
            }
            
            // Update result
            for (int lane = 0; lane < 2; lane++) {
                for (int switches = 0; switches < 3; switches++) {
                    if (dp[length-1][lane][switches] != INT_MIN) {
                        maxResult = max(maxResult, dp[length-1][lane][switches]);
                    }
                }
            }
            
            // Free memory
            for (int i = 0; i < length; i++) {
                for (int j = 0; j < 2; j++) {
                    free(dp[i][j]);
                }
                free(dp[i]);
            }
            free(dp);
        }
    }
    
    return maxResult;
}

int main() {
    int lane1[] = {1, -3, 4, 2};
    int lane2[] = {2, 5, -1, 3};
    int n = 4;
    
    printf("%d\n", maxCoins(lane1, lane2, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops for start and end positions, with constant work inside

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store the maximum coins for each state

⚡ Linearithmic Space

52.8K Views

Medium-High Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler