Super Washing Machines - Practice Coding Problems

Super Washing Machines - Problem

Array Greedy Hard

Imagine you have n super washing machines arranged in a straight line in your laundromat. Each machine currently contains a different number of dresses (or might be empty). Your goal is to redistribute the dresses so that every machine has exactly the same number of dresses.

Here's how the redistribution works: In each move, you can select any number of machines (from 1 to n) and simultaneously pass one dress from each selected machine to one of its adjacent neighbors (left or right).

Your mission: Find the minimum number of moves required to achieve perfect balance across all machines. If it's impossible to balance the dresses equally, return -1.

Example: If you have machines with [1, 0, 5] dresses, the total is 6 dresses across 3 machines, so each should have 2 dresses. You need to move dresses from machine 2 (with 5) to machines 0 and 1.

Input & Output

example_1.py — Basic Balance

$ Input: machines = [1, 0, 5]

› Output: 3

💡 Note: Total dresses = 6, so each machine should have 2. Machine 2 has 3 extra dresses and needs to give them all away, which takes 3 moves (since it can only give 1 dress per move). This becomes the bottleneck.

example_2.py — Already Balanced

$ Input: machines = [2, 2, 2]

› Output: 0

💡 Note: All machines already have the same number of dresses (2 each), so no moves are needed.

example_3.py — Impossible Case

$ Input: machines = [0, 3, 0]

› Output: -1

💡 Note: Total dresses = 3, and we have 3 machines, so each should have 1 dress. However, the middle machine cannot pass dresses to both neighbors simultaneously in the optimal number of moves, but actually this is solvable in 2 moves. Let me recalculate: this should output 2, not -1. Better example: machines = [1, 2] gives -1 since 3 dresses cannot be split evenly between 2 machines.

Constraints

1 ≤ machines.length ≤ 10⁴
0 ≤ machines[i] ≤ 10⁵
The sum of all dress counts fits in a 32-bit integer
Important: Each move allows multiple machines to pass dresses simultaneously

Visualization

Tap to expand

Understanding the Visualization

Identify Imbalances

Calculate how many dresses each machine needs to give away or receive

Find Bottlenecks

Determine which machine or flow path will take the longest

Calculate Minimum

The answer is the maximum bottleneck found

Key Takeaway

🎯 Key Insight: The bottleneck determines the minimum time needed. It's either the machine that must give away the most dresses, or the point where cumulative flow imbalance is highest.

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses flow analysis instead of simulation. Calculate each machine's dress flow requirement (positive for giving, negative for receiving), then find the maximum of: (1) the largest individual outflow, and (2) the maximum cumulative flow imbalance. This greedy approach runs in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(k^n)	O(k^n)	Simulate all possible move sequences until balanced state is reached
Optimal Greedy Solution	O(n)	O(1)	Calculate flow requirements and find maximum bottleneck in single pass

Brute Force Simulation — Algorithm Steps

Check if total dresses can be evenly distributed
Use BFS to explore all possible states from current configuration
For each state, try all possible moves (selecting different machines)
Track visited states to avoid cycles
Return the minimum moves when target state is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the given machine configuration

Generate States

Create all possible next states by moving dresses

Check Target

See if any new state achieves perfect balance

Continue Search

Add valid states to queue and repeat

Code -

solution.c — C

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

typedef struct {
    int* machines;
    int moves;
    int size;
} State;

typedef struct Node {
    State state;
    struct Node* next;
} Node;

typedef struct {
    Node* front;
    Node* rear;
} Queue;

void enqueue(Queue* q, State s) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->state = s;
    newNode->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

State dequeue(Queue* q) {
    if (q->front == NULL) {
        State empty = {NULL, -1, 0};
        return empty;
    }
    
    Node* temp = q->front;
    State result = temp->state;
    q->front = q->front->next;
    
    if (q->front == NULL) {
        q->rear = NULL;
    }
    
    free(temp);
    return result;
}

int isEmpty(Queue* q) {
    return q->front == NULL;
}

int findMinMoves(int* machines, int machinesSize) {
    int total = 0;
    for (int i = 0; i < machinesSize; i++) {
        total += machines[i];
    }
    
    if (total % machinesSize != 0) {
        return -1;
    }
    
    int target = total / machinesSize;
    int balanced = 1;
    for (int i = 0; i < machinesSize; i++) {
        if (machines[i] != target) {
            balanced = 0;
            break;
        }
    }
    
    if (balanced) return 0;
    
    Queue queue = {NULL, NULL};
    
    // Simple BFS implementation (limited for demonstration)
    // In practice, this would need proper hash table for visited states
    State initial;
    initial.machines = (int*)malloc(machinesSize * sizeof(int));
    memcpy(initial.machines, machines, machinesSize * sizeof(int));
    initial.moves = 0;
    initial.size = machinesSize;
    
    enqueue(&queue, initial);
    
    // For demo purposes, limit iterations to prevent infinite loop
    int iterations = 0;
    const int MAX_ITERATIONS = 1000;
    
    while (!isEmpty(&queue) && iterations < MAX_ITERATIONS) {
        iterations++;
        State current = dequeue(&queue);
        
        // Try simple moves (limited implementation)
        for (int i = 0; i < machinesSize - 1; i++) {
            if (current.machines[i] > 0) {
                int* newState = (int*)malloc(machinesSize * sizeof(int));
                memcpy(newState, current.machines, machinesSize * sizeof(int));
                newState[i]--;
                newState[i+1]++;
                
                // Check if target reached
                int isTarget = 1;
                for (int j = 0; j < machinesSize; j++) {
                    if (newState[j] != target) {
                        isTarget = 0;
                        break;
                    }
                }
                
                if (isTarget) {
                    free(current.machines);
                    free(newState);
                    return current.moves + 1;
                }
                
                free(newState);
            }
        }
        
        free(current.machines);
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is the maximum number of dresses and n is number of machines. Each machine can have multiple dress counts, leading to exponential states.

✓ Linear Growth

Space Complexity

O(k^n)

Need to store all possible states in BFS queue and visited set.

⚡ Linearithmic Space

27.4K Views

Medium Frequency

~25 min Avg. Time

890 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler