力扣每日一题：

给你一个整数数组 jobs ，其中 jobs[i] 是完成第 i 项工作要花费的时间。

请你将这些工作分配给 k 位工人。所有工作都应该分配给工人，且每项工作只能分配给一位工人。工人的 工作时间 是完成分配给他们的所有工作花费时间的总和。请你设计一套最佳的工作分配方案，使工人的 最大工作时间 得以 最小化 。

返回分配方案中尽可能 最小 的 最大工作时间 。

 

示例 1：

输入：jobs = [3,2,3], k = 3
输出：3
解释：给每位工人分配一项工作，最大工作时间是 3 。
示例 2：

输入：jobs = [1,2,4,7,8], k = 2
输出：11
解释：按下述方式分配工作：
1 号工人：1、2、8（工作时间 = 1 + 2 + 8 = 11）
2 号工人：4、7（工作时间 = 4 + 7 = 11）
最大工作时间是 11 。
 

提示：

1 <= k <= jobs.length <= 12
1 <= jobs[i] <= 107

直接很难求出最小的最大工作时间在这里设为limit，先想到暴力，枚举每一个可能的limit（可用二分），然后判断是否可行（搜索过程），然后简化，利用二分查找简化枚举过程。
1，为什么能用二分？如果当前limit不可行，则比这个limit更小的都不可行，如果当前这个limit可行，那么可能存在更小的可行的limit。
2，判断合法：k个工人无差别用一层循环判断是否可执行当前人物，如果可行则递归搜索下一个任务，分配任务按照先分配工作量大的任务，这样能避免小任务分配完大任务无法分配的现象。

class Solution {
public:
    bool backtrack(vector<int>& jobs, vector<int>& workloads, int idx, int limit) {
        if (idx >= jobs.size()) {
            return true;
        }
        int cur = jobs[idx];
        for (auto& workload : workloads) {
            if (workload + cur <= limit) {
                workload += cur;
                if (backtrack(jobs, workloads, idx + 1, limit)) {
                    //剩下的工作都能按照limit分配
                    //直接返回可行
                    return true;
                }
                //不可行
                workload -= cur;
            }
            // 如果当前工人未被分配工作，那么下一个工人也必然未被分配工作
            // 或者当前工作恰能使该工人的工作量达到了上限
            // 这两种情况下我们无需尝试继续分配工作
            if (workload == 0 || workload + cur == limit) {
                break;
            }
        }
        return false;
    }
    bool check(vector<int>& jobs, int k, int limit) {
        vector<int> workloads(k, 0);
        return backtrack(jobs, workloads, 0, limit);
    }

    int minimumTimeRequired(vector<int>& jobs, int k) {
        sort(jobs.begin(), jobs.end(), greater<int>());//按照工作量从大到小排序
        //对limit做二分查找，左边界为所有工作量的最大值，右边界为所有工作量之和
        int l = jobs[0], r = accumulate(jobs.begin(), jobs.end(), 0);
        //accumulate(迭代器的起始位置，迭代器的终止位置，和的初始值)
        while (l < r) {
            int mid = (l + r) >> 1;
            if (check(jobs, k, mid)) {
                r = mid;
            }
            else {
                l = mid + 1;
            }
        }
        return l;
    }
    int minimumTimeRequeired(vector<int>& jobs, int k) {
        sort(jobs.begin(), jobs.end(),greater<int>());
        int l = jobs[0]; int r = accumulate(jobs.begin(), jobs.end(), 0);
        while (l < r) {
            int mid = (l + r) >> 1;//右移一位等于整除2
            if (check(jobs, k, mid)) {
                r = mid;
            }
            else {
                l = mid + 1;
            }
        }
        return l;
    }
};