LeetCode 1052. Grumpy Bookstore Owner

输入：customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3

输出：16

解释：

书店老板可以保持 3 分钟的平静。

原本老板不暴躁的时候，即 grumpy[i] = 0 时，顾客总数为: 1 + 1 + 1 + 7 = 10。
而连续 3 分钟内，老板暴躁时，对应的顾客总数最大为: 1 + 5 = 6。

因此，最大人数为：10 + 6 = 16。

被满足的最大顾客总数 = 不暴躁时的顾客总数 + X 分钟内暴躁时的最大顾客总数。

/**
 * @param {number[]} customers
 * @param {number[]} grumpy
 * @param {number} X
 * @return {number}
 */
var maxSatisfied = function (customers, grumpy, X) {
    if (customers && grumpy) {
        let i = 0
        // x 分钟内暴躁时的顾客总数
        let xSum = 0
        // x 分钟内暴躁时最大的顾客总数
        let maxXSum = 0
        // 记录 grumpy = 0 时，客户的总数
        let sum = 0
        // 首先计算出前 X 个数中 grumpy = 1，对应的客户总数
        while (i < X) {
            if (grumpy[i] === 1) {
                xSum += customers[i]
            } else {
                sum += customers[i]
            }
            i += 1
        }
        // maxXSum 初始值
        maxXSum = xSum
        while (i < customers.length) {
            // 计算不暴躁时的数量
            if (grumpy[i] === 0) {
                sum += customers[i]
            }
            const lastIndex = i - X
            // 如果不暴躁，则为 0，因为不暴躁有额外的记录。暴躁则为对应的顾客数。
            let num = grumpy[i] === 0 ? 0 : customers[i]
            let lastNum = grumpy[lastIndex] === 0 ? 0 : customers[lastIndex]
            // 计算增量
            xSum += num - lastNum
            if (maxXSum < xSum) {
                maxXSum = xSum
            }
            i += 1
        }
        return sum + maxXSum
    }
    return 0
};

public int maxSatisfied(int[] customers, int[] grumpy, int X) {
	// 不暴躁总数
    int satisfied = 0;
	
	// 暴躁最大总数
    int maxMakeSatisfied = 0;
    
    // winOfMakeSatisfied 为 x 分钟内的暴躁总数
    for (int i = 0, winOfMakeSatisfied = 0; i < grumpy.length; ++i) {
        if (grumpy[i] == 0) { satisfied += customers[i]; }
        else { winOfMakeSatisfied += customers[i]; }
        if (i >= X) {
	        // 减去差量，更新暴躁时的总量
            winOfMakeSatisfied -= grumpy[i - X] * customers[i - X];
        }
        maxMakeSatisfied = Math.max(winOfMakeSatisfied, maxMakeSatisfied);
    }
    return satisfied + maxMakeSatisfied;        
}