浮点二分，很难吗？

(a1 + a2 + a3 + a4 + ... + an) / n = avg
(a1 + a2 + a3 + a4 + ... + an) = avg * n
(a1 - avg) + (a2 - avg) + ... + (an - avg) = 0

如果 (a1 - avg) + (a2 - avg) + ... + (an - avg) > 0，说明当前选的 avg 是小于实际的平均值的
如果 (a1 - avg) + (a2 - avg) + ... + (an - avg) < 0，说明当前选的 avg 是大于实际的平均值的

class Solution {
    public double findMaxAverage(int[] nums, int k) {
        if (nums == null || nums.length < k) {
            return 0;
        }

        // 遍历找到平均值的范围，最大值就是数组中最大的元素，最小值就是数组中最小的元素
        int minValue = Integer.MAX_VALUE, maxValue = Integer.MIN_VALUE;
        for (int i : nums) {
            minValue = Math.min(i, minValue);
            maxValue = Math.max(i, maxValue);
        }

        // errorRate 表示的是误差值，由于最后的答案是浮点数，没有办法精确到一个固定的值
        // 但我们可以把答案控制在一定的误差范围内，这里设定的是 10^(-5)
        // 如果当前二分中点和上一次二分中点的差别小于 10^(-5)，说明可二分的区间很小，我们已经极度逼近答案，此时退出循环
        double errorRate = Integer.MAX_VALUE;
        double l = minValue, r = maxValue;
        double result = minValue;
        while (errorRate >= 1e-5) {
            double mid = (l + r) / 2.0;
            
            // 看看数组中是否有符合条件的子数组的值大于或等于此时的二分中点
            // 如果有，说明答案大于或等于此时的中点，移动头指针，缩小二分范围
            // 如果没有，说明答案小于此时的中点，移动尾指针，缩小二分范围
            if (haveSolutionOrNot(nums, mid, k)) {
                l = mid;
            } else {
                r = mid;
            }

            // 计算此时的误差值
            errorRate = Math.abs(result - mid);
            result = mid;
        }

        return result;
    }

    private boolean haveSolutionOrNot(int[] nums, double mid, int k) {
        double sum = 0.0;
        for (int i = 0; i < k; ++i) {
            sum += nums[i] - mid;
        }

        if (sum >= 0.0) {
            return true;
        }

        double prevSum = 0.0, minSum = 0.0;
        for (int i = k; i < nums.length; ++i) {
            sum += nums[i] - mid;

            prevSum += nums[i - k] - mid;

            minSum = Math.min(minSum, prevSum);
            if (sum >= minSum) {
                return true;
            }
        }

        return false;
    }

}