Number of Sets of K Non-Overlapping Line Segments

Number of Sets of K Non-Overlapping Line Segments - Problem

Imagine you're a city planner working on a 1-dimensional street with n evenly spaced points numbered from 0 to n-1. Your task is to determine how many different ways you can draw exactly k non-overlapping line segments to represent different zones or districts.

Key Requirements:

Each line segment must connect at least 2 points
Line segments are non-overlapping (they can share endpoints but not interior points)
You need exactly k segments
Not all points need to be covered
Return the count modulo 10⁹ + 7

Example: With points [0, 1, 2, 3] and k=2, you could draw segments [0,1] and [2,3], or [0,2] and [3,3], etc.

Input & Output

example_1.py — Basic case

$ Input: n = 4, k = 2

› Output: 5

💡 Note: With 4 points [0,1,2,3] and k=2 segments, we can place: [0,1]+[2,3], [0,2]+[3,3], [0,0]+[1,2], [0,0]+[2,3], [1,1]+[2,3]. Total: 5 ways.

example_2.py — Edge case

$ Input: n = 3, k = 1

› Output: 3

💡 Note: With 3 points and 1 segment, we can place segment at: [0,1], [0,2], or [1,2]. Total: 3 ways.

example_3.py — Zero segments

$ Input: n = 5, k = 0

› Output: 1

💡 Note: There's exactly 1 way to draw 0 segments: draw nothing.

Constraints

2 ≤ n ≤ 1000
1 ≤ k ≤ 1000
Line segments must cover at least 2 points
Segments are non-overlapping but can share endpoints

Visualization

Tap to expand

Understanding the Visualization

Setup

We have n positions (0 to n-1) where we can place bridge supports

Constraint

Each bridge must span at least 2 positions and bridges cannot overlap

Insight

This becomes a combinatorial problem: choosing 2k endpoints from n+k-1 positions

Formula

Apply C(n+k-1, 2k) using modular arithmetic

Key Takeaway

🎯 Key Insight: The problem transforms into a beautiful combinatorial formula C(n+k-1, 2k) by recognizing the relationship between segment placement and choosing endpoints in an expanded space.

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 f Meta 12

This problem has an elegant combinatorial solution using the formula C(n+k-1, 2k). The key insight is recognizing that placing k non-overlapping segments is equivalent to choosing 2k endpoints from an expanded space of n+k-1 positions using stars and bars technique. The optimal solution runs in O(k) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming Solution	O(k)	O(1)	Use DP to build solutions incrementally by tracking segments at each position

Dynamic Programming Solution — Algorithm Steps

Recognize this as a combinatorial problem: choosing endpoints for k segments
Use the mathematical insight: answer = C(n+k-1, 2*k)
Implement efficient combination calculation with modular arithmetic
Handle edge cases where k=0 or n is insufficient

Visualization

Tap to expand

Step-by-Step Walkthrough

Insight

Recognize this as choosing 2k endpoints from expanded space

Formula

Apply stars and bars: C(n+k-1, 2k)

Calculate

Use modular arithmetic to compute combination

Result

Return the final count modulo 10^9+7

Code -

solution.c — C

#include <stdio.h>

#define MOD 1000000007

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp /= 2;
        base = (base * base) % mod;
    }
    return result;
}

long long modInverse(long long a, long long mod) {
    return modPow(a, mod - 2, mod);
}

int combination(int n, int r, long long mod) {
    if (r > n || r < 0) return 0;
    if (r == 0 || r == n) return 1;
    
    long long numerator = 1;
    long long denominator = 1;
    
    for (int i = 0; i < r; i++) {
        numerator = (numerator * (n - i)) % mod;
        denominator = (denominator * (i + 1)) % mod;
    }
    
    return (numerator * modInverse(denominator, mod)) % mod;
}

int numberOfSets(int n, int k) {
    if (k == 0) return 1;
    if (k > n) return 0;
    
    return combination(n + k - 1, 2 * k, MOD);
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    printf("%d\n", numberOfSets(n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

We only need to calculate C(n+k-1, 2*k) which takes O(k) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

842 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 Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler