Handshakes That Don't Cross

Handshakes That Don't Cross - Problem

You are given an even number of people numPeople that stand around a circle. Each person must shake hands with exactly one other person, resulting in numPeople / 2 handshakes total.

Return the number of ways these handshakes could occur such that none of the handshakes cross. Since the answer could be very large, return it modulo 10⁹ + 7.

Two handshakes cross if the line segments connecting the pairs of people intersect when drawn inside the circle.

Input & Output

Example 1 — Basic Case

$ Input: numPeople = 4

› Output: 2

💡 Note: Person 0 can shake hands with person 1 (leaving 2,3 as a pair) or with person 3 (leaving 1,2 as a pair). Both arrangements have no crossing handshakes.

Example 2 — Larger Circle

$ Input: numPeople = 6

› Output: 5

💡 Note: With 6 people in a circle, there are 5 different ways to arrange 3 handshakes without any crossings. This corresponds to the 3rd Catalan number.

Example 3 — Minimum Case

$ Input: numPeople = 2

› Output: 1

💡 Note: Only one way exists: the two people shake hands with each other. No crossings possible.

Constraints

2 ≤ numPeople ≤ 1000
numPeople is even

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 F Facebook 8

The key insight is recognizing this as a Catalan number problem. Each valid handshake arrangement corresponds to a way of parenthesizing expressions or building binary trees. Best approach uses the mathematical Catalan formula for O(n) time and O(1) space complexity.

Common Approaches

✓ Set Intersection

⏱️ Time: N/A Space: N/A

Frequency Count

⏱️ Time: N/A Space: N/A

Bottom-up Dynamic Programming

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

Instead of recursion, we build the solution bottom-up by calculating results for smaller problem sizes first. This approach is iterative and typically more efficient than memoization.

Catalan Number Formula

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

This problem is equivalent to finding the nth Catalan number. The Catalan number C(n) can be computed using the formula C(n) = (2n)! / ((n+1)! * n!) or the more efficient recursive relation.

Recursive Brute Force

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

For each person, try pairing them with every other valid person. This creates two independent subproblems that can be solved recursively. However, this approach recalculates the same subproblems multiple times.

Recursive with Memoization

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

Same recursive approach as brute force, but we store the results of each subproblem in a cache. This eliminates redundant calculations and dramatically improves performance.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int** nums, int numsSize, int* numsColSize, int* returnSize) {
    *returnSize = 0;
    if (numsSize == 0) {
        return NULL;
    }
    
    // Use first array as initial result
    int* result = (int*)malloc(1000 * sizeof(int));
    int resultCount = 0;
    
    for (int i = 0; i < numsColSize[0]; i++) {
        result[resultCount++] = nums[0][i];
    }
    
    // For each subsequent array, keep only common elements
    for (int i = 1; i < numsSize; i++) {
        int* newResult = (int*)malloc(1000 * sizeof(int));
        int newCount = 0;
        
        // Check each element in current result
        for (int j = 0; j < resultCount; j++) {
            int found = 0;
            for (int k = 0; k < numsColSize[i]; k++) {
                if (result[j] == nums[i][k]) {
                    found = 1;
                    break;
                }
            }
            if (found) {
                newResult[newCount++] = result[j];
            }
        }
        
        free(result);
        result = newResult;
        resultCount = newCount;
        
        // Early termination
        if (resultCount == 0) {
            break;
        }
    }
    
    // Sort result
    for (int i = 0; i < resultCount - 1; i++) {
        for (int j = i + 1; j < resultCount; j++) {
            if (result[i] > result[j]) {
                int temp = result[i];
                result[i] = result[j];
                result[j] = temp;
            }
        }
    }
    
    *returnSize = resultCount;
    return result;
}

// Input parsing functions
void parseInput(char* line, int*** nums, int* numsSize, int** numsColSize) {
    *numsSize = 0;
    *nums = NULL;
    *numsColSize = NULL;
    
    // Skip whitespace and find first '['
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return;
    ptr++; // skip first '['
    
    // Count arrays first
    char* temp = ptr;
    int arrayCount = 0;
    int depth = 0;
    while (*temp) {
        if (*temp == '[') {
            if (depth == 0) arrayCount++;
            depth++;
        } else if (*temp == ']') {
            depth--;
        }
        temp++;
    }
    
    if (arrayCount == 0) return;
    
    *nums = (int**)malloc(arrayCount * sizeof(int*));
    *numsColSize = (int*)malloc(arrayCount * sizeof(int));
    *numsSize = arrayCount;
    
    int arrIdx = 0;
    while (*ptr && arrIdx < arrayCount) {
        // Find start of array
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // skip '['
        
        // Count numbers in this array
        char* temp = ptr;
        int numCount = 0;
        while (*temp && *temp != ']') {
            if (*temp >= '0' && *temp <= '9') {
                numCount++;
                while (*temp >= '0' && *temp <= '9') temp++;
            } else {
                temp++;
            }
        }
        
        (*nums)[arrIdx] = (int*)malloc(numCount * sizeof(int));
        (*numsColSize)[arrIdx] = numCount;
        
        // Parse numbers
        int numIdx = 0;
        while (*ptr && *ptr != ']' && numIdx < numCount) {
            if (*ptr >= '0' && *ptr <= '9') {
                int num = 0;
                while (*ptr >= '0' && *ptr <= '9') {
                    num = num * 10 + (*ptr - '0');
                    ptr++;
                }
                (*nums)[arrIdx][numIdx++] = num;
            } else {
                ptr++;
            }
        }
        
        // Skip to end of array
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        
        arrIdx++;
    }
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    
    int** nums;
    int numsSize;
    int* numsColSize;
    
    parseInput(line, &nums, &numsSize, &numsColSize);
    
    int returnSize;
    int* result = solution(nums, numsSize, numsColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    if (result) free(result);
    if (nums) {
        for (int i = 0; i < numsSize; i++) {
            if (nums[i]) free(nums[i]);
        }
        free(nums);
    }
    if (numsColSize) free(numsColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.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