1723. Find Minimum Time to Finish All Jobs

问题：

将一组jobs分配给k个人，求完成这些job，最小需要的时间。

Example 1:
Input: jobs = [3,2,3], k = 3
Output: 3
Explanation: By assigning each person one job, the maximum time is 3.

Example 2:
Input: jobs = [1,2,4,7,8], k = 2
Output: 11
Explanation: Assign the jobs the following way:
Worker 1: 1, 2, 8 (working time = 1 + 2 + 8 = 11)
Worker 2: 4, 7 (working time = 4 + 7 = 11)
The maximum working time is 11.
 
Constraints:
1 <= k <= jobs.length <= 12
1 <= jobs[i] <= 107

　　

解法：Backtracking（回溯算法）DP（动态规划）

• 状态：到当前job[pos]为止，job的分配情况path，以及当前需要的最大工数preMax
• 选择：将当前job[pos]分配给 0～k-1 任意一个工人
  • 除去，这个工人当前所用工数，和已经选择过的工人相同。（这样的选择，没什么区别）
  • or，这个工人的工数+当前job[pos]的工数>res，超过已经成功分配得到的一个解。（我们要找更小的解）
• 递归退出条件：pos==jobs.size

 

♻️ 优化：将jobs进行从大到小排序，先分配工数大的，会比较快。

相较于将 res 初始化为INT_MAX，更优化的方法：取最大的jobs.size/k个工作给一个工人，这个工人用时一定最大。

 

代码参考：

class Solution {
public:
    //state: So far, jobs assignment situation:path, and the max workLoad: preMax
    //jobs[pos] assign to who?
    //opt:workers[0]~wokers[k-1]
    int res = 0;
    int path[12];
    void backtrack(int pos, int preMax, vector<int>& jobs, int k) {
        if(pos == jobs.size()) {
            res = min(res, preMax);
            return;
        }
        unordered_set<int> used;
        for(int i=0; i<k; i++) {
            if(used.insert(path[i]).second==false) continue;//same workload try only once
            if(path[i]+jobs[pos]>=res) continue;// bigger than already gotten min res.
            path[i]+=jobs[pos];
            backtrack(pos+1, max(preMax, path[i]), jobs, k);
            path[i]-=jobs[pos];
        }
        return;
    }
    int minimumTimeRequired(vector<int>& jobs, int k) {
        if(k==jobs.size()) return *max_element(begin(jobs), end(jobs));
        vector<int> path(k, 0);
        sort(jobs.begin(), jobs.end(), greater<int>());
        for (int i = 0; i < jobs.size(); i += k)
            res += jobs[i];
        backtrack(0, 0, jobs, k);
        return res;
    }
};

 

DP：

状态：

dp[i][j]：i 个工人，做map=j的job，花费的最小工数。

状态转移：

将 i 个工人，分出一个人，去做 j 的所有子集合的可能，

例如其中一个子集合subj，那么这个人需要做的工数=sum[subj]

总工数：剩下i-1个人的工数dp[i-1][j-subj] ， sum[subj] 中求最大。

那么，对于所有子集合可能，我们要求的最优解：min(所有可能)：即：

dp[i][j] = min{ all subj: max( dp[i-1][j-subj], sum[subj] ) }

 

base case:

dp[1][j] = sum[j]

 

求sum[j]:

j为job的map选择：如果 j的某一位 i ==1，那么sum+=jobs[i]，即：

for(all j : 0~(1<<n) )  i：第 i 个job

if ((j>>i)&1==1) sum[j]+=jobs[i]

 

代码参考：

class Solution {
public:
    //dp[i][j]:0~i workers to do map_j jobs: the min time cost
    //dp[i][j]=min( <for all subj> : max(dp[i-1][subj],sum[j-subj]) ) subj:subset of j
    //one worker to do sum[j-subj] and others have the min time cost: dp[i-1][subj];
    
    //base case: dp[1][j]=sum[job[0]+...+job[j]];
    int minimumTimeRequired(vector<int>& jobs, int k) {
        if(k==jobs.size()) return *max_element(begin(jobs), end(jobs));
        int n = jobs.size();
        vector<vector<int>> dp(k+1, vector<int>(1<<n));
        vector<int> sum((1<<n), 0);
        //get sum:
        for(int i=1; i<(1<<n); i++) {
            for(int j=0; j<n; j++) {
                if((i>>j)&1==1) {
                    sum[i] += jobs[j];
                }
            }
        }
        //base:
        for(int j=0; j<(1<<n); j++) {
            dp[1][j] = sum[j];
        }
        //loop:
        for(int i=2; i<=k; i++) {//for every i workers
            for(int j=1; j<(1<<n); j++) {//for each jobs assignment map:j
                dp[i][j] = max(dp[i-1][j],sum[0]);
                for(int subj=j; subj>0; subj=(subj-1)&j) {//for each subset of j:all->0
                    dp[i][j] = min(dp[i][j], max(dp[i-1][subj], sum[j-subj]));
                }
            }
        }
        
        return dp[k][(1<<n)-1];
    }
};