Number of Ways to Rearrange Sticks With K Sticks Visible

Number of Ways to Rearrange Sticks With K Sticks Visible - Problem

Imagine you have n uniquely-sized sticks with lengths from 1 to n (like a set of measuring sticks). Your challenge is to arrange them in a row such that exactly k sticks are visible when looking from the left.

A stick is visible from the left if there are no taller sticks standing to its left. Think of it like a skyline - you can only see buildings that aren't blocked by taller ones in front of them.

Example: If sticks are arranged as [1,3,2,5,4], then:

Stick 1 is visible (nothing blocks it)
Stick 3 is visible (only shorter stick 1 is to its left)
Stick 2 is not visible (taller stick 3 blocks it)
Stick 5 is visible (tallest so far)
Stick 4 is not visible (taller stick 5 blocks it)

So 3 sticks are visible from the left. Given n and k, return the number of arrangements where exactly k sticks are visible. Since the answer can be huge, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic case

$ Input: n = 3, k = 2

› Output: 3

💡 Note: There are 3 arrangements where exactly 2 sticks are visible: [2,1,3], [2,3,1], and [1,2,3]. In each case, exactly 2 sticks can be seen from the left.

example_2.py — Edge case k=1

$ Input: n = 5, k = 1

› Output: 24

💡 Note: Only arrangements starting with stick 5 (tallest) have exactly 1 visible stick. There are 4! = 24 ways to arrange the remaining 4 sticks after placing 5 first.

example_3.py — All visible

$ Input: n = 4, k = 4

› Output: 1

💡 Note: Only the arrangement [1,2,3,4] has all 4 sticks visible from the left, since each stick is taller than all previous ones.

Constraints

1 ≤ n ≤ 1000
0 ≤ k ≤ n
Answer fits in 32-bit integer after taking modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Tallest building insight

The tallest building (n) is always visible regardless of position

Two placement choices

Place building n as the k-th visible, or place it where it doesn't affect the count

Recursive subproblems

If n is k-th visible: solve for (n-1, k-1). If n doesn't affect count: (i-1) ways to place n among i-1 positions times solutions for (n-1, k)

Combine solutions

Total arrangements = dp[n-1][k-1] + (n-1) × dp[n-1][k]

Key Takeaway

🎯 Key Insight: The tallest element is always visible, so we can recursively build solutions by deciding whether to make it the k-th visible element or place it in a non-affecting position.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

This problem is solved using Dynamic Programming with the recurrence relation dp[i][j] = dp[i-1][j-1] + (i-1) × dp[i-1][j]. The key insight is that this is equivalent to computing unsigned Stirling numbers of the first kind, representing the number of ways to arrange n distinct objects into k cycles.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Stirling Numbers of First Kind)	O(n × k)	O(n × k)	Use dynamic programming with combinatorial insights about visible arrangements

Dynamic Programming (Stirling Numbers of First Kind) — Algorithm Steps

Create DP table dp[i][j] = number of ways to arrange i sticks with j visible
Base cases: dp[0][0] = 1, dp[i][0] = 0 for i > 0, dp[0][j] = 0 for j > 0
For each position, the tallest stick can either be at the rightmost visible position or not
Recurrence: dp[i][j] = dp[i-1][j-1] + (i-1) * dp[i-1][j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize base case

dp[0][0] = 1 (one way to arrange 0 sticks with 0 visible)

Fill row by row

For each stick count i and visible count j

Apply recurrence

dp[i][j] = dp[i-1][j-1] + (i-1) × dp[i-1][j]

Return final answer

dp[n][k] contains the result

Code -

solution.c — C

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

#define MOD 1000000007

int min(int a, int b) {
    return a < b ? a : b;
}

int numWaysToArrangeSticks(int n, int k) {
    if (k > n || k == 0) return 0;
    
    // Allocate DP table
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)calloc(k + 1, sizeof(long long));
    }
    
    // Base case
    dp[0][0] = 1;
    
    // Fill DP table
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= min(i, k); j++) {
            // Place stick i at position j (becomes j-th visible)
            dp[i][j] = dp[i-1][j-1];
            // Place stick i at any other position
            dp[i][j] = (dp[i][j] + (long long)(i-1) * dp[i-1][j]) % MOD;
        }
    }
    
    int result = dp[n][k];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Fill DP table with n rows and k columns

✓ Linear Growth

Space Complexity

O(n × k)

DP table storage, can be optimized to O(k) with rolling array

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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 (Stirling Numbers of First Kind) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler