Random Flip Matrix - Practice Coding Problems

Random Flip Matrix - Problem

Random Flip Matrix is a fascinating system design problem that combines randomization, space optimization, and efficient data structures.

You start with an m × n binary matrix filled entirely with zeros. Your task is to design a smart data structure that can:

🎯 Randomly flip zeros to ones: Pick any cell containing 0, flip it to 1, and return its coordinates [i, j]. Every zero cell must have an equal probability of being selected.

🔄 Reset the matrix: Set all cells back to 0, making them available for flipping again.

The Challenge: Optimize for both time and space complexity while minimizing calls to the random number generator. As cells get flipped, the available positions shrink - how do you maintain uniform randomness efficiently?

Example: With a 3×2 matrix, initially all 6 positions are available. After flipping [1,0], only 5 positions remain, and each should have a 1/5 probability of being chosen next.

Input & Output

example_1.py — Basic Usage

$ Input: solution = Solution(3, 1) solution.flip() # return [1, 0] solution.flip() # return [0, 0] or [2, 0] solution.flip() # return remaining cell solution.reset() # all cells become 0 again

› Output: [[1, 0], [0, 0], [2, 0]] [reset completed]

💡 Note: A 3×1 matrix has cells [0,0], [1,0], [2,0]. Each flip returns one of the remaining available cells with equal probability. After reset, all cells become available again.

example_2.py — Small Matrix

$ Input: solution = Solution(2, 2) solution.flip() # return [0, 1] (example) solution.flip() # return [1, 0] (example) solution.reset() solution.flip() # could return any cell again

› Output: [[0, 1], [1, 0]] [reset completed] [[1, 1]]

💡 Note: In a 2×2 matrix, there are 4 possible positions. Each flip randomly selects from remaining available positions. Reset makes all positions available again.

example_3.py — Edge Case

$ Input: solution = Solution(1, 2) solution.flip() # return [0, 0] or [0, 1] solution.flip() # return the other cell solution.reset() # reset to all zeros

› Output: [[0, 0], [0, 1]] [reset completed]

💡 Note: Minimal case with just 2 cells. First flip has 50% chance for each cell, second flip returns the remaining cell with 100% probability.

Visualization

Tap to expand

O(1) Time: Each flip uses one random call + constant hash operations• O(k) Space: Hash map only stores k swapped positions out of m×n total• Perfect Distribution: Every remaining position has equal 1/(remaining) probability• No Gaps: Available positions always occupy indices [0, total-1] logically

Understanding the Visualization

Matrix as Array

Treat the 2D matrix as a 1D array of indices [0, 1, 2, ..., m*n-1]

Random Selection

Pick a random index from [0, total-1] where total is count of available positions

Smart Swap

Swap selected position with last available position using hash map

Shrink Range

Decrease total count, effectively removing last position from consideration

Key Takeaway

🎯 Key Insight: By treating the matrix as a 1D array and using Fisher-Yates shuffle with hash map optimization, we achieve O(1) time per flip while maintaining perfect randomness and using minimal space.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each flip operation is constant time with hash map lookup and swap

✓ Linear Growth

Space Complexity

O(k)

Where k is number of flipped cells, storing only moved positions in hash map

✓ Linear Space

Constraints

1 ≤ m, n ≤ 10⁴
There will be at least one cell with value 0 when flip is called
At most 1000 calls will be made to flip and reset combined

Asked in

G Google 42 f Facebook 28 a Amazon 31 ⊞ Microsoft 19

The optimal solution uses a Fisher-Yates shuffle approach with a hash map to achieve O(1) flip operations. Instead of maintaining all available positions, it treats the matrix as a 1D array and uses the swap-with-last technique. When a position is selected, it's swapped with the last available position using the hash map, maintaining uniform probability distribution while using only O(k) space where k is the number of flipped cells.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Random Search	O(m*n) per flip in worst case	O(m*n)	Keep generating random coordinates until finding an unflipped cell
Hash Map with Random Index (Optimal)	O(1)	O(k)	Use Fisher-Yates shuffle technique with hash map for O(1) flip and space optimization

Naive Random Search — Algorithm Steps

Initialize an m×n matrix filled with zeros
For flip(): generate random (i,j) until matrix[i][j] == 0
Set matrix[i][j] = 1 and return [i,j]
For reset(): set all cells back to 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

3×3 matrix with all zeros, 9 available positions

First Flip Success

Random (1,1) hits available cell immediately

Later Attempts

With only 2 cells left, may try (1,1) multiple times

Inefficient Search

Wastes random calls on already-flipped positions

Code -

solution.c — C

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

typedef struct {
    int m, n;
    int** matrix;
} Solution;

Solution* solutionCreate(int m, int n) {
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    obj->m = m;
    obj->n = n;
    obj->matrix = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        obj->matrix[i] = (int*)calloc(n, sizeof(int));
    }
    srand(time(NULL));
    return obj;
}

int* solutionFlip(Solution* obj, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    while (1) {
        int i = rand() % obj->m;
        int j = rand() % obj->n;
        if (obj->matrix[i][j] == 0) {
            obj->matrix[i][j] = 1;
            result[0] = i;
            result[1] = j;
            return result;
        }
    }
}

void solutionReset(Solution* obj) {
    for (int i = 0; i < obj->m; i++) {
        for (int j = 0; j < obj->n; j++) {
            obj->matrix[i][j] = 0;
        }
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n) per flip in worst case

May need to try all positions when only one cell remains unflipped

✓ Linear Growth

Space Complexity

O(m*n)

Stores the entire matrix explicitly

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 10⁴
There will be at least one cell with value 0 when flip is called
At most 1000 calls will be made to flip and reset combined

78.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Naive Random Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler