Number of Ways to Divide a Long Corridor - Problem

Along a long library corridor, there is a line of seats and decorative plants. You are given a 0-indexed string corridor of length n consisting of letters 'S' and 'P' where each 'S' represents a seat and each 'P' represents a plant.

One room divider has already been installed to the left of index 0, and another to the right of index n - 1. Additional room dividers can be installed. For each position between indices i - 1 and i (1 <= i <= n - 1), at most one divider can be installed.

Divide the corridor into non-overlapping sections, where each section has exactly two seats with any number of plants. There may be multiple ways to perform the division. Two ways are different if there is a position with a room divider installed in the first way but not in the second way.

Return the number of ways to divide the corridor. Since the answer may be very large, return it modulo 10⁹ + 7. If there is no way, return 0.

Input & Output

Example 1 — Basic Case

$ Input: corridor = "SSPPSPS"

› Output: 3

💡 Note: 6 seats total (even ✓). Seats at positions [0,1,3,4,6]. Pairs: (0,1), (3,4), (6). Gap between pairs: positions 2-3 gives 2 options, position 5-6 gives 1 option. Total: 2 × 1 = 2. Wait, let me recalculate... Actually 3 ways total.

Example 2 — No Valid Division

$ Input: corridor = "PPSPPP"

› Output: 0

💡 Note: Only 1 seat total (odd number), impossible to create sections with exactly 2 seats each.

Example 3 — Minimum Valid Case

$ Input: corridor = "SS"

› Output: 1

💡 Note: Exactly 2 seats, only one way to divide: both seats in one section.

Constraints

1 ≤ corridor.length ≤ 10⁵
corridor[i] is either 'S' or 'P'

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 M Microsoft 15 a Amazon 12

The key insight is recognizing this as a combinatorial problem. We must group seats into pairs, then count the ways to place dividers between consecutive pairs. The mathematical pattern approach finds seat positions and multiplies the gap sizes between consecutive seat-pairs. Time: O(n), Space: O(k) where k is number of seats.

Common Approaches

✓ Brute Force Recursion

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

Generate all possible combinations of divider placements and check if each creates valid sections with exactly 2 seats each. This involves exploring every possible subset of positions where dividers can be placed.

Mathematical Pattern Recognition

⏱️ Time: O(n) Space: O(k)

First check if division is possible (even number of seats). Then find positions of all seats and group them into consecutive pairs. Between each pair of seat-pairs, count the number of plants as these represent the number of ways to place the divider.

Brute Force Recursion — Algorithm Steps

Find all seat positions
Generate all possible divider combinations
For each combination, verify all sections have exactly 2 seats
Count valid arrangements

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Corridor string with seats (S) and plants (P)

Generate

Try all 2^n possible divider placements

Validate

Count arrangements where each section has exactly 2 seats

Code -

solution.c — C

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

#define MOD 1000000007

// backtrack(pos, seats) = number of valid ways to place dividers
// from position pos onwards, with `seats` seats seen in current section
long long backtrack(const char* corridor, int len, int pos, int seats) {
    // Base case: reached end of corridor
    // Valid only if last section has exactly 2 seats
    if (pos == len)
        return seats == 2 ? 1 : 0;

    // Count seat at current position
    if (corridor[pos] == 'S')
        seats++;

    // More than 2 seats in current section — invalid path
    if (seats > 2)
        return 0;

    long long ways = 0;

    if (seats == 2 && pos + 1 < len) {
        // Option 1: place a divider after pos
        // New section starts with 0 seats
        ways = (ways + backtrack(corridor, len, pos + 1, 0)) % MOD;

        // Option 2: don't place a divider, continue
        ways = (ways + backtrack(corridor, len, pos + 1, seats)) % MOD;
    } else {
        // seats < 2 or at last position — just move forward
        ways = backtrack(corridor, len, pos + 1, seats) % MOD;
    }

    return ways;
}

int solution(const char* corridor) {
    int len = (int)strlen(corridor);

    // Count total seats — must be even and nonzero
    int total = 0;
    for (int i = 0; i < len; i++)
        if (corridor[i] == 'S') total++;

    if (total == 0 || total % 2 != 0) return 0;

    return (int)backtrack(corridor, len, 0, 0);
}

int main() {
    char corridor[100001];
    if (!fgets(corridor, sizeof(corridor), stdin)) return 1;
    corridor[strcspn(corridor, "\n")] = '\0';
    printf("%d\n", solution(corridor));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Explores 2^n possible divider placements where n is corridor length

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n levels

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Number of Ways to Divide a Long Corridor - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler