Zuma Game

Zuma Game - Problem

You are playing a variation of the game Zuma. In this variation of Zuma, there is a single row of colored balls on a board, where each ball can be colored red 'R', yellow 'Y', blue 'B', green 'G', or white 'W'. You also have several colored balls in your hand.

Your goal is to clear all of the balls from the board. On each turn:

Pick any ball from your hand and insert it in between two balls in the row or on either end of the row.

If there is a group of three or more consecutive balls of the same color, remove the group of balls from the board.

If this removal causes more groups of three or more of the same color to form, then continue removing each group until there are none left.

If there are no more balls on the board, then you win the game.

Repeat this process until you either win or do not have any more balls in your hand.

Given a string board, representing the row of balls on the board, and a string hand, representing the balls in your hand, return the minimum number of balls you have to insert to clear all the balls from the board. If you cannot clear all the balls from the board using the balls in your hand, return -1.

Input & Output

Example 1 — Basic Clear

$ Input: board = "RWWWRR", hand = "RB"

› Output: 2

💡 Note: Insert B at position 1: RBWWWRR → RBWWWRR (no removal). Insert B at position 2: RBBWWWRR → R___WWWRR (BBB removed) → RWWWRR. Insert R at position 3: RWWRRRR → RWW___ (RRR removed) → RWW. Continue to clear remaining.

Example 2 — Impossible Case

$ Input: board = "RWWWRR", hand = "WWBBRR"

› Output: -1

💡 Note: No matter how we insert the balls, we cannot clear all balls from the board with the given hand.

Example 3 — Already Clear

$ Input: board = "", hand = "RWB"

› Output: 0

💡 Note: Board is already empty, so no moves needed.

Constraints

1 ≤ board.length ≤ 16
0 ≤ hand.length ≤ 5
board and hand consist of characters 'R', 'Y', 'B', 'G', and 'W'
The initial row of balls on the board will not have any groups of three or more consecutive balls of the same color

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 A Apple 6

The key insight is to use BFS with memoization to systematically explore all possible game states level by level, ensuring we find the minimum number of moves. The algorithm tries inserting each ball at each position, removes consecutive groups, and continues until the board is cleared. Best approach is BFS with memoization. Time: O(2^(n+m) × n²), Space: O(2^(n+m))

Common Approaches

✓ BFS with Memoization

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

Use breadth-first search to explore all possible game states level by level, ensuring we find the minimum number of moves. Memoization prevents recomputing the same board-hand combination multiple times.

Brute Force Recursion

⏱️ Time: O(n! × m^n) Space: O(n)

For each ball in hand, try inserting it at every possible position on the board. After insertion, remove consecutive groups of 3+ same colored balls and recursively solve the remaining problem.

BFS with Memoization — Algorithm Steps

Use BFS queue to track (board, hand, moves) states
For each state, try inserting each unique ball at each position
Remove consecutive groups after insertion
Use memoization to avoid duplicate states
Return moves when board becomes empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with board and hand in queue

BFS Expansion

Try all ball insertions at current level

Memoization

Skip already seen board-hand combinations

Find Minimum

Return when board becomes empty

Code -

solution.c — C

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

#define MAX_STATES 100000
#define MAX_LEN 100

typedef struct {
    char board[MAX_LEN];
    char hand[MAX_LEN];
    int moves;
} State;

char* removeConsecutive(char* s) {
    int len = strlen(s);
    if (len == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* stack = malloc(len + 1);
    int* counts = malloc(len * sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < len; i++) {
        if (stackSize > 0 && stack[stackSize - 1] == s[i]) {
            counts[stackSize - 1]++;
        } else {
            stack[stackSize] = s[i];
            counts[stackSize] = 1;
            stackSize++;
        }
    }
    
    char* result = malloc(len + 1);
    int pos = 0;
    for (int i = 0; i < stackSize; i++) {
        if (counts[i] < 3) {
            for (int j = 0; j < counts[i]; j++) {
                result[pos++] = stack[i];
            }
        }
    }
    result[pos] = '\0';
    
    free(stack);
    free(counts);
    
    if (strcmp(result, s) == 0) {
        return result;
    } else {
        char* next = removeConsecutive(result);
        free(result);
        return next;
    }
}

int solution(char* board, char* hand) {
    State queue[MAX_STATES];
    char memo[MAX_STATES][MAX_LEN * 2];
    int memoCount = 0;
    int front = 0, rear = 0;
    
    strcpy(queue[rear].board, board);
    strcpy(queue[rear].hand, hand);
    queue[rear].moves = 0;
    rear++;
    
    while (front < rear) {
        State curr = queue[front++];
        
        if (strlen(curr.board) == 0) {
            return curr.moves;
        }
        
        if (strlen(curr.hand) == 0) {
            continue;
        }
        
        // Simple memoization check
        char state[MAX_LEN * 2];
        sprintf(state, "%s|%s", curr.board, curr.hand);
        
        int found = 0;
        for (int i = 0; i < memoCount; i++) {
            if (strcmp(memo[i], state) == 0) {
                found = 1;
                break;
            }
        }
        
        if (found) continue;
        if (memoCount < MAX_STATES - 1) {
            strcpy(memo[memoCount++], state);
        }
        
        // Try each ball in hand
        int handLen = strlen(curr.hand);
        for (int h = 0; h < handLen; h++) {
            char ball = curr.hand[h];
            
            // Create new hand without this ball
            char newHand[MAX_LEN];
            int pos = 0;
            for (int i = 0; i < handLen; i++) {
                if (i != h) {
                    newHand[pos++] = curr.hand[i];
                }
            }
            newHand[pos] = '\0';
            
            // Try inserting at each position
            int boardLen = strlen(curr.board);
            for (int i = 0; i <= boardLen; i++) {
                char newBoard[MAX_LEN];
                strncpy(newBoard, curr.board, i);
                newBoard[i] = ball;
                strcpy(newBoard + i + 1, curr.board + i);
                
                char* cleanedBoard = removeConsecutive(newBoard);
                
                if (rear < MAX_STATES - 1) {
                    strcpy(queue[rear].board, cleanedBoard);
                    strcpy(queue[rear].hand, newHand);
                    queue[rear].moves = curr.moves + 1;
                    rear++;
                }
                
                free(cleanedBoard);
            }
        }
    }
    
    return -1;
}

int main() {
    char board[MAX_LEN], hand[MAX_LEN];
    fgets(board, sizeof(board), stdin);
    fgets(hand, sizeof(hand), stdin);
    board[strcspn(board, "\n")] = 0;
    hand[strcspn(hand, "\n")] = 0;
    
    printf("%d\n", solution(board, hand));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n+m) × n²)

BFS explores up to 2^(n+m) states, each requiring O(n²) processing for removal

⚠ Quadratic Growth

Space Complexity

O(2^(n+m))

Memoization stores up to 2^(n+m) different board-hand combinations

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

856 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

BFS with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler