Minimum Number of Lines to Cover Points - Problem

Array Hash Table Math Dynamic Programming Backtracking Bit Manipulation Geometry Bitmask Medium

You are given an array points where points[i] = [xi, yi] represents a point on an X-Y plane.

Straight lines are going to be added to the X-Y plane, such that every point is covered by at least one line.

Return the minimum number of straight lines needed to cover all the points.

Input & Output

Example 1 — Basic Case

$ Input: points = [[1,1],[2,2],[3,4],[4,5],[5,5]]

› Output: 3

💡 Note: One possible solution: Line 1 passes through (1,1) and (2,2); Line 2 passes through (3,4) and (4,5); Line 3 passes through (5,5). Total: 3 lines.

Example 2 — Collinear Points

$ Input: points = [[1,1],[2,2],[3,3],[4,4]]

› Output: 1

💡 Note: All points are collinear (on the line y=x), so only 1 line is needed to cover all points.

Example 3 — Minimum Case

$ Input: points = [[1,1],[2,3]]

› Output: 1

💡 Note: Any two points can be covered by exactly one line.

Constraints

1 ≤ points.length ≤ 20
points[i].length == 2
-100 ≤ points[i][0], points[i][1] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

This problem requires finding the minimum number of straight lines to cover all points. The key insight is that collinear points can share the same line. The optimal approach uses dynamic programming with bitmasks to track covered points efficiently. Time: O(2ⁿ × n²), Space: O(2ⁿ).

Common Approaches

✓ Brute Force with Backtracking

⏱️ Time: O(2ⁿ × n³) Space: O(n)

For each subset of points, try forming a line and recursively solve for remaining points. This explores all possible ways to partition points into lines.

Dynamic Programming with Bitmask

⏱️ Time: O(2ⁿ × n²) Space: O(2ⁿ)

Use dynamic programming where state represents which points are covered (bitmask). For each state, try adding different lines and take minimum.

Brute Force with Backtracking — Algorithm Steps

Generate all possible lines from pairs of points
Use backtracking to try different line combinations
Track minimum number of lines needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Lines

Create all possible lines from point pairs

Backtrack

Try different combinations of lines

Find Minimum

Return the minimum number of lines needed

Code -

solution.c — C

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

static int points[20][2];
static int n;

int areCollinear(int* p1, int* p2, int* p3) {
    return (p2[1] - p1[1]) * (p3[0] - p1[0]) == (p3[1] - p1[1]) * (p2[0] - p1[0]);
}

int getLinePoints(int i, int j, int* linePoints) {
    linePoints[0] = i;
    linePoints[1] = j;
    int count = 2;
    
    for (int k = 0; k < n; k++) {
        if (k != i && k != j && areCollinear(points[i], points[j], points[k])) {
            linePoints[count++] = k;
        }
    }
    return count;
}

int backtrack(int covered, int linesUsed) {
    if (covered == (1 << n) - 1) {
        return linesUsed;
    }
    
    if (linesUsed >= n) {  // Upper bound pruning
        return INT_MAX;
    }
    
    int result = INT_MAX;
    
    // Find first uncovered point
    int firstUncovered = -1;
    for (int i = 0; i < n; i++) {
        if (!(covered & (1 << i))) {
            firstUncovered = i;
            break;
        }
    }
    
    if (firstUncovered == -1) {
        return linesUsed;
    }
    
    // Try pairing first uncovered point with all other points
    for (int j = 0; j < n; j++) {
        if (j == firstUncovered) continue;
        
        int linePoints[20];
        int count = getLinePoints(firstUncovered, j, linePoints);
        int newCovered = covered;
        for (int k = 0; k < count; k++) {
            newCovered |= (1 << linePoints[k]);
        }
        
        // Only proceed if we actually cover the first uncovered point
        if (newCovered & (1 << firstUncovered)) {
            int subResult = backtrack(newCovered, linesUsed + 1);
            if (subResult != INT_MAX && subResult < result) {
                result = subResult;
            }
        }
    }
    
    return result;
}

int solution() {
    if (n <= 2) return n > 0 ? 1 : 0;
    
    return backtrack(0, 0);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse the input
    n = 0;
    char* ptr = input;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;  // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n')) ptr++;
        if (*ptr == ']') break;
        
        if (*ptr == '[') {
            ptr++;  // Skip opening bracket of point
            // Read x coordinate
            points[n][0] = (int)strtol(ptr, &ptr, 10);
            // Skip comma
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            // Read y coordinate
            points[n][1] = (int)strtol(ptr, &ptr, 10);
            // Skip to closing bracket
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    int result = solution();
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n³)

Exponential combinations of point subsets, with O(n³) work to check collinearity

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary storage for current solution

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

485 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

Minimum Number of Lines to Cover Points - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler