【js】Leetcode每日一题-完成所有工作的最短时间

【js】Leetcode每日一题-完成所有工作的最短时间

【题目描述】

给你一个整数数组 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

---

【分析】

朴素递归模拟【dfs】

最容易想到的，模拟分配任务给每个工人，递归每个任务，使用idx结束递归，使用循环模拟分配给每个工人。

时间复杂度：\(O(k^n)\)

var minimumTimeRequired = function(jobs, k) {
    let max = 1e8;
    const kjobs = new Array(k).fill(0);
    const dfs = function(idx){
        if(idx == jobs.length){
            let m = Math.max.apply(null, kjobs);
            if(m < max){
                max = m;
            }
            return;
        }
        for(let i=0;i<k;i++){
            kjobs[i] += jobs[idx];
            dfs(idx+1);
            kjobs[i] -= jobs[idx];
        }
    }
    dfs(0);
    return max;
};

dfs+剪枝

可以想象，每个工人性质是相同的，所以模拟分配时，只需分配给第一个人，

比如，任务一81分配给工人1，则第一轮递归结束回到任务一时，任务一再分配给工人2时，这时分配给工人2其实等价于分配给工人1，后续分配均可以当作第一轮分配时工人1与工人2交换了位置。

所以，我们分配任务1时，可以默认给第一个人，然后分配任务2时，则只需分配给第一个人和第二个人（第二个人和后面的人性质相同），以此类推。

同时，如果当前分配的工人的任务时比已经得到的最小任务时长，可以直接剪掉。

时间复杂度：\(O(k!)\)

这样已经可以通过大部分样例。

/**
 * @param {number[]} jobs
 * @param {number} k
 * @return {number}
 */
var minimumTimeRequired = function(jobs, k) {
    // jobs.sort(function(a,b){return a<b?b:a;});
    let max = 1e8;
    const kjobs = new Array(k).fill(0);
    const dfs = function(idx){
        if(idx == jobs.length){
            let m = Math.max.apply(null, kjobs);
            if(m < max){
                max = m;
            }
            return;
        }
        for(let i=0;i<k;i++){
            kjobs[i] += jobs[idx];
            if(kjobs[i] < max){  //剪枝1：当前分配的工人以及超过已知最小任务时
                dfs(idx+1);
            }
            kjobs[i] -= jobs[idx];
            if(idx == i) return; //剪枝2
        }
    }
    dfs(0);
    return max;
};

后来一看，剪枝2处并没有完全实现我们剪枝的原理，比如，当任务1、任务2都分配给工人1时，那么分配任务3时，工人2和后面的工人性质相同，而上面代码会分配给2后还会再分配给3才剪掉后面的。

/**
 * @param {number[]} jobs
 * @param {number} k
 * @return {number}
 */
var minimumTimeRequired = function(jobs, k) {
    // jobs.sort(function(a,b){return a<b?b:a;});
    let max = 1e8;
    const kjobs = new Array(k).fill(0);
    const dfs = function(idx){
        if(idx == jobs.length){
            let m = Math.max.apply(null, kjobs);
            if(m < max){
                max = m;
            }
            return;
        }
        for(let i=0;i<k;i++){
            kjobs[i] += jobs[idx];
            if(kjobs[i] < max){  //剪枝1：当前分配的工人以及超过已知最小任务时
                dfs(idx+1);
            }
            kjobs[i] -= jobs[idx];
            if(kjobs[i] == 0) return; //剪枝2：当分配结束，此工人任务时为0，表示与模拟分配给后面工人均相同
        }
    }
    dfs(0);
    return max;
};

【官方题解】二分+贪心+剪枝+回溯+模拟

思路同在D天内送包裹的能力

取得最小工人任务时上下限，二分check这个时间是否是我们想要的。

check的方法与前面的回溯剪枝差不多。

var minimumTimeRequired = function(jobs, k) {
    jobs.sort((a, b) => b - a);
    let l = jobs[0], r = jobs.reduce(function(sum, curr){ return sum + curr });
    while (l < r) {
        const mid = Math.floor((l + r) >> 1);
        if (check(jobs, k, mid)) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    return l;
};

const check = (jobs, k, limit) => {
    const workloads = new Array(k).fill(0);
    return backtrack(jobs, workloads, 0, limit);
}

const backtrack = (jobs, workloads, i, limit) => {
    if (i >= jobs.length) {
        return true;
    }
    let cur = jobs[i];
    for (let j = 0; j < workloads.length; ++j) {
        if (workloads[j] + cur <= limit) {
            workloads[j] += cur;
            if (backtrack(jobs, workloads, i + 1, limit)) {
                return true;
            }
            workloads[j] -= cur;
        }
        // 如果当前工人未被分配工作，那么下一个工人也必然未被分配工作
        // 或者当前工作恰能使该工人的工作量达到了上限
        // 这两种情况下我们无需尝试继续分配工作
        if (workloads[j] === 0 || workloads[j] + cur === limit) {
            break;
        }
    }
    return false;
}