Super Washing Machines

Super Washing Machines - Problem

Array Greedy Hard

You have n super washing machines on a line. Initially, each washing machine has some dresses or is empty.

For each move, you could choose any m (1 ≤ m ≤ n) washing machines, and pass one dress of each washing machine to one of its adjacent washing machines at the same time.

Given an integer array machines representing the number of dresses in each washing machine from left to right on the line, return the minimum number of moves to make all the washing machines have the same number of dresses.

If it is not possible to do it, return -1.

Input & Output

Example 1 — Basic Imbalance

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

› Output: 3

💡 Note: Total = 6, target = 2 each. Machine 2 has 3 excess dresses that must be distributed, requiring 3 moves minimum.

Example 2 — Impossible Case

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

› Output: 2

💡 Note: Total = 3, target = 1 each. Middle machine distributes one dress left and right, taking 2 moves total.

Example 3 — Already Balanced

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

› Output: 0

💡 Note: All machines already have equal dresses (2 each), so no moves needed.

Constraints

1 ≤ machines.length ≤ 10⁴
0 ≤ machines[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that we need to track the cumulative flow of dresses and find bottlenecks. The greedy approach calculates the maximum flow required through any position, considering both cumulative imbalance and local outflow requirements. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(k^n) Space: O(k^n)

Try all possible combinations of simultaneous moves at each step, exploring the state space until we find the minimum moves needed to balance all machines.

Greedy Flow Analysis

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

Analyze the flow of dresses needed through each position. The key insight is that we need to track cumulative imbalance and find the maximum flow required at any position.

Brute Force Simulation — Algorithm Steps

Check if total dresses can be evenly distributed
Use BFS to explore all possible simultaneous move combinations
Track minimum moves to reach balanced state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with given machine configuration

Generate Moves

Try all possible simultaneous dress transfers between adjacent machines

Find Solution

Return minimum moves when all machines have equal dresses

Code -

solution.c — C

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

int targetVal;
int foundResult;
int visitedCount;

/* Simple hash set for visited states using string keys */
#define MAX_VISITED 50000
char* visitedKeys[MAX_VISITED];

int isVisited(int* state, int n) {
    char key[256] = "";
    char tmp[16];
    for (int i = 0; i < n; i++) {
        sprintf(tmp, "%d,", state[i]);
        strcat(key, tmp);
    }
    for (int i = 0; i < visitedCount; i++) {
        if (strcmp(visitedKeys[i], key) == 0) return 1;
    }
    if (visitedCount < MAX_VISITED) {
        visitedKeys[visitedCount] = strdup(key);
        visitedCount++;
    }
    return 0;
}

/* BFS queue */
#define MAX_QUEUE 50000
int queueStates[MAX_QUEUE][10];
int queueMoves[MAX_QUEUE];
int queueN[MAX_QUEUE];
int qHead = 0, qTail = 0;

void enqueue(int* state, int n, int moves) {
    if (qTail >= MAX_QUEUE) return;
    for (int i = 0; i < n; i++) queueStates[qTail][i] = state[i];
    queueN[qTail] = n;
    queueMoves[qTail] = moves;
    qTail++;
}

int abs_val(int x) { return x < 0 ? -x : x; }
int max_val(int a, int b) { return a > b ? a : b; }

void generate(int* state, int* options_count, int options[][3], int* combo, 
              int idx, int n, int moves) {
    if (foundResult != -1) return;
    if (idx == n) {
        int allZero = 1;
        for (int i = 0; i < n; i++) if (combo[i] != 0) { allZero = 0; break; }
        if (allZero) return;
        
        int newState[10];
        for (int i = 0; i < n; i++) newState[i] = state[i];
        for (int i = 0; i < n; i++) {
            if (combo[i] == -1) {
                newState[i]--;
                newState[i-1]++;
            } else if (combo[i] == 1) {
                newState[i]--;
                newState[i+1]++;
            }
        }
        for (int i = 0; i < n; i++) if (newState[i] < 0) return;
        
        if (!isVisited(newState, n)) {
            int balanced = 1;
            for (int i = 0; i < n; i++) if (newState[i] != targetVal) { balanced = 0; break; }
            if (balanced) { foundResult = moves + 1; return; }
            enqueue(newState, n, moves + 1);
        }
        return;
    }
    for (int a = 0; a < options_count[idx]; a++) {
        combo[idx] = options[idx][a];
        generate(state, options_count, options, combo, idx + 1, n, moves);
        if (foundResult != -1) return;
    }
}

int solution(int* machines, int n) {
    long long total = 0;
    for (int i = 0; i < n; i++) total += machines[i];
    
    if (total % n != 0) return -1;
    
    targetVal = total / n;
    int balanced = 1;
    for (int i = 0; i < n; i++) if (machines[i] != targetVal) { balanced = 0; break; }
    if (balanced) return 0;
    
    /* Reset globals */
    visitedCount = 0;
    qHead = 0;
    qTail = 0;
    foundResult = -1;
    
    isVisited(machines, n);  /* mark initial as visited */
    enqueue(machines, n, 0);
    
    while (qHead < qTail && foundResult == -1) {
        int state[10];
        int moves = queueMoves[qHead];
        int nn = queueN[qHead];
        for (int i = 0; i < nn; i++) state[i] = queueStates[qHead][i];
        qHead++;
        
        if (moves > 50) break;
        
        int options[10][3];
        int options_count[10];
        for (int i = 0; i < n; i++) {
            options_count[i] = 1;
            options[i][0] = 0;
            if (state[i] > 0) {
                if (i > 0) { options[i][options_count[i]++] = -1; }
                if (i < n - 1) { options[i][options_count[i]++] = 1; }
            }
        }
        
        int combo[10] = {0};
        generate(state, options_count, options, combo, 0, n, moves);
    }
    
    /* Free visited keys */
    for (int i = 0; i < visitedCount; i++) free(visitedKeys[i]);
    
    return foundResult;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int machines[1000];
    int n = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",] \t\n\r");
        while (token && n < 1000) {
            machines[n++] = atoi(token);
            token = strtok(NULL, ",] \t\n\r");
        }
    }
    
    int result = solution(machines, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Exponential state space where k is average dresses and n is machines

✓ Linear Growth

Space Complexity

O(k^n)

Need to store all possible states in queue/stack

✓ Linear Space

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