[leetcode]Super Washing Machines

517. Super Washing Machines

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 representing the number of dresses in each washing machine from left to right on the line, you should find 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. 
Example1 
Input: [1,0,5] 
Output: 3 
Explanation:  
1st move:    1     0 <– 5    =>    1     1     4 
2nd move:    1 <– 1 <– 4    =>    2     1     3 
3rd move:    2     1 <– 3    =>    2     2     2 
Example2 
Input: [0,3,0] 
Output: 2 
Explanation:  
1st move:    0 <– 3     0    =>    1     2     0 
2nd move:    1     2 –> 0    =>    1     1     1 
Example3 
Input: [0,2,0] 
Output: -1 
Explanation:  
It’s impossible to make all the three washing machines have the same number of dresses.  
Note: 
The range of n is [1, 10000]. 
The range of dresses number in a super washing machine is [0, 1e5].

The proof of this algorithm is from here.
Say wash machines are with dresses: a1,a2,a3,...,an.
L[i] denotes number of dresses it needs to pass to its left neighbor.
R[i] denotes number of dresses it needs to pass to its right neighbor.
f[i] denotes number of dresses it needs to pass through machine i, f[i]=L[i]+R[i]

dress count 1 0 7 0 L[i] 0 1 3 0 R[i] 0 0 2 0 f[i] 0 1 5 0

Theorem: The minimum number of moves to even all wash machines M=max(f[i]).
proof:
First we need construct a sequence of M moves that could even all wash machines.

while M > 0:    for each wash machine:        if f[i] < M: do nothing        else:            if R[i] > 0: move one dress to its right            else: move one dress to its left    recompute M based on current configuration

In each loop, M will decrease by one because those with M values wash machines release a dress simultaneously.
if R[i]>0, move one dress to its right, how to ensure that f[i+1]new<M?(how to guarantee M will decrease by one?)

Lemma1: in previous constructing process, M will decrease by one in each loop.
pf:
assume ∃ithatf[i]=L[i]+R[i]=M and R[i]>0.
i th machine will pass one dress to its right.
R[i]>0⟹L[i+1]=0⟹f[i+1]=R[i+1]≤M=L[i]+R[i]
if R[i+1]=M,f[i+1]new=R[i+1]−1=M−1
if R[i+1]<M,f[i+1]new=R[i+1]≤M−1
Thus, f[i+1]new≤M−1
Since in every loop, machines with M decrease by one dress, how to prove there are dresses left to pass?
*Lemma2:if f[i]=M, ai>0
pf by contradiction:
Assume ai=0
f[i]=L[i]+R[i]
if L[i]>0andR[i]>0:
this means both sides lack dress to fill to reach even, this is impossible.
if f[i]=R[i],L[i]=0:
because ai=0, R[i−1]>R[i]⟹f[i−1]=L[i−1]+R[i−1]>f[i]=R[i]=M, contradiction.
if f[i]=L[i],R[i]=0:
because ai=0, L[i+1]>L[i]⟹f[i+1]=L[i+1]+R[i+1]>f[i]=L[i]=M, contradiction.

C++ solution:

int findMinMoves(vector<int>& machines) {    int len = machines.size();    vector<int> sums(len + 1, 0);    for (int i = 1; i <= len; ++i)        sums[i] = sums[i - 1] + machines[i - 1];    if (sums[len] % len) return -1;    int average = sums[len] / len, ans = 0;    for (int i = 0; i < len; ++i)    {        int L = max(average * i - sums[i], 0);        int R = max((len - i - 1) * average - (sums[len] - sums[i + 1]), 0);        ans = max(ans, L + R);    }    return ans;}