1621. Number of Sets of K Non-Overlapping Line Segments

Difficulty:
Related Topics:
Similar Questions:

    Problem

    Given n points on a 1-D plane, where the ith point (from 0 to n-1) is at x = i, find the number of ways we can draw exactly k non-overlapping line segments such that each segment covers two or more points. The endpoints of each segment must have integral coordinates. The k line segments do not have to cover all n points, and they are allowed to share endpoints.

    Return **the number of ways we can draw *k* non-overlapping line segments**. Since this number can be huge, return it modulo 10^9 + 7.

      Example 1:

    Input: n = 4, k = 2
    Output: 5
    Explanation: The two line segments are shown in red and blue.
    The image above shows the 5 different ways {(0,2),(2,3)}, {(0,1),(1,3)}, {(0,1),(2,3)}, {(1,2),(2,3)}, {(0,1),(1,2)}.
    

    Example 2:

    Input: n = 3, k = 1
    Output: 3
    Explanation: The 3 ways are {(0,1)}, {(0,2)}, {(1,2)}.
    

    Example 3:

    Input: n = 30, k = 7
    Output: 796297179
    Explanation: The total number of possible ways to draw 7 line segments is 3796297200. Taking this number modulo 10^9 + 7 gives us 796297179.
    

      Constraints:

    Solution (Java)

    class Solution {
        public int numberOfSets(int n, int k) {
            if (n - 1 >= k) {
                int[] dp = new int[k];
                int[] sums = new int[k];
                int mod = (int) (1e9 + 7);
                for (int diff = 1; diff < n - k + 1; diff++) {
                    dp[0] = ((diff + 1) * diff) >> 1;
                    sums[0] = (sums[0] + dp[0]) % mod;
                    for (int segments = 2; segments <= k; segments++) {
                        dp[segments - 1] = (sums[segments - 2] + dp[segments - 1]) % mod;
                        sums[segments - 1] = (sums[segments - 1] + dp[segments - 1]) % mod;
                    }
                }
                return dp[k - 1];
            } else {
                return 0;
            }
        }
    }
    

    Explain:

    nope.

    Complexity: