我们可以利用Induction和交换（减少逆序数）的思路来证明一个Greedy算法是正确的。
我们可以通过Lower Bound来启发得到算法。

1. Introduction to Greedy Algorithms and Scheduling

Def: Scheduling

• Planning Process Over Time
• 使用Unified Language.

第一个问题：Interval Scheduling

有一个n job的集合J，每一个job有一个start time $s_j$和一个end time $t_j$ $\forall j\in J$
Constraint：有一个机器，不能同时处理多个任务
目标函数：max number jobs scheduled

Greedy Algorithms

Builds up a solution iteratively, in each step taking the decision that at that moment looks best (without looking into the future).

Rq:

1. 如果它们正确，则他们既简单又高效
2. 可以用它作为启发式算法的开始。

利用Greedy Alg写Interval Scheduling问题的模版

Initialization: no interval in the solution, all interval available
Iteration:

• While there are intervals available
  • choose the most interesting available interval (前面的例子中就是最短的那个)
  • remove it from the set of available intervals (如果再放回去的话，就会不断地取放这个元素)
  • if it does not overlap with the intervals in the solution,
    • then add it to the solution

利用上面的模版给出问题的算法: Shortest-first

• Solution $S=\varphi$
• for $j\in J$ (J按照长度从小到大排序):
  • 将$j$踢出J
  • if $S\cap j=\varphi$，则将j加入S的集合
• return $S$

但是这个算法只能得到feasible的解，而不能得到optimal的解。
反例：

但最优解是5：

利用上面的模版给出问题的算法: Earliest-First

• Solution $S=\varphi$
• for $j\in J$ (J按照开始时间从小到大排序):
  • 将$j$踢出J
  • if $S\cap j=\varphi$，则将j加入S的集合
• return $S$
  

利用上面的模版给出问题的算法: Earliest-End

• Solution $S=\varphi$
• for $j\in J$ (J按照结束时间从小到大排序):
  • 将$j$踢出J
  • if $S\cap j=\varphi$，则将j加入S的集合
• return $S$
  
  我们可以证明它确实是一个Optimal Solution.

证明 Earliest-End能给出原问题的Optimal Solution:

Lemma 1: (“can’t be wrong to start with the job that ends first”)

我们证明每一个Greedy Decision都不会错。
即: There is an optimal solution that contains the job with earliest end time.

Dem:

• 假设S是一个Optimal的解。
• 令j是S中结束最早的任务，设j开始时间为$s_j$，结束时间为$e_j$。则S中除了j之外的任务结束时间都比它迟，且因为算法，他们开始的时间$s_j^{\prime }$都比$e_j$要大（因为他们和j没有交集）。
• 假设k是所有数据集中结束时间最早的任务，则$s_k<e_k<e_j$，所以将j用k换掉得到的Solution $S^{\prime }$也是原问题的一个最优解，因为两者拥有同样的元素。

Lemma 2: (Exchange Property)

设$j$是一个Optimal Solution中的一个工作
设$J^{\prime }$所有不和$j$冲突的任务的集合，设$S^{\prime }\subseteq J^{\prime }$
则 $S^{\prime }$是$J^{\prime }$中的Optimal Solution $\iff$ { j } ∪ S ′ \{j\} \cup S' { j}∪S′是J中的Optimal Solution

Dem: 见Poly

Thm:

证明：Earliest-End是正确的算法

• 我们根据要安排的工作的集合长度$|J|$运用数学归纳法：
  对于任意的$|J^{\prime }|<|J|$我们都可以通过这个算法给出正确的解。
• 假设j是J中最早停止的工作。
• 记$J^{\prime }$为一个不和$j$重叠的工作的集合，鉴于$|J^{\prime }|<|J|$，根据归纳假设，我们可以得到一个$J^{\prime }$正确的解$S^{\prime }$
• 由Lemma 1，$j$包含在一个$J$的Optimal的解集里面。
• 由Lemma 2，因为$S^{\prime }$是$J^{\prime }$上的最优解，所以 S = { j } ∪ S ′ S=\{j\} \cup S' S={ j}∪S′是一个解。
• 又因为S是我们算法给出的solution，所以我们的算法能给出原问题的Optimal的解。

怎么寻找Greedy Algorithm？

Each greedy decision must be so good that we do not regret it regardless what decisions come next !
A good greedy decision is so profitable that it does not matter what other options it destroys.
A good greedy decision interacts little with other options.

2. 第二个问题:Minimizing the maximum Lateness

Given:

• 一个n个jobs的集合$J$和一个单任务处理的机器。
• 每一个工作包含processing time $p_j$和 deadline $d_j$。

Wanted:
Schedule $S$，
$C_j$：job $j$完成的时刻(completion time)
$L_j$：job $j$的lateness。 L j : = m a x { 0 , C j − d j } L_j := max\{0,C_j-d_j\} Lj​:=max{ 0,Cj​−dj​}
目的:
Minimize the maximum lateness L m a x : = m a x { L j ∣ j ∈ J } L_{max}:=max\{L_j | j \in J\} Lmax​:=max{ Lj​∣j∈J}，即所有人的等待时间都小于$L_{m}ax$。

EDF: Earliest Deadline First

Sort the jobs by increasing deadline and schedule them in this order (without leaving the machine idle). $\Theta$(nlogn)

可以证明： EDF computes a schedule with minimal max-lateness.

证明EDF能给出原问题的Optimal Solution:

红色的虚线是交换前（j=4排在k=3）其时的max lateness，换完之后的lateness是红色的实线。（黑色虚线代表每个任务的ddl）
因此，我们尝试证明

如果存在两个工作$j$和$k$，使得$d_j>d_k$，但是$j$却排在$k$的前面，则交换j和k能改善max lateness

• Dem:
• 记每个工作开始时间为$s$，结束时间为$e$。
• 在交换之前，$e_j=t_1$,$e_k=t_2$，$t_1<t_2$两者的lateness为$e_j-d_j$和$e_k-d_k$，由假设$e_j<e_k,d_k<d_j$，因此$e_j-d_j<e_k-d_k$。所以两者最大的lateness为$e_k-d_k=t_2-d_k$。
• 交换完之后$t_1<t_2$，$e_k=t_1<e_j=t_2,d_k<d_j$。我们注意到
  • lateness j : $e_j-d_j<e_j-d_k=t_1-d_k<t_2-d_k$
  • lateness k: $e_k-d_k<t_1-d_k<t_2-d_k$。
• 因此交换完后两者最大的lateness肯定小于交换之前的lateness。

之后，我们只要证明每一个Schedule都可以通过这个交换的方式得到Optimal Solution。
这个是显然的，因为Optimal Solution下我们没有逆序数，而任何一个非Optimal的序列都可以通过交换得到最后的序列。

Main Proof Argument: Transforming Solutions

3. 第三个问题：Preemptive Makespan Minimization

• preemptive: 抢先的

类似于煎饼问题。
$n$ jobs，每一个工作有一个processing time $p_j$
$m$ parallel identical machines
Preemption (允许抢占):

• 每一个工作可以被拆分成两块到若干个机器上完成
• 但一个工作不可以同时由两个机器执行。
  目的：
  Min makespan $C_{max}:=ma{x}_j{C}_j$取决于最后一个任务才完成的时刻。

例子：

2个Lower Bounds

Lemma 1:
The makespan is at least $\frac{1}{m}{\sum }_{j\in J}{p}_j:=D_1$

Dem: 反证

Lemma 2:
The makespan is at least m a x { p j ∣ j ∈ J } : = D 2 max\{p_j | j\in J\}:=D_2 max{ pj​∣j∈J}:=D2​

Dem:
因为我们即便可以把一个任务拆分开来，但是我们每一个时刻只能完成一部分这个任务（一个时间段只能对应一部分这个任务）。因此，最少需要这个任务的时长$p_j$。

McNaughton’s wrap-around rule:

具体算法描述：

将所有的jobs排成一排，取$D=max{D}_1,D_2$，然后每D一截，就可以得到最后的时间。

• 由Lower Bound定义知道这个算法是Optimal的。
• 可行性：
  • 由$mD>m{D}_1$，所以所有的任务能被安排在$mD$的总时间里面。
  • 由$mD>m{D}_2$，所以不会产生同时有多个机器处理一个任务的情况。

4. 第四个问题：Non-Preemptive Makespan Minimization

$n$ jobs，每一个工作有一个processing time $p_j$
$m$ parallel identical machines
不允许抢占:
目的：
Min makespan $C_{max}:=ma{x}_j{C}_j$取决于最后一个任务才完成的时刻。

一些观察：

1. 什么时候执行任务不再重要，而是在哪个机器上和另外哪些机器形成组合执行任务。（因为不可以抢占，所以交换顺序很方便）
2. 这是一个NP-complete的问题
3. 利用DP可以得到一个$O(nm{P}^{m-1})$的算法，KaTeX parse error: Undefined control sequence: \sun at position 3: P=\̲s̲u̲n̲_{j\in J}p_j

鉴于NP-complete问题不能用Polynomial Time解决，我们尝试使用另外一种解法：

Greedy Approximation Algorithm

如，每次把任务分给最先完成的机器。

Performance of List Scheduling

我们可以证明通过以上的算法得到的$C_{max}^S$
The makespan $C_{max}^S$ of any list scheduling solution $S$ is at most twice the optimal makespan $C_{max}^{\ast }$： $C_{max}^S\le C_{max}^{\ast }$.

Dem:

• 设$j$是见证makespan的工作，在上图的例子中就是(7)。
• 则按照我们的算法，之所以会选择这个Machine安排工作，是因为它最先结束，记机器数量为$m$
• $j$工作开始时刻 $s_j\le \text{average load after j-1 jobs}=\frac{1}{m}{\sum }_{k=1}^{j-1}{p}_k\le D_1$。一种直观的想法是，因为这个Machine最先完成，所以其他机器的Schdule对于此机器而言都是突出来的，这样把它们突出来的部分减下来平均到$m$个机器上，则一定比$s_j$要大。小于等于$D_1$是因为$D_1$定义为j个工作在m个机器上的平均值。
• $C_{max}^S=s_j+p_j\le D_1+D_2\le 2C_{max}^{\ast }$。因为$D_1,D_2$是这个问题的Lower Bound。

Def: rho-approximation algorithm

Let A be an algorithm for a minimization problem,

• A(I): 解法A在instance I上的质量
• OPT(I):I上最优解的质量
• 则A被称为$\rho$-approximation algorithm如果对于任意instance I，我们有$\frac{A(I)}{OPT(I)}\le \rho$

Def: The approximation ratio of an algorithm

The approximation ratio of an algorithm A is the smallest $\rho$ such that A is a $\rho$-approximation algorithm.

Appriximation Ratio of List Scheduling

The approximation ratio of list scheduling is 2.

我们采取构造+极限的方式给出证明
Dem:
考虑m台机器，m个长度为1的工作，m个长度为$\frac{1}{m}$的工作。

• 显然$OPT(I)=C_{max}^{\ast }=1+\frac{1}{m}$，因为它取到了min。
• 如果任务的顺序是1,1,…,$\frac{1}{m}$,…,$\frac{1}{m}$,1，即最后一台机器只做$\frac{1}{m}$的工作。
  此时$LS(I)=C_{max}^S=2$
• $\rho \ge \frac{LS(I)}{OPT(I)}\ge \frac{2}{1+\frac{1}{m}}=2(1-\frac{1}{m+1})$对于任意m成立
  当m趋向正无穷的时候为2。

5. 第五个问题：Better Non-Preemptive Makespan Minimization

由我们在上部分最后的观察可知，如果把最长的工作放在后面，则可能会导致makespan变长，因此我们要尽早schedule长的工作 -> List Scheduling With LTP Rule

List Scheduling With LTP Rule

LPT: Longest Processin time First
具体做法：

• Sort the jobs in order of decreasing process times.
• 用这个递减的顺序做List Scheduling.

Thm:

List Scheduling with LPT rule is a $\frac{4}{3}$ approximation algorithm runs in $O(nlogn)$.

Dem:

• 设$S$是LTP的Schedule，$j$是S中最后完成的工作（而非最后schedle的工作），则由LPT假设，所有工作的processing时间至少为$p_j:=p_{min}$。$s_j$为第j个工作开始的时间
• Case 1: $p_j\le \frac{OPT(I)}{3}$
  • 类似前面的逻辑：$C_{max}^S\le s_j+p_j\le D_1+p_j\le OPT(I)+\frac{OPT(I)}{3}=\frac{4\ast OPT(I)}{3}$
• Case 1: $p_j>\frac{OPT(I)}{3}$
  • 此时我们最佳的solution中的每个机器一定最多完成了2个工作，$n\le 2m$，即有些机器可能只完成了一个工作。否则随便任意三个任务$\sum p_k\ge 3p_j\ge OPT(I)$和$OPT(I)$的定义矛盾。
  • 实际上在这种情况下，我们可以证明我们的解是Optimal的。
  • 假设我们得到的解不是Optimal的，即存在$S^{\prime }$它是更优的解。此时$j$的一定会在$[2m+2-j,2m]$中寻找它的Partner $p\ast$，然而p*的partner $x$会被迫接受一个比$p_{2m+1-j}$更大的元素$p_y$，即$p_x\ge p_j$和$p_y\ge p_{2m+1-j}$
  • 所以$p_x+p_y\ge p_j+p_{2m+1-j}$，换言之，$S^{\prime }$的makespan比S还要长，所以矛盾。S是Solution Optimal。