Uncrossed Lines - Practice Coding Problems

Uncrossed Lines - Problem

Uncrossed Lines is a fascinating dynamic programming challenge that visualizes connections between two sequences.

Given two integer arrays nums1 and nums2, imagine writing the numbers from nums1 on a horizontal line and the numbers from nums2 on another horizontal line below it. Your goal is to draw straight connecting lines between matching numbers (where nums1[i] == nums2[j]) with the following constraints:

• No crossing lines: Any two connecting lines cannot intersect
• One connection per number: Each number can only be used in one connecting line
• Order preservation: Lines must maintain the relative ordering of elements

Return the maximum number of connecting lines you can draw. This problem is essentially finding the Longest Common Subsequence (LCS) between two arrays!

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,4,2], nums2 = [1,2,4]

› Output: 2

💡 Note: We can draw 2 uncrossed lines: connect the 1s and connect 2 in nums1 to 2 in nums2. We cannot connect 4s because it would cross the line connecting the 2s.

example_2.py — No Common Elements

$ Input: nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]

› Output: 3

💡 Note: We can connect three pairs: (5,5), (1,1), and (2,2). The optimal strategy is to find the longest common subsequence while maintaining order.

example_3.py — Single Elements

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

› Output: 2

💡 Note: We can connect (1,1) and (5,5). Even though there are multiple 1s, we can only use each position once to avoid crossing.

Visualization

Tap to expand

Understanding the Visualization

Layout the Streets

Place nums1 houses on top street, nums2 houses on bottom street

Find Matching Houses

Identify houses with same numbers that could be connected

Connect Without Crossing

Draw cables between matching houses ensuring no crossings

Maximize Connections

Use DP to find the optimal set of non-crossing connections

Key Takeaway

🎯 Key Insight: This is the Longest Common Subsequence problem in disguise! Uncrossed lines preserve order, just like LCS preserves the relative ordering of common elements.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

We fill each cell of the m×n table exactly once

✓ Linear Growth

Space Complexity

O(m*n)

We store the entire 2D DP table

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 500
1 ≤ nums1[i], nums2[j] ≤ 2000
No crossing lines allowed
Each number can be used at most once

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 Apple 18

The optimal solution uses Dynamic Programming with O(mn) time complexity. This problem is equivalent to finding the Longest Common Subsequence (LCS) between two arrays. The key insight is that uncrossed lines maintain the relative order of elements, which is exactly what LCS preserves. Use a 2D DP table where dp[i][j] represents maximum uncrossed lines between first i elements of nums1 and first j elements of nums2.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(m*n)	O(m*n)	Build solution table from bottom-up using 2D DP

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create a 2D DP table of size (m+1) × (n+1)
Initialize base cases: dp[0][j] = 0 and dp[i][0] = 0
For each cell dp[i][j], check if nums1[i-1] == nums2[j-1]
If match: dp[i][j] = dp[i-1][j-1] + 1
If no match: dp[i][j] = max(dp[i-1][j], dp[i][j-1])
Return dp[m][n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create (m+1)×(n+1) table with zeros

Fill Cell by Cell

For each cell, check if characters match

Match Case

If match: add 1 to diagonal value

No Match Case

If no match: take max of left and top cells

Code -

solution.c — C

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

int maxUncrossedLines(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int** dp = (int**)malloc((nums1Size + 1) * sizeof(int*));
    for (int i = 0; i <= nums1Size; i++) {
        dp[i] = (int*)calloc(nums2Size + 1, sizeof(int));
    }
    
    for (int i = 1; i <= nums1Size; i++) {
        for (int j = 1; j <= nums2Size; j++) {
            if (nums1[i - 1] == nums2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                int max_val = dp[i - 1][j] > dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1];
                dp[i][j] = max_val;
            }
        }
    }
    
    int result = dp[nums1Size][nums2Size];
    
    // Free memory
    for (int i = 0; i <= nums1Size; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

We fill each cell of the m×n table exactly once

✓ Linear Growth

Space Complexity

O(m*n)

We store the entire 2D DP table

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 500
1 ≤ nums1[i], nums2[j] ≤ 2000
No crossing lines allowed
Each number can be used at most once

67.2K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler