算法 Hw9

1 Scheduling with profits and deadlines

1

决策问题表述：

给定一个利润值 $P$，是否存在一个任务调度方案使得完成所有任务的总利润至少为 $P$

---

2

在 NP 类中：
给定一个任务调度方案，可以在多项式时间内验证该方案的总利润是否至少为 $P$。验证过程包括检查每个任务是否在截止日期前完成，并计算总利润。因此，该问题在 NP 类中。

对于 NP 完全性：
- 给定一个 0/1 背包问题实例，其中有 $n$ 个物品，每个物品有一个重量 $w_i$ 和价值 $v_i$，以及一个总重量限制 $W$。

• 对应于调度问题中的每个任务 $a_j$，设置其处理时间 $t_j=w_i$，利润 $p_j=v_i$，并设置截止日期 $d_j=W$，保证任务必须在总时间 $W$ 内完成。
• 利润值 $P$ 设为背包问题中的价值总和的要求。

通过归约，若能在调度问题中找到一个利润至少为 $P$ 的方案，则在 0/1 背包问题中可以找到一个总价值至少为 $P$ 且总重量不超过 $W$ 的物品选择方案。因此，调度问题的决策版本是 NP 完全的。

---

3

• 状态定义：设 $dp[t][k]$ 表示在总时间 $t$ 内，选择前 $k$ 个任务能获得的最大利润。

• 状态转移方程：
  对于每个任务 $a_j$，有两种选择：

  • 不选择任务 $a_j$：$dp[t][k]=dp[t][k-1]$
  • 选择任务 $a_j$（前提是 $t\ge t_j$ 且 $t\le d_j$）：$dp[t][k]=\max (dp[t][k-1],dp[t-t_j][k-1]+p_j)$

• 初始状态：

  • $dp[0][0]=0$，表示没有时间且没有任务时的利润为 0。

• 算法步骤：

  • 初始化 $dp$ 数组为 0。
  • 遍历所有任务，根据上述状态转移方程更新 $dp$ 数组。
  • 最终检查 $dp[T][n]$ 是否大于等于 $P$，其中 $T$ 是计算机的总时间。

---

4

• 状态定义：设 $dp[t]$ 表示在总时间 $t$ 内能获得的最大利润。

• 状态转移方程：
  对于每个任务 $a_j$，有两种选择：

  • 不选择任务 $a_j$：$dp[t]=dp[t]$
  • 选择任务 $a_j$（前提是 $t\ge t_j$ 且 $t\le d_j$）：$dp[t]=\max (dp[t],dp[t-t_j]+p_j)$

• 初始状态：

  • $dp[0]=0$，表示没有时间时的利润为 0。

• 算法步骤：

  • 初始化 $dp$ 数组为 0。
  • 遍历所有任务，根据上述状态转移方程更新 $dp$ 数组。
  • 最终 $dp[T]$ 即为最大利润，其中 $T$ 是计算机的总时间。

---

5

由于上述动态规划算法是一个精确算法（在多项式时间内找到最优解），因此它的近似比为 1，即它能够找到最优解。

---

2 Parallel machine

1

考虑所有工作中处理时间最长的工作 $J_k$，其处理时间为 p k = max ⁡ { p j : 1 ≤ j ≤ n } p_k = \max\{p_j : 1 \leq j \leq n\} pk​=max{pj​:1≤j≤n}。

由于该工作必须在某台机器上连续运行 $p_k$ 时间单位，且在此期间不能有其他工作在同一台机器上运行，因此该工作的完工时间至少为 $p_k$。

因此，最优完工时间 $C_{\text{max}}^{\ast }$ 必须至少为 $p_k$，即 C max ∗ ≥ max ⁡ { p k : 1 ≤ k ≤ n } C^*_{\text{max}} \geq \max\{p_k : 1 \leq k \leq n\} Cmax∗​≥max{pk​:1≤k≤n}。

---

2

设所有工作的总处理时间为 $P={\sum }_{k=1}^n{p}_k$。

对于最优调度，每台机器在总时间 $C_{\text{max}}^{\ast }$ 内处理一部分工作。

由于共有 $m$ 台机器，总的工作负载 $P$ 必须分配给这 $m$ 台机器。因此，平均每台机器的负载为 $\frac{P}{m}$。

在最优调度中，任意机器的完工时间不能少于其分配到的工作负载时间，即最优完工时间 $C_{\text{max}}^{\ast }$ 不能小于平均机器负载 $\frac{P}{m}$，即 $C_{\text{max}}^{\ast }\ge \frac{1}{m}{\sum }_{k=1}^n{p}_k$。

---

3

def GreedyParallelScheduling(jobs, m):
    # jobs 是一个由元组 (p_k, job_id) 组成的作业列表
    # m 是机器的数量

    # 初始化了一个大小为m的空列表schedules，
    # 用于记录每台机器分配的作业
    schedules = [[] for _ in range(m)]

    # 初始化了一个大小为m的数组machine_completion_times，
    # 用于记录每台机器的完工时间，初始值为0
    machine_completion_times = [0] * m

    # 对作业列表按照处理时间的非递增顺序进行排序
    jobs.sort(reverse=True, key=lambda x: x[0])

    # 对每个已排序的作业进行调度
    for (p_k, job_id) in jobs:
        # 找到完工时间最小的机器 Mi
        min_machine = machine_completion_times.index(min(machine_completion_times))

        # 将作业分配给机器 Mi
        schedules[min_machine].append(job_id)

        # 更新机器 Mi 的完工时间，增加该作业的处理时间
        machine_completion_times[min_machine] += p_k

    return schedules

运行时间:

• 初始化和读取输入需要 $O(n)$ 时间。
• 对作业按处理时间排序需要 $O(n\log n)$ 时间。
• 遍历每个作业并找到具有最小结束时间的机器需要 $O(n\log m)$ 时间，因为可以使用最小堆来跟踪机器的结束时间。

总体运行时间为 $O(n\log n+n\log m)=O(n\log n)$，因为通常情况下 $n\ge m$。

---

4

设所有工作的总处理时间为 $P={\sum }_{k=1}^n{p}_k$，处理时间最长的工作为 p max = max ⁡ { p k : 1 ≤ k ≤ n } p_{\text{max}} = \max\{p_k : 1 \leq k \leq n\} pmax​=max{pk​:1≤k≤n}。

在贪心算法中，任何时刻将未分配的工作分配给当前空闲时间最少的机器，这种策略确保每台机器的负载是尽可能均衡的。

假设最坏情况下某台机器上的负载时间为 $L$，即 $L\le \frac{P}{m}+p_{\text{max}}$
其中，$\frac{P}{m}$ 是平均每台机器分配到的负载时间，$p_{max}$ 是任何单个工作可能增加的最大负载时间。

因此，贪心算法的完工时间 $C_{max}$ 满足
C max ≤ 1 m ∑ k = 1 n p k + max ⁡ { p k : 1 ≤ k ≤ n } C_{\text{max}} \leq \frac{1}{m} \sum_{k=1}^{n} p_k + \max\{p_k : 1 \leq k \leq n\} Cmax​≤m1​k=1∑n​pk​+max{pk​:1≤k≤n}

由于最优完工时间 $C_{max}^{\ast }$ 至少为这两个量中的最大值，即：
C m a x ∗ ≥ max ⁡ ( 1 m ∑ k = 1 n p k , max ⁡ { p k : 1 ≤ k ≤ n } ) C^*_{max} \geq \max \left(\frac{1}{m} \sum_{k=1}^{n} p_k, \max\{p_k : 1 \leq k \leq n\}\right) Cmax∗​≥max(m1​k=1∑n​pk​,max{pk​:1≤k≤n})

结合以上两个不等式，可得
$$C_{max}\le 2C_{max}^{\ast }$$

因此，贪心算法是一个多项式时间的 2-近似算法。

---