Count Collisions of Monkeys on a Polygon - Problem

Math Recursion Medium

There is a regular convex polygon with n vertices. The vertices are labeled from 0 to n - 1 in a clockwise direction, and each vertex has exactly one monkey.

Simultaneously, each monkey moves to a neighboring vertex. A collision happens if at least two monkeys reside on the same vertex after the movement or intersect on an edge.

Return the number of ways the monkeys can move so that at least one collision happens. Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Triangle (n=3)

$ Input: n = 3

› Output: 6

💡 Note: Total ways = 2³ = 8. Non-collision ways = 2 (all clockwise or all counterclockwise). Collision ways = 8 - 2 = 6.

Example 2 — Square (n=4)

$ Input: n = 4

› Output: 14

💡 Note: Total ways = 2⁴ = 16. Non-collision ways = 2. Collision ways = 16 - 2 = 14.

Example 3 — Edge Case (n=1000000000)

$ Input: n = 1000000000

› Output: 49

💡 Note: Using modular arithmetic: 2¹⁰⁰⁰⁰⁰⁰⁰⁰⁰ mod (10⁹+7) = 51, so answer is (51-2) mod (10⁹+7) = 49.

Constraints

1 ≤ n ≤ 10⁹
Answer modulo 10⁹ + 7

Visualization

Tap to expand

Asked in

G Google 25 M Meta 20 a Amazon 15

The key insight is using complementary counting: out of 2^n total movement ways, only 2 avoid collisions (all clockwise or all counterclockwise). Best approach uses mathematical formula 2^n - 2 with fast exponentiation. Time: O(log n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2^n × n) Space: O(n)

For each monkey, try both movement directions (clockwise/counterclockwise). Generate all 2^n combinations and check each for collisions.

Mathematical Formula (Optimal)

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

Total movement ways is 2^n. Only 2 ways avoid collisions: all monkeys move clockwise or all move counterclockwise. Answer is 2^n - 2.

Brute Force Simulation — Algorithm Steps

Generate all 2^n possible movement combinations
For each combination, simulate monkey movements
Check if any collisions occur
Count combinations with at least one collision

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all 2^n movement combinations

Simulate

Move monkeys for each combination

Count Collisions

Check if monkeys occupy same positions

Code -

solution.c — C

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

long long power(long long base, long long exp, long long mod) {
    if (exp == 0) {
        return 1;
    }
    
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

long long solution(long long n) {
    const long long MOD = 1000000007;
    
    if (n == 1) {
        return 0;
    }
    
    // Total ways: each monkey can move clockwise or counterclockwise = 2^n
    long long totalWays = power(2, n, MOD);
    
    // Non-collision ways: all clockwise OR all counterclockwise = 2
    long long nonCollisionWays = 2;
    
    // Ways with at least one collision = total - non_collision
    long long result = (totalWays - nonCollisionWays + MOD) % MOD;
    return result;
}

int main() {
    long long n;
    scanf("%lld", &n);
    long long result = solution(n);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n combinations, each taking O(n) time to check for collisions

⚠ Quadratic Growth

Space Complexity

O(n)

Array to track monkey positions during simulation

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 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

Count Collisions of Monkeys on a Polygon - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler