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

Eric.Cui

已于 2023-05-20 16:56:16 修改

阅读量369

点赞数

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

于 2023-05-19 21:37:10 首次发布

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

版权

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

201 篇文章 0 订阅

订阅专栏

文章目录

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

Minimum Difficulty of a Job Schedule 工作计划的最低难度-单调栈

问题描述：

略

分析

单调栈

下标p是j左侧第一个满足job[p]>job[j]

当k>=p ,f{k+1~~ j}最大的就是job[j]
$\begin{equation} \begin{aligned} \textit{dp}[i][j] =& \min_{k=p,p+1,\dots,j - 1}\{\textit{dp}[i-1][k] + \textit{jobDifficulty}[j]\} \\ =& \min_{k=p,p+1,\dots,j - 1}\{\textit{dp}[i-1][k]\} + \textit{jobDifficulty}[j] \end{aligned} \end{equation}$
当k<p,f{k+1~~ j}最大的就是job[p]
$\begin{equation} \begin{aligned} \textit{dp}[i][j] =& \min_{k=i-1,i,\dots,p - 1}\{\textit{dp}[i-1][k] + f(k + 1, p)\} \\ =& \textit{dp}[i][p] \end{aligned} \end{equation}$

在DP中，dp[i] [j] = dp[i-1] [k-1]+ f{k~ ~ j}
f{k~ ~ j} 表示这个区间最大的值。
而在寻找max的过程中，最简单的就是遍历过程中进行比较。

但是在遍历过程中，只有当左侧出现较大的元素时，f{}才会变化。
因为 k的范围是[i,j],初始时区域最大值max是job[j].
假设有一个位置p，p>=0 && p<j && job[p]>job[j],
情况1 如果 k >= p
dp[i] [j] = min(dp[i-1] [k]+job[j]) k∈ [p,j-1]
即 dp[i] [j] = min(dp[i-1] [k])+job[j] k ∈ [p,j-1]
job[j] 就是 f{k+1~ ~ ~ j}这个区域的最大值。
情况2 如果 k< p , f{ k+1~ ~ ~j}这个区域的最大值就是job[p].
此时f{k+1~ ~ ~ j}==f{k+1~ ~ ~p}
dp[i] [j] = min(dp[i-1] [k]+ f{k+1~~~p}) k∈ [i-1,p-1]
dp[i] [j] =dp[i] [p]

所以dp[i] [j] 是有2个情况综合决定的，这2个情况实际上是把原来线性遍历maxjob的过程划分成为2段。假设p已知，那么dp[i] [j], k就需要在[p,j-1]的范围内遍历一遍{目的是为了找最小的dp }，而且maxjob是job[j].然后理论上k在[i-1,p-1]范围内也需要遍历，但是情况2中通过变换，可以直接使用dp[i][p].
到此问题又发生变化，原来的DP框架下枚举k的环节，要调整，而且是找j左侧第一个p&&job[p]>job[j].
很明显这个问题需要单调栈来处理。
如果p<j,但是 job[p]<=job[j],即满足上面的条件的p不存在，那么就只能暴力的遍历一次dp[i-1] [k],同时dp[i-1] []不一定单调，就必须使用暴力，在暴力处理完成后，dp[i-1] [i-1~~j-1]的区间内最小值也就可以知道了，当j逐渐增大，即使p不存在，也不用全部暴力，只需要把之前记录的最小值拿出来比较，就可以了。
为了处理p，就需要单调递减栈，整个区间会被若干个p划分，p1,p2,p3…,p1> p2> p3,
0~ p1-1,p1~ p2-1,p2~ p3-1,这几个区间的dp[i] []都是相同的。即以pi为分割，p(i-1)~pi-1 ==> val(i).
要计算dp[i] [j],首先就是枚举mx = dp[i-1] [j-1]，
当stack.isEmpty||job[j]<job[p3],说明和上面的思路一样，分2块，因为单调栈的存在，如果栈空了，说明j左侧不存在p，dp[i] [j] = dp[i-1] [j-1]+job[j].如果栈不空，dp[i] [j]= min(dp[i] [stack.top],dp[i-1] [j-1]+job[j]),得到dp[i][j],然后入栈。
为了维护单调栈，当job[stack.top]<=job[j],就要出栈同时更新mx，为了增加数据，栈的每个元素以[pi,dp[i] [] ]的形式入栈。

能想到单调栈这个思路的人，也是个狠人。你能想到，但是不一定能用的灵活。

时间复杂度 O(Nd)
空间复杂度： O(N)

代码

public int minDifficulty(int[] jobDifficulty, int d) {
        int n = jobDifficulty.length;
        if (n < d) {
            return -1;
        }
        int[][] dp = new int[d][n];
        for (int j = 0, ma = 0; j < n; ++j) {
            ma = Math.max(ma, jobDifficulty[j]);
            dp[0][j] = ma;
        }
        for (int i = 1; i < d; ++i) {
            Deque<int[]> stack = new ArrayDeque<int[]>();
            for (int j = i; j < n; ++j) {
                int mi = dp[i - 1][j - 1];
                while (!stack.isEmpty() && jobDifficulty[stack.peek()[0]] <= jobDifficulty[j]) {
                    mi = Math.min(mi, stack.pop()[1]);
                }
                if (stack.isEmpty()) {
                    dp[i][j] = mi + jobDifficulty[j];
                } else {
                    dp[i][j] = Math.min(dp[i][stack.peek()[0]], mi + jobDifficulty[j]);
                }
                stack.push(new int[]{j, mi});
            }
        }
        return dp[d - 1][n - 1];
    }