Lecture 4 Online Scheduling

讲义 HTML（Online-Scheduling.html）第 1–187 页，第 15–20 页并入第 14 页的交互演示（slides 无页脚页码）

前三讲的在线问题都是”服务请求、付移动或缺页代价”。本讲换一类问题：在线调度。jobs 逐个到来，要立刻（或在合适的时刻）把它们分到机器上，目标是让最后完工的时间（makespan）尽量早。这也是负载均衡的模型：jobs 是任务，machines 是服务器。

全讲围绕两个下界展开：OPT 不能太小，因为工作量要摊到所有机器上（效率界）；同时大 job 不能太多，因为两个大 job 落在同一台机器上就会撞破 OPT（组合界）。几乎所有上界证明都是”假设 ALG 很大，推出这两个界之一被违反”。

部分	模型	核心结论
1. 基本问题与 Greedy	列表到达 + 相同机器	Greedy 是 $(2-\frac{1}{m})$-competitive；$m=2$ 时最优
2. 打破 2：避免平坦	同上	MR 算法 $1.9201$；关键是不让所有机器一样高
3. 一般模型与技巧	—	机器类型 / 到达方式 / 目标；效率界、组合界、doubling、分层
4. 实时到达	实时到达 + 相同机器	在线 LPT 是 $1.5$-competitive；$m=2$ 下界 $1.382$
5. 相关机器	列表到达 + 速度不同	改进的 Greedy 是 $\Theta (\log m)$；slow fit + doubling 是 $8$
6. 不相关机器	列表到达 + 任意 $p_{ij}$	下界 $\Omega (\log m)$；指数势函数达到 $O(\log m)$

1. 基本问题与 Greedy

1.1 在线 makespan 最小化

定义：Makespan 最小化（负载均衡）

• 输入：$m$ 台相同的机器，$n$ 个 job，job $j$ 的大小（处理时间）为 $p_j$。
• 输出：把每个 job 分给一台机器，最小化 makespan，即所有 job 的最大完工时间。机器 $i$ 的负载 $L(i)$ 是分给它的 job 大小之和，makespan $={\max }_{i}L(i)$。
• 在线（列表到达，list arrival）：job 逐个到来，每来一个必须立即且不可撤销地选定机器，然后才看到下一个。

离线版本已是 NP-hard（$m=2$ 时就包含 Partition），但有好的近似：LPT（Longest Processing Time first）先把 job 按大小降序排列，再依次放到当前负载最小的机器上，是 $\frac{4}{3}$-近似。在线时无法排序，只能按到达顺序处理。

1.2 Greedy 是 $(2-\frac{1}{m})$-competitive

定义：Greedy（List Scheduling，Graham 1966）

每来一个 job，放到当前负载最小的机器上。

两个关于 OPT 的下界贯穿全讲：

• 效率界：$\mathrm{OPT}\ge \frac{1}{m}{\sum }_j{p}_j$（总工作量摊到 $m$ 台机器上）。
• 单个 job：$\mathrm{OPT}\ge {\max }_j{p}_j$。

定理：Greedy 是 $(2-\frac{1}{m})$-competitive（Graham 1966）

证明

设决定 makespan 的机器上最后放入的 job 为 $n$（之后到达的 job 不影响这台机器，可以删掉，不妨设它就是最后一个 job），它的开始位置为 $t$，即放入前该机器的负载，于是 $\mathrm{ALG}=t+p_n$。Greedy 选的是负载最小的机器，所以放入 $p_n$ 时每台机器的负载都 $\ge t$。由效率界， $\mathrm{OPT}\ge \frac{tm+p_n}{m}=t+\frac{p_n}{m}.$ 所以 $\mathrm{ALG}-\mathrm{OPT}\le \left(1-\frac{1}{m}\right)p_n\le \left(1-\frac{1}{m}\right)\mathrm{OPT}$，即 $\mathrm{ALG}\le \left(2-\frac{1}{m}\right)\mathrm{OPT}$。

粗略版本是 $t\le \mathrm{OPT}$、$p_n\le \mathrm{OPT}$，所以 $\mathrm{ALG}\le 2\mathrm{OPT}$。后面 LPT 和相关机器的分析都沿用这个框架：盯住”最后一个 job”，分别估计它的开始时间和它本身的大小。

分析是紧的：先来 $m(m-1)$ 个大小为 $1$ 的 job，Greedy 把每台机器都堆到 $m-1$；再来一个大小为 $m$ 的 job，$\mathrm{ALG}=2m-1$。OPT 把小 job 平均放在 $m-1$ 台机器上（每台 $m$），大 job 单独占一台，$\mathrm{OPT}=m$。比值 $\frac{2m-1}{m}=2-\frac{1}{m}$。

1.3 $m=2$ 时 Greedy 最优

定理： $m=2$ 时任何确定性在线算法的竞争比 $\ge \frac{3}{2}=2-\frac{1}{2}$

证明

先来两个大小为 $1$ 的 job。确定性算法只有两种做法：

flowchart TD
  S["两个大小为 1 的 job"] --> A["放在同一台机器"]
  S --> B["各放一台"]
  A --> A1["停止：ALG = 2，OPT = 1，比值 2"]
  B --> B1["再来一个大小为 2 的 job：ALG ≥ 3，OPT = 2，比值 3/2"]

两种情况下比值都 $\ge \frac{3}{2}$。

所以 $m=2$ 时 $2-\frac{1}{m}$ 是最优竞争比。$m$ 很大时，能不能明显好于 $2$？

2. 打破 2：避免”平坦”的调度

2.1 已知结果

确定性算法，一般 $m$：上下界目前是 $[1.88,1.9201]$。

年份	作者	结果	类型
1966	Graham	$2-\frac{1}{m}$；$m=2,3$ 时最优	上界
1993	Galambos, Woeginger	$2-\frac{1}{m}-{ϵ}_m$，$m\ge 4$	上界
1995	Bartal et al.	$1.986$	上界
1996	Karger et al.	$1.945$	上界
1999	Albers	$1.923$	上界
2000	Fleischer, Wahl	$1.9201$（$m\to \infty$）	上界
2001	Rudin III	$1.88$（$m\to \infty$）	下界

随机算法：一般 $m$ 时为 $[1.582,1.916]$（下界 Sgall 1997，上界 Albers 2002）。

所有突破 $2$ 的算法都基于同一个想法：避免平坦的调度。

2.2 为什么”平坦”危险

回看 Greedy 的紧例子：坏就坏在大 job 到来时所有机器一样高（都是 $m-1$），它放在哪里都会叠在高处。如果有几台机器保持很低，大 job 就可以放在低处，而不必叠到 $m-1$ 之上。

所以来一个小 job 时有两种选择：

• Greedy：放在最低的机器上，当前代价小；
• Steep（陡峭）：放在一台较高的机器上，故意保持一些机器很低，为将来的大 job 留位置。

决策规则大致是：

• 调度已经足够陡峭 → 不必再刻意保持，按 Greedy 放；
• 调度已经危险（再往高处放会超过目标比值）→ 按 Greedy 放；
• 其余情况 → 让调度更陡峭。

2.3 MR 算法

定义：MR 算法（Fleischer & Wahl, ESA 2000）

把机器按当前负载升序排列，机器 $1$ 负载最小。前 $k$ 台为 Light，其余为 Heavy。参数 $c\approx 1.9201$，$a\approx 0.46$，$k\approx 0.36m$。新 job $p$ 到来时：

• 已经陡峭：$\mathrm{Avg}(\mathrm{Light})\le a\cdot L(2k+1)$ → Greedy，放在机器 $1$；
• 已经危险：$L(k+1)+p\ge c\cdot \mathrm{Avg}(\mathrm{All})$ → Greedy，放在机器 $1$；
• 否则 → 放在机器 $k+1$（最低的 Heavy 机器），使调度变陡。

其中 $\mathrm{Avg}(\cdot )$ 表示一组机器的平均负载。

放在 $k+1$ 而不是更高的机器，是因为它在 Heavy 中最低，代价最小；Light 机器则一直留着给大 job。条件”危险”保证这种刻意的不平衡不会直接把 makespan 推过 $c$ 倍。

2.4 分析（只给框架）

完整证明很长，讲义只给思路。设存在最小反例：$\mathrm{ALG}>c\cdot \mathrm{OPT}$。设最后一个 job $p_n$ 决定了 makespan，开始位置为 $s_n$，于是 $\mathrm{ALG}=s_n+p_n>c\cdot \mathrm{OPT}$。

第一步：$p_n$ 是按 Greedy 放的。若它放在机器 $k+1$，说明不危险：$L(k+1)+p_n<c\cdot \mathrm{Avg}(\mathrm{All})\le c\cdot \mathrm{OPT}$，与 $\mathrm{ALG}>c\cdot \mathrm{OPT}$ 矛盾。所以它放在负载最小的机器 $1$ 上，$s_n=L(1)$，此时所有机器的负载都 $\ge s_n$（称为都”满”了）。

再记两个简单事实：由 $p_n\le \mathrm{OPT}$ 和 $s_n+p_n>c\cdot \mathrm{OPT}$ 得 $s_n>(c-1)\mathrm{OPT}$；由效率界 $\mathrm{OPT}\ge s_n$。

第二步：$p_n$ 到来时调度一定是平坦的，即 $\mathrm{Avg}(\mathrm{Light})>a\cdot L(2k+1)$。否则 $s_n\le \mathrm{Avg}(\mathrm{Light})\le a\cdot L(2k+1)$。机器 $2k+1,\dots ,m$ 的负载都 $\ge L(2k+1)\ge s_n/a$，其余机器 $\ge s_n$，由效率界

$$\mathrm{OPT}\ge \frac{2k\cdot s_n+(m-2k)\cdot s_n/a}{m}\approx s_n(0.72+0.28/0.46)\approx 1.33s_n>1.33\times 0.92\mathrm{OPT}\approx 1.22\mathrm{OPT},$$

矛盾。这就是参数 $a,k$ 的作用：陡峭的调度”浪费”了足够多的工作量，最后不可能还是坏情况。

第三步：找 $m+1$ 个大 job。称 job 为大的，若 $p\ge \frac{s_n}{2(c-1)}$（$\approx 0.54s_n$）。若有 $m+1$ 个大 job，必有两个落在 OPT 的同一台机器上，$\mathrm{OPT}\ge \frac{s_n}{c-1}$，于是 $\mathrm{ALG}=s_n+p_n\le (c-1)\mathrm{OPT}+\mathrm{OPT}=c\cdot \mathrm{OPT}$，矛盾。

• $p_n$ 是大的：$p_n>c\cdot \mathrm{OPT}-s_n\ge (c-1)s_n\approx 0.92s_n$。
• 另外 $m$ 个：每台机器最终都满了（负载 $\ge s_n$）。把一台机器”变满”的那个 job 称为 filling job，每台机器一个，共 $m$ 个。要证明所有 filling job 都是大的。

第四步：filling job 为什么大（只有直觉）。以最后一个 filling job $p_j$ 为例：

• 若 $p_j$ 到来前调度平坦：MR 会把它放到 $k+1$，除非危险；它能填满某台机器，需要 $p_j+L(k+1)\ge c\cdot \mathrm{Avg}(\mathrm{All})$，即 $p_j\ge c\cdot \mathrm{Avg}(\mathrm{All})-L(k+1)$。若 $L(1)$ 已经很小，填满它需要大 job；若 $L(1)$ 很大，则平均负载大，$p_j$ 也必须大。
• 若调度陡峭：最终调度是平坦的（第二步），从陡峭变到平坦需要足够多的工作量，而这时 $L(1)$ 保证很小，填满它的 job 必须大。

其余 filling job 的论证类似，但细节繁琐，略去。

思路：MR 的证明在做什么

想推出矛盾，就要用到两个下界之一：

• 效率界：陡峭的调度里，Heavy 机器比 Light 高很多，总工作量大，OPT 被迫变大。第二步说明坏情况的终局一定平坦。
• 组合界：平坦的终局里每台机器都满了，而每台机器的 filling job 都是大 job，加上 $p_n$ 共 $m+1$ 个，两个必须在 OPT 中同机，OPT 被迫变大。

算法的设计就是让每一种局面都至少被其中一个界”罚”到：要么调度陡峭，大 job 有低处可放；要么平坦，但那时 OPT 也不小。

3. 一般模型与技巧

3.1 模型的维度

机器不一定相同，job 也不一定一到就要决定：

维度	选项	含义
机器	Identical	所有机器相同，job $j$ 处理时间 $p_j$
	Related	机器 $i$ 有速度 $s_i$，处理时间 $p_j/s_i$
	Unrelated	每个（机器, job）对有自己的处理时间 $p_{ij}$
到达	List arrival	job 逐个到来，立即决定
	Real-time arrival	job 在释放时间 $r_j$ 出现，算法在任意时刻可以在空闲机器上开始一个 job
目标	Makespan	${\max }_j{C}_j$
	总完工时间	${\sum }_j{C}_j$
	总流时间	${\sum }_j(C_j-r_j)$

模型太多，本讲只讲 makespan，按以下顺序：

flowchart LR
  A["列表到达 + 相同机器<br/>Greedy 2−1/m，MR 1.92"] --> B["实时到达 + 相同机器<br/>在线 LPT 1.5"]
  A --> C["列表到达 + 相关机器<br/>Θ(log m) → 常数 8"]
  C --> D["列表到达 + 不相关机器<br/>Θ(log m)"]

3.2 常用技巧

• OPT 的下界
  • 效率界：工作量不能太多，$\mathrm{OPT}\ge$ 总工作量 / 总处理能力。
  • 组合界：大 job 不能太多，两个 $>\frac{1}{2}\mathrm{OPT}$ 的 job 不能同机。
• Doubling：先假设知道 OPT 的值设计算法，再用猜测并翻倍去掉这个假设（Lecture 1 线搜索的翻倍思想）。
• Grouping / 分层：把 job、机器或负载按量级分成若干层，每层损失一个常数，层数是 $O(\log m)$。

4. 实时到达 + 相同机器

4.1 模型

定义：实时到达的在线 makespan 最小化

• $m$ 台相同的机器；job $j$ 有大小 $p_j$ 和释放时间 $r_j$。
• 在时刻 $t\ge r_j$ 算法才知道 job $j$（及其大小）；$r_j>t$ 的 job 尚不可见。
• 任何时刻都可以在一台空闲机器上开始一个已释放的 job（不可中断）。
• OPT 事先知道所有 job 的大小和释放时间，但同样不能在 $r_j$ 之前开始 job $j$。

与列表到达的区别：决定的是何时开始、在哪开始，不必在 job 到达时立刻承诺。算法可以让 job 排队等待。

4.2 Greedy 与在线 LPT

Greedy（job 一到就放到当前最闲的机器上）仍然是 $(2-\frac{1}{m})$-competitive，原证明照搬；紧例子也照搬（所有 job 在时刻 $0$ 按列表顺序释放）。

但实时模型允许等待：job $p_i$ 在 $r_i$ 到来，若等到某台机器空闲的时刻 $s$ 再决定，期间 $[r_i,s)$ 可能又来了更长的 job，先做长的更好。这就是 LPT 的在线版本。

定义：在线 LPT

每当一台机器在时刻 $t$ 空闲且有待处理的 job，就在它上面开始当前最长的待处理 job。

在线 LPT 不会在有待处理 job 时让机器闲着，只是把”选哪个 job”推迟到机器空闲时。它化解了 Greedy 的紧例子：

• 若大 job 也在时刻 $0$ 释放，LPT 先做它，正好是 OPT。
• 若对手推迟大 job（如 $r=1+ϵ$），OPT 也只能从 $1+ϵ$ 起做它，$\mathrm{OPT}\ge m+1+ϵ$；而 LPT 在时刻 $2$ 就能开始它，$\mathrm{ALG}\le m+2$，比值趋于 $1$。

定理：在线 LPT 对所有 $m$ 都是 $1.5$-competitive（Chen & Vestjens 1997）

4.3 证明框架

设 job $n$ 在 ALG 中最后完工，开始时刻为 $t$，$\mathrm{ALG}=t+p_n$。反设 $\mathrm{ALG}>1.5\mathrm{OPT}$。

照搬 Greedy 的框架会得到"$t\le \mathrm{OPT}$"，但这在实时模型中可能是错的：$t$ 之前机器可能有空闲（job 还没释放），工作量不足以推出 $\mathrm{OPT}\ge t$。先假设没有空闲，看证明的主干；再处理空闲。

引理 1：最后的 job 等了超过 $\frac{1}{2}\mathrm{OPT}$

$t-r_n>\frac{1}{2}\mathrm{OPT}.$

证明

$r_n+p_n\le \mathrm{OPT}$（OPT 也要在 $r_n$ 之后做完 $n$），而 $t+p_n=\mathrm{ALG}>1.5\mathrm{OPT}$，两式相减。

$n$ 在 $[r_n,t)$ 内一直待处理，LPT 却没开始它，所以这段时间所有机器都忙。忙的是什么 job？

引理 2： $m$ 个"拦路"的 job

每台机器 $i$ 上都有一个 job $j_i\ne n$，满足以下之一：

• (a) $j_i$ 在 $[r_n,t)$ 内开始：则 $p_{j_i}\ge p_n$；
• (b) 机器 $i$ 在 $[r_n,t)$ 内没有开始任何 job：则有一个 job 贯穿整个 $[r_n,t)$，$p_{j_i}\ge t-r_n>\frac{1}{2}\mathrm{OPT}$。

证明

(a) 开始 $j_i$ 时 $n$ 已释放且在等待，LPT 选最长的，所以 $p_{j_i}\ge p_n$。(b) 机器一直忙又没有新开始的 job，只能是同一个 job 从 $r_n$ 之前一直做到 $t$ 之后。不同机器上的 $j_i$ 互不相同。

情形 A：$p_n>\frac{1}{2}\mathrm{OPT}$。$m$ 个 $j_i$ 都 $>\frac{1}{2}\mathrm{OPT}$（(a) 型 $\ge p_n$，(b) 型由引理 1），加上 $n$ 共 $m+1$ 个大于 $\frac{1}{2}\mathrm{OPT}$ 的 job。由鸽巢原理，OPT 中有两个在同一台机器上，这台机器的负载 $>\mathrm{OPT}$，矛盾。

情形 B：$p_n\le \frac{1}{2}\mathrm{OPT}$。若 $t\le \mathrm{OPT}$，则 $\mathrm{ALG}\le 1.5\mathrm{OPT}$，矛盾。但如上所说，$t\le \mathrm{OPT}$ 不一定成立，需要处理空闲。

4.4 处理空闲：情形 B 的严格证明

令 $t^{\prime }$ 为 $t$ 之前最后一个空闲区间的结束时刻（某台机器空闲的最后时刻；若从未空闲则 $t^{\prime }=0$）。于是 $[t^{\prime },t)$ 内所有机器都忙。

基本事实（F）：LPT 只在没有待处理 job 时才让机器空闲，所以 $t^{\prime }$ 之前释放的 job 在 $t^{\prime }$ 时都已开始（忽略端点情形）。特别地 $t^{\prime }\le r_n$。

情形 B 的证明分成两个断言，分别改进"$t\le \mathrm{OPT}$"和"$p_n\le \frac{1}{2}\mathrm{OPT}$"，两者相加正好是 $1.5$：

断言 A： $\mathrm{OPT}\ge t-\frac{t^{\prime }}{2}$

断言 B： $p_n\le \frac{1}{2}(\mathrm{OPT}-t^{\prime })$

于是 $\mathrm{ALG}=t+p_n\le \mathrm{OPT}+\frac{t^{\prime }}{2}+\frac{1}{2}\mathrm{OPT}-\frac{t^{\prime }}{2}=1.5\mathrm{OPT}$，矛盾。定理得证。

断言 A 的证明

设 $C$ 为在 $t^{\prime }$ 之前开始、在 $t^{\prime }$ 时仍在运行的 job（跨过 $t^{\prime }$ 的 job）。$t^{\prime }$ 之前一刻有一台机器空闲，所以 $|C|\le m-1$。对 $j\in C$，记它在 ALG 中的延迟 $d_j=s_j-r_j$（$s_j$ 为开始时刻），$\delta ={\max }_{j\in C}{d}_j$（$C$ 为空时 $\delta =0$），对应的 job 称为”最受延迟的 job”。

(i) $\mathrm{OPT}\ge t-\delta$。ALG 在 $[t^{\prime },t)$ 内做了 $m(t-t^{\prime })$ 的工作，来自两类 job：

• $t^{\prime }$ 之后开始的 job：由 (F)，它们在 $t^{\prime }$ 之后才释放，OPT 也必须在 $t^{\prime }$ 之后做；
• $j\in C$：OPT 最早从 $r_j$ 开始做它，$t^{\prime }$ 之前至多做 $t^{\prime }-r_j$，所以 $t^{\prime }$ 之后至少还要做 $p_j-(t^{\prime }-r_j)=(s_j+p_j-t^{\prime })-d_j,$ 而 $s_j+p_j-t^{\prime }$ 不小于 ALG 在 $[t^{\prime },t)$ 内对 $j$ 做的工作。

所以 OPT 在 $t^{\prime }$ 之后的工作量 $\ge m(t-t^{\prime })-(m-1)\delta$，摊到 $m$ 台机器上：$\mathrm{OPT}\ge t^{\prime }+(t-t^{\prime })-\frac{m-1}{m}\delta \ge t-\delta$。

(ii) $\mathrm{OPT}\ge t-t^{\prime }+\delta$。最受延迟的 job 在 $[r_j,s_j)$ 内一直等待，这段时间所有机器都忙，ALG 做了 $m\delta$ 的工作；这段时间在 $t^{\prime }$ 之前，与 $[t^{\prime },t)$ 不相交。总工作量 $\ge m\delta +m(t-t^{\prime })$，由效率界得到 (ii)。

两式相加：$2\mathrm{OPT}\ge 2t-t^{\prime }$。

断言 A 的意思是：空闲会让 $t$ 超过 OPT，但超出部分至多是 $\frac{t^{\prime }}{2}$。直观上，$t^{\prime }$ 前的空闲说明 OPT 在 $t^{\prime }$ 之前也”没多少事可做”，而 $t^{\prime }$ 之后 ALG 一直忙；唯一能让 OPT 提前做掉的，是那些在 ALG 中被延迟、跨过 $t^{\prime }$ 的 job，而延迟本身又意味着 $t^{\prime }$ 之前有一段全忙的时间。两种情况此消彼长，取平均得到 $\frac{t^{\prime }}{2}$。

断言 B 的证明

反设 $p_n>\frac{1}{2}(\mathrm{OPT}-t^{\prime })$。引理 2 的 $m$ 个 job 加上 $n$，每个都 $>\frac{1}{2}(\mathrm{OPT}-t^{\prime })$：(a) 型 $\ge p_n$；(b) 型 $>\frac{1}{2}\mathrm{OPT}$。OPT 中必有两个在同一台机器上，设先做 $a$ 后做 $b$，于是 $\mathrm{OPT}\ge r_a+p_a+p_b$。

• 若 $r_a\ge t^{\prime }$：$\mathrm{OPT}\ge t^{\prime }+p_a+p_b>t^{\prime }+(\mathrm{OPT}-t^{\prime })=\mathrm{OPT}$，矛盾。
• 若 $r_a<t^{\prime }$：$n$ 和 (a) 型 job 都在 $t^{\prime }$ 之后开始，由 (F) 它们在 $t^{\prime }$ 之后释放，所以 $a$ 是 (b) 型：在 $t^{\prime }$ 之前开始，贯穿 $[r_n,t)$，$s_a\le t^{\prime }$ 且 $s_a+p_a\ge t$。另一方面 $p_b\ge p_n$（$b$ 是 $n$、(a) 型，或 $>\frac{1}{2}\mathrm{OPT}\ge p_n$ 的 (b) 型）。于是 $s_a-r_a\ge (t-p_a)-(\mathrm{OPT}-p_a-p_b)=t+p_b-\mathrm{OPT}\ge t+p_n-\mathrm{OPT}=\mathrm{ALG}-\mathrm{OPT}>\frac{1}{2}\mathrm{OPT}.$ $a$ 等待了超过 $\frac{1}{2}\mathrm{OPT}$，所以 $[r_a,s_a)$ 内所有机器都忙；$[t^{\prime },t)\supseteq [r_n,t)$ 内也都忙，长度 $>\frac{1}{2}\mathrm{OPT}$（引理 1）。两段不相交（$s_a\le t^{\prime }$），ALG 的总工作量 $>m\cdot \mathrm{OPT}$，与效率界矛盾。

Remark

讲义第 73 页由 $r_a+p_a+p_b\le \mathrm{OPT}$、$s_a+p_a+p_n\ge 1.5\mathrm{OPT}$、$p_b>p_n$ 推出的应是 $s_a-r_a>0.5\mathrm{OPT}$（两式相减），页面上写成了"$\le$"。后续”两块忙碌区域各 $>0.5\mathrm{OPT}$ → 矛盾”用的正是"$>$"。讲义还引入了 $t^{\prime \prime }$（最后一个空闲区间的开始）来说明 $s_a\le t^{\prime \prime }$；上面的证明只需要 $s_a\le t^{\prime }$，所以省去了。

思路：LPT 的 1.5 从哪里来

$\mathrm{ALG}=t+p_n$，把 $t$ 和 $p_n$ 分别和 OPT 比较：

• 若 $p_n$ 大（$>\frac{1}{2}\mathrm{OPT}$）：$n$ 等了很久，等待期间每台机器都被一个”不比 $n$ 短”或”比等待时间还长”的 job 占着，凑出 $m+1$ 个大 job，组合界矛盾。
• 若 $p_n$ 小：本来只要 $t\le \mathrm{OPT}$ 就完了，但空闲会破坏效率界。于是用最后一次空闲的结束时刻 $t^{\prime }$ 把两边都改进一点：$t$ 至多多出 $\frac{t^{\prime }}{2}$（断言 A），$p_n$ 至多 $\frac{\mathrm{OPT}-t^{\prime }}{2}$（断言 B，还是组合界，只是只看 $t^{\prime }$ 之后）。$t^{\prime }$ 在两式中正好抵消。

4.5 下界：$m=2$ 时不能好于 $1.382$

先试老办法。时刻 $0$ 来两个大小为 $1$ 的 job，想说”算法只有两种选择”。但实时模型下这不成立：算法还可以等待（选择 C）。若在等待期间对手放出一个大小为 $2$ 的 job，算法就先做它，对手占不到便宜；若对手一直不放，等待本身又增加了 ALG 的代价。对手必须根据算法何时开始来出招，需要一个带参数的构造。

新构造（参数 $\alpha \in (0,\frac{1}{2})$ 待定，目标是证明竞争比 $\ge 1+\alpha$）：

1. 时刻 $0$ 释放 $p_1=1$。设 ALG 在时刻 $x$ 开始它。若 $x\ge \alpha$，不再释放任何 job，$\mathrm{ALG}\ge 1+\alpha$，$\mathrm{OPT}=1$，完成。下面设 $x<\alpha$。
2. 时刻 $x$ 释放 $p_2=\frac{\alpha }{1-\alpha }$。设 ALG 在时刻 $y\ge x$ 开始 $p_2$。令 $\tau =x+1-p_2$。

情形 1：$y\le \tau$（$p_2$ 开始得早）。在时刻 $y$ 释放 $p_3=1+p_2-y$。

• OPT：一台机器做 $p_1$ 再做 $p_2$，在 $1+p_2$ 完工；另一台从 $y$ 起做 $p_3$，同样在 $1+p_2$ 完工。$\mathrm{OPT}\le 1+p_2=\frac{1}{1-\alpha }$。
• ALG：时刻 $y$ 两台机器都在忙（$p_1$ 做到 $x+1$，$p_2$ 做到 $y+p_2\le x+1$），$p_3$ 至早在 $y+p_2$ 开始： $\mathrm{ALG}\ge y+p_2+p_3=1+2p_2=\frac{1+\alpha }{1-\alpha }\ge (1+\alpha )\mathrm{OPT}.$

情形 2：$y>\tau$（$p_2$ 开始得晚）。在时刻 $\tau$（此时 ALG 还没开始 $p_2$）释放 $p_3=1-p_2-x$。

• OPT：一台机器从 $0$ 做 $p_1$；另一台从 $x$ 做 $p_2$ 再做 $p_3$，在 $x+p_2+p_3=1$ 完工。需要 $p_3$ 的释放时刻 $\tau \le x+p_2$，即 $p_2\ge \frac{1}{2}$；取下面的 $\alpha \approx 0.382$ 时 $p_2\approx 0.618$，成立。所以 $\mathrm{OPT}=1$。
• ALG：时刻 $\tau$ 时 $p_2,p_3$ 都未开始，$p_1$ 占着一台机器到 $x+1$。要么 $p_2,p_3$ 都放在另一台机器，完工 $\ge \tau +p_2+p_3=x+1+p_3$；要么其中一个排在 $p_1$ 之后，完工 $\ge x+1+\min (p_2,p_3)=x+1+p_3$。所以 $\mathrm{ALG}\ge x+1+p_3=2-p_2=\frac{2-3\alpha }{1-\alpha }.$

选 $\alpha$：让情形 2 的比值也等于 $1+\alpha$： $\frac{2-3\alpha }{1-\alpha }=1+\alpha ⟺{\alpha }^2-3\alpha +1=0⟺\alpha =\frac{3\pm \sqrt{5}}{2}.$ 所有 job 大小必须为正（$p_3=1-p_2-x>0$ 需要 $p_2<1$，即 $\alpha <\frac{1}{2}$），只能取 $\alpha =\frac{3-\sqrt{5}}{2}\approx 0.382$。此时 $p_2=\frac{\alpha }{1-\alpha }=\frac{\sqrt{5}-1}{2}\approx 0.618$，并且情形 2 中 $p_3>0$ 恰好等价于 $x<\alpha$，与第 1 步一致。

图中，蓝线是 ALG 早开始 $p_2$ 时被迫的比值，橙线是晚开始时的比值。ALG 可以选择落在哪种情形，所以对手能保证的是两者中较小的那个；它在两线交点处最大。

定理：实时到达、 $m=2$ 时，任何确定性在线算法的竞争比 $\ge 1+\alpha =\frac{5-\sqrt{5}}{2}\approx 1.382$

4.6 更多结果

• 任何确定性在线算法，$m\ge 3$ 时竞争比 $\ge 1.3473$（Chen & Vestjens 1996）。
• $m=2$ 时，SLEEPY 算法达到 $1.382$，与下界匹配（Noga & Seiden 1999）。
• 公开问题：一般 $m$ 时能否击败在线 LPT 的 $1.5$（讲者称是进行中的项目）。

5. 列表到达 + 相关机器

5.1 模型与已知结果

回到列表到达（立即且不可撤销地分配）。机器 $i$ 有速度 $s_i$，job $j$ 在其上的处理时间为 $p_j/s_i$。机器按速度降序编号：$s_1\ge s_2\ge \cdots \ge s_m$。

类型	区间	代表结果
确定性	$[2.56,5.82]$	上界 $8$（Aspnes et al. 1993）、$5.82$（Berman et al. 2000）；下界 $2.56$（Ebenlendr & Sgall 2012）
随机	$[2,4.311]$	上界 $4.311$（Berman et al. 2000）；下界 $2$（Epstein & Sgall 2000）

单 job 下界变为：$\mathrm{OPT}\ge p_j/s_1$（放在最快的机器上也要这么久）。效率界变为：$\mathrm{OPT}\ge {\sum }_j{p}_j/{\sum }_i{s}_i$。

5.2 Greedy 不再好用

“放到当前负载最小的机器”忽略了速度。$s_1=1000$，$s_2=1$，来一个大小为 $1$ 的 job：两台机器负载都是 $0$，Greedy 可能把它放到慢机器上，$\mathrm{ALG}=1$，而 $\mathrm{OPT}=0.001$。

定义：改进的 Greedy（看完工后的负载）

把 job $j$ 放到使 $L(i)+\frac{p_j}{s_i}$ 最小的机器 $i$ 上，$L(i)$ 为机器 $i$ 当前的负载（总处理时间）。

它解决了上面的例子。它有多好？

5.3 改进的 Greedy 是 $O(\log m)$-competitive

从最后时刻出发。设 makespan 由机器 $h$ 决定，$j$ 是放到 $h$ 上的最后一个 job，于是 $\mathrm{ALG}=L_{\text{前}}(h)+p_j/s_h$。Greedy 没有把 $j$ 放到机器 $i$，所以

$$\mathrm{ALG}\le L(i)+\frac{p_j}{s_i}\text{对每台机器 }i.$$

对最快的机器，$p_j/s_1\le \mathrm{OPT}$，所以 $L(1)\ge \mathrm{ALG}-\mathrm{OPT}$。对较慢的机器只能得到 $L(i)\ge \mathrm{ALG}-\mathrm{OPT}\cdot \frac{s_1}{s_i}$，速度越慢下界越差。

若所有机器的负载都接近 ALG，效率界就会给出矛盾。问题是：要有多少台机器负载接近 ALG？

• 若只知道快机器的负载大，而 $s_i\approx s_1$ 的机器只有 $\sqrt{m}$ 台：即使这些机器的负载都 $\ge \sqrt{m}\cdot \mathrm{OPT}$，总量也只有 $m\cdot \mathrm{OPT}$，OPT 可以把工作分给所有 $m$ 台机器，没有矛盾。所以必须对大部分处理能力都给出负载下界。
• 想要的图景是：速度每减半，负载下界只损失一个常数倍的 OPT。速度跨越 $s_1$ 到 $s_1/m$ 共 $\log m$ 个量级，总损失 $O(\log m)\cdot \mathrm{OPT}$。

引理 1：速度减半，负载下界只损失 $4\mathrm{OPT}$

若所有 $s_i\ge x$ 的机器都满足 $L(i)\ge \ell$，则所有 $s_i\ge \frac{x}{2}$ 的机器都满足 $L(i)\ge \ell -4\mathrm{OPT}$。

证明

不妨设 $\ell \ge 2\mathrm{OPT}$（否则结论平凡）。令 $F=\{i:s_i\ge x\}$。考虑 ALG 放在 $F$ 中机器上、并且完工位置高于 $\ell -2\mathrm{OPT}$ 的 job。在每台 $h\in F$ 上，它们覆盖了负载区间 $[\ell -2\mathrm{OPT},L(h)]$，长度 $\ge 2\mathrm{OPT}$，所以总大小 $\ge 2\mathrm{OPT}\cdot s_h$。对 $F$ 求和，这些 job 的总大小 $\ge 2\mathrm{OPT}{\sum }_{h\in F}{s}_h$，而 OPT 在 $F$ 上至多能处理 $\mathrm{OPT}{\sum }_{h\in F}{s}_h$。所以其中某个 job $j$ 被 OPT 放在了 $F$ 之外、速度 $s_{i^{\prime }}<x$ 的机器上，于是 $p_j\le \mathrm{OPT}\cdot s_{i^{\prime }}<\mathrm{OPT}\cdot x$。

对任何 $s_i\ge \frac{x}{2}$ 的机器 $i$，$\frac{p_j}{s_i}<2\mathrm{OPT}$。ALG 放 $j$ 时选了 $F$ 中的某台 $h$ 而不是 $i$，所以 $\ell -2\mathrm{OPT}<(j\text{ 在 }h\text{ 上的完工位置})\le L_{\text{当时}}(i)+\frac{p_j}{s_i}<L(i)+2\mathrm{OPT}.$ 即 $L(i)>\ell -4\mathrm{OPT}$。

引理 2：对所有 $s_i\ge s_1/m$，$L(i)\ge \mathrm{ALG}-(4\lceil {\log }_{2}m\rceil +1)\mathrm{OPT}$

证明

起点：所有 $s_i=s_1$ 的机器满足 $L(i)\ge \mathrm{ALG}-\mathrm{OPT}$（上面”最后时刻”的论证）。用引理 1 把 $x$ 依次取 $s_1,\frac{s_1}{2},\frac{s_1}{4},\dots$，每次损失 $4\mathrm{OPT}$，经过 $\lceil {\log }_{2}m\rceil$ 次覆盖所有 $s_i\ge s_1/m$ 的机器。

定理：改进的 Greedy 是 $O(\log m)$-competitive

证明

设 $F^{\ast }=\{i:s_i\ge s_1/m\}$。若 $\mathrm{ALG}>(4\lceil {\log }_{2}m\rceil +3)\mathrm{OPT}$，由引理 2，$F^{\ast }$ 中每台机器的负载都 $>2\mathrm{OPT}$，所以 job 总大小 $>2\mathrm{OPT}{\sum }_{i\in F^{\ast }}{s}_i$。

另一方面，OPT 的总处理能力为 $\mathrm{OPT}{\sum }_i{s}_i\le \mathrm{OPT}{\sum }_{i\in F^{\ast }}{s}_i+\mathrm{OPT}\cdot m\cdot \frac{s_1}{m}\le 2\mathrm{OPT}{\sum }_{i\in F^{\ast }}{s}_i,$ 其中慢机器（$s_i<s_1/m$）至多 $m$ 台，总速度 $<s_1$，而 $s_1$ 本身就在 $F^{\ast }$ 中。OPT 处理不完所有 job，矛盾。所以 $\mathrm{ALG}\le (4\lceil {\log }_{2}m\rceil +3)\mathrm{OPT}$。

5.4 分析是紧的

能否真的构造出”速度每减半，负载就减少一个常数”的局面？构造 $k$ 层机器：

• 第 $i$ 层有 $n_i$ 台速度 $s_i=2^{-(i-1)}$ 的机器，$n_1=1$，并让每层的总速度等于比它快的所有层的总速度之和：$n_i{s}_i={\sum }_{j<i}{n}_j{s}_j$。于是 $n_2=2$，$i\ge 3$ 时 $n_i{s}_i=2n_{i-1}{s}_{i-1}$，即 $n_i=4n_{i-1}$，$n_i=2\cdot 4^{i-2}$，$m=\Theta (4^k)$，$k=\Theta (\log m)$。
• 第 $i$ 层对应 $n_i$ 个大小为 $s_i$ 的 job，每个在本层机器上恰好用时 $1$，所以 $\mathrm{OPT}=1$。
• 到达顺序：最小的（第 $k$ 层的）job 先来，第 $1$ 层的 job 最后来。

ALG 的表现（平局时偏向快机器，也可以对 job 大小做微小扰动来消除平局）：

• 第 $k$ 层的 job 先到。放在更快的机器上完工更早，于是它们把第 $1,\dots ,k-1$ 层的机器都填到负载 $1$。它们的总大小 $n_k{s}_k$ 恰好等于这些机器的总速度，正好填满。
• 第 $k-1$ 层的 job 到来：放在本层机器上完工于 $1+1=2$；放在第 $1,\dots ,k-2$ 层的机器上，完工也不超过 $2$。于是它们把这些机器填到负载 $2$。
• 依此类推，每一批 job 把所有更快的机器再抬高 $1$。第 $2$ 层的 job 处理完后，机器 $1$ 的负载为 $k-1$。

所以 $\mathrm{ALG}\ge k-1=\Theta (\log m)$，而 $\mathrm{OPT}=1$。问题出在 Greedy 太快地使用快机器：快机器被小 job 占满，真正需要它的大 job 来了却没有位置。

5.5 Slow fit：知道 OPT 时 2-competitive

能达到常数吗？平衡在于：

• 太快：把太多 job 放在最快的机器上（上面的坏例子）；
• 太慢：把太大的 job 放在慢机器上（5.2 的坏例子）。

需要定义”合理的慢”。先假设知道 OPT 的值。

定义：Slow fit

称机器 $i$ 对 job $j$ 可行，若 $L(i)+\frac{p_j}{s_i}\le 2\mathrm{OPT}$。把 $j$ 放到最慢的可行机器上（速度相同时取编号最大的）。

只要每次都有可行机器，所有负载就 $\le 2\mathrm{OPT}$，slow fit 是 $2$-competitive。因为 $p_j/s_1\le \mathrm{OPT}$，只需证明最快的机器始终满足 $L(1)\le \mathrm{OPT}$，它就始终可行。

引理：slow fit 运行中始终有 $L(1)\le \mathrm{OPT}$

证明

反设某时刻 $L(1)>\mathrm{OPT}$。对 $r$ 归纳证明此刻 $L(1),\dots ,L(r)$ 都 $>\mathrm{OPT}$，到 $r=m$ 时得到矛盾。

设 $L(1),\dots ,L(r)>\mathrm{OPT}$。ALG 放在机器 $1,\dots ,r$ 上的 job 总大小 $>\mathrm{OPT}{\sum }_{i\le r}{s}_i$，而 OPT 在这些机器上至多处理 $\mathrm{OPT}{\sum }_{i\le r}{s}_i$。所以其中某个 job $j$（ALG 放在某台 $q\le r$ 上）被 OPT 放在了某台 $i^{\prime }>r$ 上，于是 $\frac{p_j}{s_{r+1}}\le \frac{p_j}{s_{i^{\prime }}}\le \mathrm{OPT}.$ slow fit 选的是最慢的可行机器，却选了比 $r+1$ 快的 $q$，说明当时机器 $r+1$ 不可行：$L_{\text{当时}}(r+1)+\frac{p_j}{s_{r+1}}>2\mathrm{OPT}$，所以 $L(r+1)\ge L_{\text{当时}}(r+1)>\mathrm{OPT}$。

当 $r=m$ 时，所有机器的负载都 $>\mathrm{OPT}$，job 总大小 $>\mathrm{OPT}{\sum }_i{s}_i$，OPT 无法完成，矛盾。

5.6 不知道 OPT：Doubling

定义：Slow fit + doubling

• 初始猜测 $L_0=p_1/s_1$（$\le \mathrm{OPT}$）。
• 第 $t$ 阶段：以 $L_t$ 代替 OPT 运行 slow fit，可行性只计算本阶段放入的 job 的负载：$L^{(t)}(i)+\frac{p_j}{s_i}\le 2L_t$。
• 若某个 job 找不到可行机器，令 $L_{t+1}=2L_t$，开始新阶段（负载计数清零，该 job 在新阶段重新放）。

定理：slow fit + doubling 是 $8$-competitive（Aspnes et al. 1993）

证明

上面引理的证明只用到”所有 job 能在 $L_t$ 时间内完成”，所以只要猜测 $L_t\ge \mathrm{OPT}$，该阶段就不会失败。设最后阶段为 $k$：若 $k\ge 1$，第 $k-1$ 阶段失败说明 $L_{k-1}<\mathrm{OPT}$，所以 $L_k<2\mathrm{OPT}$；若 $k=0$，$L_0\le \mathrm{OPT}$。

第 $t$ 阶段给每台机器增加的负载 $\le 2L_t$，所以 $\mathrm{ALG}\le 2L_0+2L_1+\cdots +2L_k\le 2L_k\left(1+\frac{1}{2}+\frac{1}{4}+\cdots \right)\le 4L_k\le 8\mathrm{OPT}.$

这与 Lecture 1 线搜索的翻倍一样：几何级数的和被最后一项控制，代价只多一个常数倍。

思路：从 $\log m$ 到常数，改的是什么

改进的 Greedy 只看”放在哪里完工最早”，于是快机器总被小 job 占满。紧例子正是利用这一点：每来一批小 job，就把所有更快的机器抬高一层，共 $\log m$ 层。

Slow fit 反过来：在不超过 $2\mathrm{OPT}$ 的前提下尽量用慢机器，把快机器留给只有快机器才能及时处理的大 job。证明的核心是”快机器不会被占满”：若机器 $1$ 超过 OPT，那么一定有某个 job 本可以放在更慢的机器上（OPT 就是这么放的），slow fit 没放，只能是因为那台慢机器也超过了 OPT；如此一路推到所有机器都超过 OPT，与效率界矛盾。

6. 列表到达 + 不相关机器

6.1 模型

定义：不相关机器

job $j$ 在机器 $i$ 上的处理时间 $p_{ij}$ 任意（可以是 $\infty$），$L(i)={\sum }_{j\in J(i)}{p}_{ij}$，目标仍是 ${\max }_{i}L(i)$。

两个典型特例：

• 相关机器：$p_{ij}=p_j/s_i$。
• 受限机器（restricted assignment）：$p_{ij}\in \{p_j,\infty \}$，每个 job 只能放在部分机器上。更特殊的是 one-infinity：$p_{ij}\in \{1,\infty \}$，即单位 job 加上可用机器的限制。

即使是 one-infinity 也已经很难：竞争比必须是 $\Omega (\log m)$。

6.2 下界 $\Omega (\log m)$

构造：每轮淘汰一半机器

设 $m$ 为 $2$ 的幂。第 $i$ 轮开始时有 $M=m/2^{i-1}$ 台”存活”机器，来 $M/2$ 个单位 job，每个都可以放在任意一台存活机器上。ALG 分配完后，对手淘汰一半存活机器，保留总负载较大的一半。共进行 ${\log }_{2}m$ 轮。

OPT $=1$：每一轮的 $M/2$ 个 job 恰好放到这一轮被淘汰的 $M/2$ 台机器上，每台一个。被淘汰的机器以后不再可用，所以不会冲突。

ALG 很大：设一轮开始前存活机器的平均负载为 $A$，这一轮后总负载为 $AM+M/2$。保留的一半总负载至少是一半：

$$A_{\text{next}}\ge \frac{\frac{1}{2}(AM+M/2)}{M/2}=A+\frac{1}{2}.$$

${\log }_{2}m$ 轮后只剩一台机器，负载 $\ge \frac{1}{2}{\log }_{2}m$。

定理：one-infinity 情形下，任何确定性在线算法的竞争比 $\ge \frac{1}{2}{\log }_{2}m$

随机算法也一样：由 Yao 原理，改为每轮淘汰均匀随机的一半存活机器。对任何确定性算法，随机一半的总负载期望恰好是一半，$\mathbb{E}[A_{\text{next}}\mid A]=A+\frac{1}{2}$；而每个输入上都有 $\mathrm{OPT}=1$。所以 $\frac{\mathbb{E}[\mathrm{ALG}]}{\mathbb{E}[\mathrm{OPT}]}\ge \frac{1}{2}{\log }_{2}m$，随机算法也是 $\Omega (\log m)$。

6.3 受限机器：Greedy 达到 $O(\log m)$

定义：Greedy（受限机器）

把 job 放到当前负载最小的可行机器（$p_{ij}<\infty$）上。

下面对 one-infinity 证明（单位 job，OPT 为整数）。

分层：把负载按 OPT 切成层，第 $i$ 层是高度 $((i-1)\mathrm{OPT},i\cdot \mathrm{OPT}]$ 的部分，每台机器每层至多放 $\mathrm{OPT}$ 个 job。记

• $J_i$：第 $i$ 层的 job 数；
• $R_i$：第 $i$ 层之上的 job 数，$R_{i-1}=J_i+R_i$，$R_0$ 是 job 总数。

引理： $J_i\ge R_i$，因此 $R_i\le \frac{1}{2}{R}_{i-1}$

证明

取一个在第 $i$ 层之上的 job，它在 ALG 中放入前所在机器的负载 $\ge i\cdot \mathrm{OPT}$；Greedy 选的是可行机器中负载最小的，所以当时它的所有可行机器负载都 $\ge i\cdot \mathrm{OPT}$，第 $i$ 层都已放满 $\mathrm{OPT}$ 个 job。特别地，OPT 给它安排的机器第 $i$ 层是满的。

OPT 的每台机器至多承接 $\mathrm{OPT}$ 个 job，所以这 $R_i$ 个 job 在 OPT 中至少分布在 $R_i/\mathrm{OPT}$ 台不同的机器上，每台在 ALG 中第 $i$ 层都有 $\mathrm{OPT}$ 个 job。所以 $J_i\ge \frac{R_i}{\mathrm{OPT}}\cdot \mathrm{OPT}=R_i$，从而 $R_{i-1}=J_i+R_i\ge 2R_i$。

定理：Greedy 对受限机器是 $O(\log m)$-competitive

证明

若 ALG 超过 $L\cdot \mathrm{OPT}$，则 $R_L\ge 1$；由引理的论证，第 $L$ 层有一台机器是满的，$R_{L-1}\ge J_L\ge \mathrm{OPT}$。而 $R_{L-1}\le R_0/2^{L-1}\le m\cdot \mathrm{OPT}/2^{L-1}$，所以 $2^{L-1}\le m$，即 $L\le {\log }_{2}m+1$。所以 $\mathrm{ALG}\le ({\log }_{2}m+2)\mathrm{OPT}$。

与 6.2 的下界一起，受限机器的竞争比是 $\Theta (\log m)$（Azar, Naor & Rom 1992）。

6.4 一般不相关机器：Greedy 很差

“放到完工后负载最小的机器”在一般情形下只有 $m-1$：

• job $1$：$p_{11}=1+ϵ$，$p_{21}=1$。Greedy 放到机器 $2$（负载 $1$）。
• job $2$：$p_{22}=1+ϵ$，$p_{32}=2$。放到机器 $2$ 会到 $2+ϵ$，Greedy 放到机器 $3$（负载 $2$）。
• job $j$：$p_{jj}=1+ϵ$，$p_{j+1,j}=j$。机器 $j$ 已有负载 $j-1$，Greedy 放到空的机器 $j+1$（负载 $j$）。

最终机器 $m$ 负载为 $m-1$，而 OPT 把 job $j$ 放在机器 $j$ 上，$\mathrm{OPT}=1+ϵ$。竞争比 $\ge m-1$。

问题在于 Greedy 只顾平衡，不顾”这台机器是否适合这个 job”：每个 job 都放在了比最合适的机器慢得多的机器上，不断累积。

6.5 指数势函数算法

两种贪心各有道理：

• Greedy 1：完工后负载平衡（只看 $L(i)+p_{ij}$）；
• Greedy 2：选最合适的机器（只看 $p_{ij}$ 最小）。

负载接近时应偏向第二条，负载差距大时应偏向第一条。用指数势函数统一二者。归一化使 $\mathrm{OPT}=1$（OPT 未知时用 doubling）。

定义：指数势函数算法（Aspnes et al. 1993）

取 $a>1$，机器 $i$ 的势为 $a^{L(i)}$。job $j$ 到来时，选使势能增量 ${\Delta }_j(i)=a^{L_{j-1}(i)+p_{ij}}-a^{L_{j-1}(i)}=a^{L_{j-1}(i)}\left(a^{p_{ij}}-1\right)$ 最小的机器，$L_{j-1}(i)$ 为放入 job $j$ 前的负载。

${\Delta }_j(i)$ 是两项之积：$a^{L_{j-1}(i)}$ 惩罚已经很高的机器，$a^{p_{ij}}-1$ 惩罚不合适的机器。若改用线性势函数 $L(i)$，增量就是 $p_{ij}$，退化为 Greedy 2。

定理：取 $a=1.5$，$C_{\max }\le {\log }_{1.5}(2m)\cdot \mathrm{OPT}=O(\log m)\cdot \mathrm{OPT}$

证明

记 $i_j$ 为算法给 job $j$ 选的机器，$i_j^{\ast }$ 为 OPT 选的机器，${\Phi }_n={\sum }_i{a}^{L_n(i)}$ 为最终势能。

总增量：按机器分组望远镜求和， ${\sum }_{j=1}^n{\Delta }_j(i_j)={\sum }_{i=1}^m{\sum }_{j:i_j=i}\left(a^{L_j(i)}-a^{L_{j-1}(i)}\right)={\sum }_{i=1}^m\left(a^{L_n(i)}-1\right)={\Phi }_n-m.$

用 OPT 的选择控制每个增量：算法选的是增量最小的机器，负载又只增不减，所以 ${\Delta }_j(i_j)\le {\Delta }_j(i_j^{\ast })=a^{L_{j-1}(i_j^{\ast })}\left(a^{p_{i_j^{\ast }j}}-1\right)\le a^{L_n(i_j^{\ast })}\left(a^{p_{i_j^{\ast }j}}-1\right).$ 对 $j$ 求和，按 OPT 的机器分组： ${\sum }_j{\Delta }_j(i_j)\le {\sum }_{i=1}^m{a}^{L_n(i)}{\sum }_{j:i_j^{\ast }=i}\left(a^{p_{ij}}-1\right).$

用 OPT $=1$：OPT 的每台机器上 ${\sum }_{j:i_j^{\ast }=i}{p}_{ij}\le 1$，每个 $p_{ij}\in [0,1]$。由凸性，$x\in [0,1]$ 时 $a^x-1\le (a-1)x$（弦在凸函数上方），所以内层和 $\le (a-1){\sum }_{j:i_j^{\ast }=i}{p}_{ij}\le a-1$。于是 ${\Phi }_n-m\le (a-1){\Phi }_n.$ 取 $a=1.5$：${\Phi }_n-m\le \frac{1}{2}{\Phi }_n$，即 ${\Phi }_n\le 2m$。每台机器 $a^{L_n(i)}\le {\Phi }_n\le 2m$，所以 $L_n(i)\le {\log }_{1.5}(2m)$。还原到原来的单位即得定理。

思路：为什么用指数势函数

想要的是”${\max }_{i}L(i)$ 小”，但 max 不好逐步分析。$\Phi ={\sum }_i{a}^{L(i)}$ 是 max 的光滑替代：$a^{\max L}\le \Phi \le m\cdot a^{\max L}$，所以只要 $\Phi \le \mathrm{poly}(m)$，就有 $\max L=O(\log m)$。

分析是”和 OPT 逐个 job 比较”：每个 job 的势能增量不超过放到 OPT 那台机器上的增量；后者按 OPT 的机器加起来，每台机器上 OPT 的总处理时间 $\le 1$，所以至多是这台机器势能的 $(a-1)$ 倍。总增量 ${\Phi }_n-m$ 被 $(a-1){\Phi }_n$ 控制，$a$ 取得接近 $1$ 就能把 ${\Phi }_n$ 钳住。$a$ 也不能太接近 $1$：${\log }_{a}m$ 会变大。$a=1.5$ 是一个方便的折中。

7. 小结

模型	本讲的算法	上界	本讲的下界
列表到达 + 相同机器	Greedy；MR	$2-\frac{1}{m}$；$1.9201$	$\frac{3}{2}$（$m=2$）；已知 $1.88$
实时到达 + 相同机器	在线 LPT	$1.5$	$1.382$（$m=2$）
列表到达 + 相关机器	改进的 Greedy；slow fit + doubling	$\Theta (\log m)$；$8$	Greedy 的紧例子 $\Omega (\log m)$
列表到达 + 受限机器	Greedy	${\log }_{2}m+2$	$\frac{1}{2}{\log }_{2}m$（随机也成立）
列表到达 + 不相关机器	指数势函数	${\log }_{1.5}(2m)$	同上

flowchart TD
  P["假设 ALG 很大"] --> E["效率界：工作量太多<br/>OPT ≥ 总工作量 / 总能力"]
  P --> C["组合界：大 job 太多<br/>m+1 个 > OPT/2 的 job"]
  E --> X["矛盾"]
  C --> X
  D["Doubling：去掉“已知 OPT”"] -.-> P
  G["分层：每层损失常数，共 log m 层"] -.-> P

练习

练习 1：MR 中为什么 $p_n$ 必须是按 Greedy 放的

在 MR 的最小反例中，为什么可以断定最后一个 job 被放在机器 $1$ 上？这一步为什么对后面的论证重要？

答：若它被放在 $k+1$，算法当时判定”不危险”：$L(k+1)+p_n<c\cdot \mathrm{Avg}(\mathrm{All})\le c\cdot \mathrm{OPT}$，这台机器的最终负载就不超过 $c\cdot \mathrm{OPT}$，与反例矛盾。放在机器 $1$ 意味着它叠在最低的机器上，开始位置 $s_n$ 是当时的最小负载，于是所有机器的负载都 $\ge s_n$。这是后面”所有机器都满、每台都有 filling job”的出发点，也让效率界给出 $\mathrm{OPT}\ge s_n$。

练习 2：实时模型中 Greedy 的紧例子

实时到达时，Greedy（job 一到就放到当前最闲的机器上并开始）的竞争比是否仍然可以接近 $2$？

答：可以。让所有 job 都在时刻 $0$ 释放，按 1.2 节紧例子的顺序到达：先 $m(m-1)$ 个单位 job，最后一个大小为 $m$ 的 job。Greedy 一到就分配，行为与列表模型完全相同，$\mathrm{ALG}=2m-1$；OPT 不受释放时间限制，仍为 $m$。在线 LPT 则会先做大 job。

练习 3：Slow fit 为什么选"最慢"的可行机器

若改为放到”最快的可行机器”上，5.5 节的引理在哪一步失效？用 5.4 节的例子说明会发生什么。

答：引理的关键一步是”slow fit 选了比 $r+1$ 快的机器，说明 $r+1$ 不可行”。若规则是选最快的可行机器，选快机器不能说明慢机器不可行，链条断裂。在 5.4 节的例子中（取 $\mathrm{OPT}=1$），选最快可行机器会像 Greedy 一样先把小 job 堆到快机器上，直到 $2\mathrm{OPT}$ 的上限；后来的大 job 放在慢机器上太慢，放在快机器上又超限。直接模拟可以验证：层数 $k\ge 4$ 时会出现找不到可行机器的 job，而 slow fit 始终能放下，所有负载都 $\le 2$。选最慢的可行机器，是把快机器的容量留给只有它们才能及时处理的 job。

练习 4： $m$ 不是 $2$ 的幂

6.2 节的下界构造要求 $m$ 是 $2$ 的幂。对一般的 $m$，能得到什么下界？

答：只在其中 $m^{\prime }=2^{\lfloor {\log }_{2}m\rfloor }$ 台机器上运行构造，其余机器对所有 job 都不可用（$p_{ij}=\infty$）。下界为 $\frac{1}{2}\lfloor {\log }_{2}m\rfloor$，仍是 $\Omega (\log m)$。