【算法】Minimum Difficulty of a Job Schedule 工作计划的最低难度

Eric.Cui

已于 2023-06-27 18:05:18 修改

阅读量356

点赞数

分类专栏：数据结构与算法文章标签：算法

于 2023-05-16 21:35:24 首次发布

本文链接：https://blog.csdn.net/edisonzhi/article/details/130714604

版权

数据结构与算法专栏收录该内容

201 篇文章 0 订阅

订阅专栏

文章目录

Minimum Difficulty of a Job Schedule 工作计划的最低难度
Tag

Minimum Difficulty of a Job Schedule 工作计划的最低难度

问题描述：

问题

你需要制定一份 d 天的工作计划表。工作之间存在依赖，要想执行第 i 项工作，你必须完成全部 j 项工作（ 0 <= j < i）。

你每天至少需要完成一项任务。工作计划的总难度是这 d 天每一天的难度之和，而一天的工作难度是当天应该完成工作的最大难度。

给你一个整数数组 jobDifficulty 和一个整数 d，分别代表工作难度和需要计划的天数。第 i 项工作的难度是 jobDifficulty[i]。

返回整个工作计划的 最小难度 。如果无法制定工作计划，则返回 -1 。

jobDifficulty范围[1,300]
jobDifficulty[i]范围[0,1000]
d范围[1,10]

分析

问题中定义了【最小难度】

最小难度是每天处理任务的最大难度的累加和。

而且每天至少需要完成一个任务，总共有 $d$ 天，所以任务的数量必须是 $c n t >= d$ ,否则就无法符合题目要求，返回-1.
如果每天的工作难度用 $h$ 表示，最小难度 $\min(h) = h1+h2+...+hd$ .要使得 $\min(h)$ 最小，就需要累加和最小。
每个 $h$ 都是当天完成任务的最大值，所以前面的 $h$ 发生了变化，可能会影响到后面的 $h$ 。

如果存在最小的难度，那么就一定存在 $d 组$ 连续的划分,类似 ${h1\}\{h2\}\{hd\}$ .

$记 j o b 的总数为 N$ 。
比较暴力的思路就是对每一天的任务，进行枚举，即对于第 $i$ 天，如果第 $i - 1$ 天的最后一个任务 $j o b [x - 1]$ ，那么第 $i$ 天的任务就从 $j o b [x]$ 开始，向后扩展到 $j o b [y]$ ，然后取 $max{job[x]\rightarrow job[y]}$ ,同时要保证 $i+1\rightarrow d$ 的天数每天至少有1个任务， $d - (i + 1) + 1 <= N - y, d - i - N >= y$ .
然后逐一累加，需要枚举大量的组合。

设计dfs, $df s (in t d a y, in t j o b N)$ 表示在工作时间为day，完成到第 $j o b N$ 个任务时，可以得到的最小难度。

时间复杂度 $O(N^2)$
空间复杂度： $O(N^2)$

代码

	public int N;
    public int[] job,rec; 
    public int minDifficulty(int[] jobDifficulty, int d) {
        N = jobDifficulty.length;
        if(N<d) return -1;
        job = jobDifficulty;
        rec = new int[N];  
        for(int i = 0,max = -1;i<N;i++){
            rec[i] =  Math.max(max,job[i]);
            max = Math.max(max,job[i]);
        } 
        return dfs(d,N-1);
    }
    public int dfs(int day,int ind){  
        if(day==1){ 
            return rec[ind];            
        }
        int res = Integer.MAX_VALUE,mx = job[ind]; 
        for(int len= 1;;len++){ 
            int j = ind -len ;
            if(j+1<day-1) break; 
            mx = Math.max(mx,job[j+1]);            
            int tmp = dfs(day-1,j)+mx;
            res = Math.min(res,tmp);  
        } 
        return res;
    }

纯暴力递归是TLE的

	public int N;
    public int[] job,rec;
    public int[][] memo;
    public int minDifficulty(int[] jobDifficulty, int d) {
        N = jobDifficulty.length;
        if(N<d) return -1;
        job = jobDifficulty;
        rec = new int[N];
        memo = new int[d+1][N+1];
        for(int i = 0;i<=d;i++){
            Arrays.fill(memo[i],-1);
        }
        for(int i = 0,max = -1;i<N;i++){
            rec[i] =  Math.max(max,job[i]);
            max = Math.max(max,job[i]);
        } 
        return dfs(d,N-1);
    }
    public int dfs(int day,int ind){ 
        if(memo[day][ind]!=-1) return memo[day][ind];
        if(day==1){ 
            return rec[ind];            
        }
        int res = Integer.MAX_VALUE,mx = job[ind]; 
        for(int len= 1;;len++){ 
            int j = ind -len ;
            if(j+1<day-1) break; 
            mx = Math.max(mx,job[j+1]);            
            int tmp = dfs(day-1,j)+mx;
            res = Math.min(res,tmp);  
        } 
        return memo[day][ind] = res;
    }