[二分查找]

1712. 将数组分成三个子数组的方案数
      我们称一个分割整数数组的方案是 好的 ，当它满足：

数组被分成三个 非空 连续子数组，从左至右分别命名为 left ， mid ， right 。
left 中元素和小于等于 mid 中元素和，mid 中元素和小于等于 right 中元素和。
给你一个 非负 整数数组 nums ，请你返回 好的 分割 nums 方案数目。由于答案可能会很大，请你将结果对 109 + 7 取余后返回。

示例 1：

输入：nums = [1,1,1]
输出：1
解释：唯一一种好的分割方案是将 nums 分成 [1] [1] [1] 。
示例 2：

输入：nums = [1,2,2,2,5,0]
输出：3
解释：nums 总共有 3 种好的分割方案：
[1] [2] [2,2,5,0]
[1] [2,2] [2,5,0]
[1,2] [2,2] [5,0]

// right >= 2 * left,  right <= (total+ left) / 2
class Solution {
    public int waysToSplit(int[] nums) {
        int[] preSum = new int[nums.length];
        preSum[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            preSum[i] = preSum[i - 1] + nums[i]; 
        }
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            int start = findStart(nums, i, i + 1, nums.length - 2, preSum);
            int end = findEnd(nums, i, i + 1, nums.length - 2, preSum);
            if (start <= end && start != -1 && end != -1) {
                res += end - start + 1;
                res %= 1000000007;
            }
        }
        return res;
}

    public int findStart(int nums[], int left, int low, int high, int preSum[]) {
        int ans = -1;
        // 第一个大于等于target的位置
        while(low <= high) {
            int mid = low + (high - low) / 2;
            if (preSum[left] <= preSum[mid] - preSum[left]) {
                ans = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return ans;
    }

    public int findEnd(int nums[], int left, int low, int high, int preSum[]) {
        int ans = -1;
        // 最后一个小于等于target的位置
        while(low <= high) {
            int mid = low + (high - low) / 2;
            if (preSum[mid] - preSum[left] <= preSum[nums.length - 1] - preSum[mid]) {
                ans = mid;
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2064. 分配给商店的最多商品的最小值
      给你一个整数 n ，表示有 n 间零售商店。总共有 m 种产品，每种产品的数目用一个下标从 0 开始的整数数组 quantities 表示，其中 quantities[i] 表示第 i 种商品的数目。

你需要将 所有商品 分配到零售商店，并遵守这些规则：

一间商店 至多 只能有 一种商品 ，但一间商店拥有的商品数目可以为 任意 件。
分配后，每间商店都会被分配一定数目的商品（可能为 0 件）。用 x 表示所有商店中分配商品数目的最大值，你希望 x 越小越好。也就是说，你想 最小化 分配给任意商店商品数目的 最大值 。
请你返回最小的可能的 x 。

示例 1：

输入：n = 6, quantities = [11,6]
输出：3
解释： 一种最优方案为：

• 11 件种类为 0 的商品被分配到前 4 间商店，分配数目分别为：2，3，3，3 。
• 6 件种类为 1 的商品被分配到另外 2 间商店，分配数目分别为：3，3 。
  分配给所有商店的最大商品数目为 max(2, 3, 3, 3, 3, 3) = 3 。
  示例 2：

输入：n = 7, quantities = [15,10,10]
输出：5
解释：一种最优方案为：

• 15 件种类为 0 的商品被分配到前 3 间商店，分配数目为：5，5，5 。
• 10 件种类为 1 的商品被分配到接下来 2 间商店，数目为：5，5 。
• 10 件种类为 2 的商品被分配到最后 2 间商店，数目为：5，5 。
  分配给所有商店的最大商品数目为 max(5, 5, 5, 5, 5, 5, 5) = 5 。
  示例 3：

输入：n = 1, quantities = [100000]
输出：100000
解释：唯一一种最优方案为：

• 所有 100000 件商品 0 都分配到唯一的商店中。
  分配给所有商店的最大商品数目为 max(100000) = 100000 。

class Solution {
    public int minimizedMaximum(int n, int[] quantities) {
        int left = 1;
        int right = 100000;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            int res = 0;
            for(int a: quantities) {
                res += a / mid;
                res += a % mid != 0 ? 1 : 0;
            }
            if (res < n) {
                right = mid - 1;
            } else if (res > n) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
            
    }
    return left;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23