Minimum Domino Rotations For Equal Row - Practice Coding Problems

Minimum Domino Rotations For Equal Row - Problem

Array Greedy Medium

Imagine you have a row of dominoes, where each domino has two numbers (from 1 to 6) - one on top and one on bottom. You can rotate any domino to swap its top and bottom values.

Given two arrays tops[] and bottoms[] representing the top and bottom halves of each domino, find the minimum number of rotations needed to make either:

All values in the tops array the same, OR
All values in the bottoms array the same

If it's impossible to achieve either goal, return -1.

Example: If you have dominoes [2,1], [2,3], [1,3], you could rotate the third domino to get tops=[2,2,3] and bottoms=[1,3,1], then rotate the third again to get all 2s on top with just 1 rotation total.

Input & Output

basic_case.py — Python

$ Input: tops = [2,1,2,4,2,2], bottoms = [5,2,6,2,3,2]

› Output: 2

💡 Note: We can make all values in tops equal to 2 with 2 rotations: rotate positions 1 and 4 to bring 2 from bottom to top.

impossible_case.py — Python

$ Input: tops = [3,5,1,2,3], bottoms = [3,6,3,3,4]

› Output: -1

💡 Note: No matter how we rotate, we cannot make all values in tops or bottoms the same. For example, position 1 has [5,6] and position 3 has [2,3], so they share no common value.

no_rotation_needed.py — Python

$ Input: tops = [1,1,1,1], bottoms = [2,2,2,2]

› Output: 0

💡 Note: All values in tops are already the same (all 1s), so no rotations are needed.

Constraints

2 ≤ tops.length ≤ 2 × 10⁴
bottoms.length == tops.length
1 ≤ tops[i], bottoms[i] ≤ 6
Each domino has exactly two values (top and bottom)

Visualization

Tap to expand

Understanding the Visualization

Identify Possibilities

Only the values visible on the first card can possibly appear on all cards

Check Each Candidate

For each candidate, count how many cards need flipping to show that value

Choose Optimal

Pick the candidate requiring minimum flips, or return -1 if impossible

Key Takeaway

🎯 Key Insight: Only values present in the first domino can possibly work for the entire row, reducing our search space from exponential to constant time.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a greedy strategy with the key insight that only values from the first domino can possibly work for all positions. We check at most 2 candidates in a single O(n) pass, making this much more efficient than the brute force O(2^n) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Single Pass (Optimal)	O(n)	O(1)	Check only the two candidates from first domino in a single pass
Try All Possible Rotations	O(n × 2^n)	O(n)	Generate all 2^n possible rotation combinations and check each one

Greedy Single Pass (Optimal) — Algorithm Steps

Identify two candidates: tops[0] and bottoms[0]
For each candidate, traverse the array once
At each position, check if candidate can be achieved (exists on top or bottom)
Count rotations needed to move candidate to desired position
Return minimum rotations between the two candidates, or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Candidates

Only tops[0] and bottoms[0] can possibly work for all positions

Check First Candidate

Count rotations needed to make tops[0] appear everywhere

Check Second Candidate

Count rotations needed to make bottoms[0] appear everywhere

Return Minimum

Return the minimum rotations between valid candidates

Code -

solution.c — C

int check(int target, int* tops, int* bottoms, int n) {
    int rotationsTop = 0, rotationsBottom = 0;
    
    for (int i = 0; i < n; i++) {
        if (tops[i] != target && bottoms[i] != target) {
            return -1;
        } else if (tops[i] != target) {
            rotationsTop++;
        } else if (bottoms[i] != target) {
            rotationsBottom++;
        }
    }
    
    return rotationsTop < rotationsBottom ? rotationsTop : rotationsBottom;
}

int minDominoRotations(int* tops, int topsSize, int* bottoms, int bottomsSize) {
    int result1 = check(tops[0], tops, bottoms, topsSize);
    int result2 = check(bottoms[0], tops, bottoms, topsSize);
    
    if (result1 == -1) return result2;
    if (result2 == -1) return result1;
    return result1 < result2 ? result1 : result2;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to check each of the 2 candidates

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

67.4K Views

Medium-High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Greedy Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler