Minimum Number of Lines to Cover Points - Practice Coding Problems

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 of points on a 2D coordinate plane, where each point is represented as points[i] = [xi, yi]. Your task is to determine the minimum number of straight lines needed to cover all the given points, where each point must be covered by at least one line.

A straight line can be horizontal, vertical, or diagonal, and can extend infinitely in both directions. Multiple points can lie on the same line, which helps minimize the total number of lines needed.

Goal: Find the minimum number of lines required such that every point in the input array lies on at least one of these lines.

This problem combines geometry concepts with optimization techniques, making it perfect for testing your understanding of coordinate geometry and dynamic programming with bitmasks.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Points [0,0], [1,1], [2,2] are collinear and can be covered by one line. Point [3,4] requires a separate line. Total: 2 lines.

example_2.py — All Points Collinear

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

› Output: 1

💡 Note: All points lie on the same line y = x, so only 1 line is needed to cover all points.

example_3.py — No Collinear Points

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

› Output: 2

💡 Note: No three points are collinear. We need at least 2 lines: one covering two points and another covering the remaining point.

Visualization

Tap to expand

Understanding the Visualization

Survey Buildings

Identify all building locations (points) that need road access

Plan Possible Roads

Consider all possible straight roads that could connect multiple buildings

Optimize Road Network

Use dynamic programming to find minimum roads covering all buildings

Final Network

Achieve complete coverage with minimum infrastructure cost

Key Takeaway

🎯 Key Insight: Use bitmasks to represent which points are covered and dynamic programming to find the minimum number of lines needed to cover all points efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2)

2^n states in bitmask DP, for each state we try O(n^2) possible lines

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for each of the 2^n possible states

⚠ Quadratic Space

Constraints

1 ≤ points.length ≤ 20
-100 ≤ x_i, y_i ≤ 100
All points are distinct
Points can be arranged in any geometric configuration

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses dynamic programming with bitmasks to efficiently explore all possible combinations of lines. The key insight is representing covered points as bits in an integer, allowing us to use memoization to avoid recomputing the same states. While the time complexity is exponential, it's practical for the given constraints (n ≤ 20).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Bitmask DP	O(2^n * n^2)	O(2^n)	Try all possible combinations of lines using dynamic programming with bitmasks

Brute Force with Bitmask DP — Algorithm Steps

Generate all possible lines by considering every pair of points
For each line, determine which points lie on it using collinearity check
Use bitmask DP where each bit represents whether a point is covered
For each state, try adding each possible line and recurse
Return minimum lines needed to cover all points (all bits set)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Lines

Create all possible lines through point pairs

Bitmask States

Each bit represents if a point is covered

DP Transition

Try adding each line and recurse on new state

Optimal Solution

Find minimum lines to reach all-covered state

Code -

solution.c — C

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

#define MAX_POINTS 20
#define MAX_STATES (1 << MAX_POINTS)

static int memo[MAX_STATES];
static int lines[MAX_POINTS * MAX_POINTS];
static int lineCount;
static int n;

int dp(int covered) {
    if (covered == (1 << n) - 1) return 0;
    if (memo[covered] != -1) return memo[covered];
    
    int result = INT_MAX;
    for (int i = 0; i < lineCount; i++) {
        int newCovered = covered | lines[i];
        if (newCovered != covered) {
            int temp = 1 + dp(newCovered);
            if (temp < result) result = temp;
        }
    }
    
    return memo[covered] = result;
}

int minimumLines(int points[][2], int pointsSize) {
    n = pointsSize;
    if (n <= 2) return n > 0 ? 1 : 0;
    
    memset(memo, -1, sizeof(memo));
    lineCount = 0;
    
    // Single point lines
    for (int i = 0; i < n; i++) {
        lines[lineCount++] = 1 << i;
    }
    
    // Lines through pairs of points
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int mask = 0;
            int x1 = points[i][0], y1 = points[i][1];
            int x2 = points[j][0], y2 = points[j][1];
            
            for (int k = 0; k < n; k++) {
                int x3 = points[k][0], y3 = points[k][1];
                if ((y2 - y1) * (x3 - x1) == (y3 - y1) * (x2 - x1)) {
                    mask |= (1 << k);
                }
            }
            lines[lineCount++] = mask;
        }
    }
    
    return dp(0);
}

int main() {
    int points[][2] = {{0,0},{1,1},{2,2},{3,4}};
    printf("%d\n", minimumLines(points, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2)

2^n states in bitmask DP, for each state we try O(n^2) possible lines

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for each of the 2^n possible states

⚠ Quadratic Space

Constraints

1 ≤ points.length ≤ 20
-100 ≤ x_i, y_i ≤ 100
All points are distinct
Points can be arranged in any geometric configuration

24.8K Views

Medium Frequency

~25 min Avg. Time

856 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

Brute Force with Bitmask DP — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler