Uncrossed Lines

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.

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

Visualization

Tap to expand

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

✓ Dynamic Programming (Bottom-Up)

⏱️ Time: O(m*n) Space: O(m*n)

Create a 2D table where dp[i][j] represents the maximum uncrossed lines between first i elements of nums1 and first j elements of nums2. Fill the table systematically using the recurrence relation.

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>

static int dp[1001][1001];

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    while (*p) {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int maxUncrossedLines(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int m = nums1Size, n = nums2Size;
    
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            dp[i][j] = 0;
        }
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; 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;
            }
        }
    }
    
    return dp[m][n];
}

int main() {
    char line1[10000], line2[10000];
    
    if (fgets(line1, sizeof(line1), stdin) && fgets(line2, sizeof(line2), stdin)) {
        line1[strcspn(line1, "\n")] = 0;
        line2[strcspn(line2, "\n")] = 0;
        
        int nums1[1000], nums2[1000];
        int nums1Size, nums2Size;
        
        parseArray(line1, nums1, &nums1Size);
        parseArray(line2, nums2, &nums2Size);
        
        printf("%d\n", maxUncrossedLines(nums1, nums1Size, nums2, nums2Size));
    }
    
    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

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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler