Matchsticks to Square

Matchsticks to Square - Problem

You are given an integer array matchsticks where matchsticks[i] is the length of the i^th matchstick.

You want to use all the matchsticks to make one square. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.

Return true if you can make this square and false otherwise.

Input & Output

Example 1 — Perfect Square

$ Input: matchsticks = [1,1,2,2,2]

› Output: true

💡 Note: Total length is 8, so each side needs length 2. We can group as: Side 1: [2], Side 2: [2], Side 3: [2], Side 4: [1,1]. All sides have length 2.

Example 2 — Impossible Square

$ Input: matchsticks = [3,3,3,3,4]

› Output: false

💡 Note: Total length is 16, so each side needs length 4. But we have three matchsticks of length 3, and 3 < 4, so we can't form sides of length 4 with these.

Example 3 — Single Large Stick

$ Input: matchsticks = [5,5,5,5,4,4,4,4,4,4]

› Output: false

💡 Note: Total is 44, not divisible by 4. Cannot form a square when total length is not divisible by 4.

Constraints

1 ≤ matchsticks.length ≤ 15
1 ≤ matchsticks[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 M Microsoft 6

The key insight is that we need to partition matchsticks into 4 groups with equal sums (total ÷ 4). Best approach uses optimized backtracking with sorting and pruning. Time: O(4ⁿ), Space: O(n).

Common Approaches

✓ Brute Force Backtracking

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

For each matchstick, try placing it on each of the 4 sides of the square. Use recursion to explore all possibilities and backtrack when a path doesn't work.

Dynamic Programming with Bitmask

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

Represent which matchsticks are used with a bitmask, and use memoization to store results for each state combination.

Optimized Backtracking

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

Sort matchsticks in descending order and add several pruning optimizations to eliminate redundant states and fail faster.

Brute Force Backtracking — Algorithm Steps

Step 1: Calculate target side length (sum ÷ 4)
Step 2: For each matchstick, try adding it to each of the 4 sides
Step 3: Recursively continue until all matchsticks are placed or impossible
Step 4: Backtrack if current assignment exceeds target length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 4 sides, calculate target length

Backtrack

For each matchstick, try placing on each side

Check

Verify all sides equal target length

Code -

solution.c — C

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

bool backtrack(int* matchsticks, int size, int* sides, int index, int target) {
    if (index == size) {
        return sides[0] == target && sides[1] == target && sides[2] == target && sides[3] == target;
    }
    
    for (int i = 0; i < 4; i++) {
        if (sides[i] + matchsticks[index] <= target) {
            sides[i] += matchsticks[index];
            if (backtrack(matchsticks, size, sides, index + 1, target)) {
                return true;
            }
            sides[i] -= matchsticks[index];
        }
    }
    
    return false;
}

bool solution(int* matchsticks, int size) {
    int total = 0;
    for (int i = 0; i < size; i++) {
        total += matchsticks[i];
    }
    if (total % 4 != 0) return false;
    
    int target = total / 4;
    int sides[4] = {0};
    
    return backtrack(matchsticks, size, sides, 0, target);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int matchsticks[20];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL && size < 20) {
        matchsticks[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(matchsticks, size);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4ⁿ)

For each of n matchsticks, we try 4 sides, leading to 4^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of matchsticks

⚡ Linearithmic Space

128.0K Views

Medium Frequency

~25 min Avg. Time

2.2K 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler