Random Flip Matrix

Random Flip Matrix - Problem

You are given an m x n binary grid matrix with all values initially set to 0. Design an algorithm to randomly pick an index (i, j) where matrix[i][j] == 0 and flip it to 1.

All indices (i, j) where matrix[i][j] == 0 should be equally likely to be returned. Optimize your algorithm to minimize the number of calls to the built-in random function and optimize time and space complexity.

Implement the Solution class:

Solution(int m, int n) - Initializes the object with the size of the binary matrix m and n
int[] flip() - Returns a random index [i, j] where matrix[i][j] == 0 and flips it to 1
void reset() - Resets all values of the matrix to 0

Input & Output

Example 1 — Basic 2x3 Matrix

$ Input: m = 2, n = 3

› Output: [0,1] (or any valid position)

💡 Note: Initialize 2×3 matrix with all 0s. First flip() call can return any position like [0,1], which gets flipped to 1. Matrix becomes [[0,1,0],[0,0,0]].

Example 2 — Small 1x2 Matrix

$ Input: m = 1, n = 2

› Output: [0,0] or [0,1]

💡 Note: With only 2 positions available, first flip returns either [0,0] or [0,1] with equal probability. Second flip would return the remaining position.

Example 3 — Single Cell Matrix

$ Input: m = 1, n = 1

› Output: [0,0]

💡 Note: Only one position [0,0] available. First flip() must return [0,0]. Any subsequent flip() calls would have no valid positions (in practice, problem guarantees valid calls).

Constraints

1 ≤ m, n ≤ 10⁴
At most 1000 calls will be made to flip and reset
It is guaranteed that there will be at least one free cell for each call to flip

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is using Fisher-Yates shuffle technique to efficiently select random positions without gaps. Instead of maintaining a full matrix or list, we use a hash map to track swapped indices. Optimal approach uses hash map with 1D index mapping for O(1) flip operation. Time: O(1), Space: O(k) where k is flipped cells.

Common Approaches

✓ Brute Force - Keep Trying Random Positions

⏱️ Time: O(1) to O(∞) Space: O(1)

Generate random (i,j) coordinates and check if that cell is 0. If yes, flip it and return. If no, try again until we find a valid cell.

Fisher-Yates Shuffle with Hash Map

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

Convert 2D coordinates to 1D indices. Use Fisher-Yates shuffle technique: when we pick index i, swap it with the last available index. Use hash map to track swapped positions efficiently.

Hash Map - Track Available Positions

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

Keep a set/list of all coordinates that are currently 0. When flip() is called, randomly select one position from this set, remove it, and return it.

Brute Force - Keep Trying Random Positions — Algorithm Steps

Generate random row i and column j
Check if matrix[i][j] == 0
If yes, flip to 1 and return [i,j]
If no, repeat until valid position found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Random Position

Pick random i,j coordinates

Check If Available

See if matrix[i][j] == 0

Flip or Retry

If available, flip to 1 and return; otherwise try again

Code -

solution.c — C

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

#define MAX_SIZE 100000

typedef struct {
    int row, col;
} Position;

typedef struct {
    int m, n;
    Position available[MAX_SIZE];
    int availableCount;
} Solution;

Solution* createSolution(int m, int n) {
    Solution* sol = (Solution*)malloc(sizeof(Solution));
    sol->m = m;
    sol->n = n;
    sol->availableCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            sol->available[sol->availableCount].row = i;
            sol->available[sol->availableCount].col = j;
            sol->availableCount++;
        }
    }
    
    srand(time(NULL));
    return sol;
}

Position flip(Solution* sol) {
    Position result = {-1, -1};
    if (sol->availableCount == 0) {
        return result;
    }
    
    int idx = rand() % sol->availableCount;
    result = sol->available[idx];
    
    // Remove the selected position by moving last element to idx
    sol->available[idx] = sol->available[sol->availableCount - 1];
    sol->availableCount--;
    
    return result;
}

void reset(Solution* sol) {
    sol->availableCount = 0;
    for (int i = 0; i < sol->m; i++) {
        for (int j = 0; j < sol->n; j++) {
            sol->available[sol->availableCount].row = i;
            sol->available[sol->availableCount].col = j;
            sol->availableCount++;
        }
    }
}

Position solution(int m, int n) {
    Solution* sol = createSolution(m, n);
    Position result = flip(sol);
    free(sol);
    return result;
}

int main() {
    int m, n;
    scanf("%d", &m);
    scanf("%d", &n);
    Position result = solution(m, n);
    printf("[%d,%d]\n", result.row, result.col);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) to O(∞)

Best case O(1) when matrix is mostly empty, worst case infinite loop when only few cells remain

✓ Linear Growth

Space Complexity

O(1)

Only stores the matrix state, no additional data structures

✓ Linear Space

32.4K Views

Medium Frequency

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

Brute Force - Keep Trying Random Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler