Count All Valid Pickup and Delivery Options

Count All Valid Pickup and Delivery Options - Problem

Given n orders, each order consists of a pickup and a delivery service.

Count all valid pickup/delivery possible sequences such that delivery(i) is always after pickup(i).

Since the answer may be too large, return it modulo 10^9 + 7.

Example: If n=1, we have one order. The valid sequences are: [P1, D1]. Answer = 1.

Example: If n=2, we have two orders. Valid sequences include: [P1, P2, D1, D2], [P1, P2, D2, D1], [P1, D1, P2, D2], [P2, P1, D1, D2], [P2, P1, D2, D1], [P2, D2, P1, D1]. Answer = 6.

Input & Output

Example 1 — Single Order

$ Input: n = 1

› Output: 1

💡 Note: With 1 order, we have one pickup P1 and one delivery D1. The only valid sequence is [P1, D1], so the answer is 1.

Example 2 — Two Orders

$ Input: n = 2

› Output: 6

💡 Note: With 2 orders, valid sequences are: [P1,P2,D1,D2], [P1,P2,D2,D1], [P1,D1,P2,D2], [P2,P1,D1,D2], [P2,P1,D2,D1], [P2,D2,P1,D1]. Total = 6.

Example 3 — Three Orders

$ Input: n = 3

› Output: 90

💡 Note: With 3 orders, following the pattern: 1 × 1 × 2 × 3 × 3 × 5 = 90 valid sequences where each delivery comes after its pickup.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is recognizing the mathematical pattern: each new order can be inserted in 2i-1 positions, and there are i ways to assign it. The optimal approach uses the formula: result = ∏(i=1 to n) i × (2i-1). Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Generate All Permutations

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

Generate all permutations of 2n elements (n pickups and n deliveries) and check each sequence to ensure every delivery comes after its corresponding pickup.

Mathematical Formula

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

The number of valid sequences follows a pattern: result = n! × 2^n. This can be derived by considering that we have n! ways to arrange the orders, and for each arrangement, we have specific positions where deliveries can be placed.

Recursive with Memoization

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

Build sequences recursively by choosing to place either a pickup or delivery at each step, while maintaining constraints. Use memoization to avoid recalculating the same subproblems.

Brute Force - Generate All Permutations — Algorithm Steps

Generate all permutations of P1,D1,P2,D2,...,Pn,Dn
For each permutation, check if Di comes after Pi for all i
Count valid permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Elements

Create P1,D1,P2,D2 for n=2

Check All Permutations

Validate each sequence: D1 after P1, D2 after P2

Count Valid

Count sequences where all deliveries come after pickups

Code -

solution.c — C

#include <stdio.h>

#define MOD 1000000007

int solution(int n) {
    long long result = 1;
    for (int i = 1; i <= n; i++) {
        result = (result * i * (2 * i - 1)) % MOD;
    }
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O((2n)!)

Generating all permutations of 2n elements takes (2n)! time

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store current permutation and recursion stack

⚠ Quadratic Space

25.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force - Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler