Greedy Algorithm - Interval Scheduling

Greedy的基本思路

用一个方法在每一个阶段找到最好的决策。在算法终止时，可以得到全局最优解。

问题

Interval Scheduling Problem:

1. a set of request { 1 , 2 , . . . , n } \{1, 2, ..., n\} {1,2,...,n}
2. $i^{th}$ request corresponds to an interval of time with starting at $s_i$ and finishing at $f_i$

基本定义

Compatible: No two of the requests overlap in time.
Optimal: Compatible sets of maximum size.

问题

局部最优选择方法:

1. 选择最早结束的任务 $i$。
2. 删除所有与 $i$ 时间重合的任务 (non-compatible request)。
3. 从剩余的任务中选择结束时间最早的（如此往复，直到没有任务可以选择）。

算法伪代码

令 $R$ 为既没有被 accept 也没有被 reject 的 requests 的集合。
令 $A$ 为被 accept 的 requests 的集合。

1. Initially let $R$ be the set of all requests, and let $A$ be empty
2. While $R$ is not yet empty
3. \quad\quad Choose a request $i\in R$ that has the smallest finishing time
4. \quad\quad Add request $i$ to A
5. \quad\quad Delete all request from $R$ that are not compatible with request $i$
6. EndWhile
7. Return the set $A$

定理

证明思路：
令 $\mathcal{O}$ 为 optimal set of interval （最优解集）
令 A = { i 1 , i 2 , . . . , i k } A=\{ i_1, i_2, ..., i_k\} A={i1​,i2​,...,ik​}
令 O = { j 1 , j 2 , . . . , j m } \mathcal{O}=\{ j_1, j_2, ..., j_m\} O={j1​,j2​,...,jm​}

WTS: $|A|=|\mathcal{O}|$, 即 $k=m$
在前半部分 $A$ 与 $\mathcal{O}$ 一样，但是后面 $A$ 每一步更好

定理1：$A$ is a compatible set of request.

定理2: For all indices $r\le k$, we have $f(i_r)\le f(j_r)$.
证明：（归纳法）
$r=1:i_1$ has the minimum finishing time， 所以一定有 $f(i_1)\le f(j_1)$
假设 $f(i_{r-1})\le f(j_{r-1})$
因为 $\mathcal{O}$ 是 compatible set, $f(j_{r-1})<s(j_r)$
$\therefore$ $f(i_{r-1})<s(j_r)$
因此 request $i_{r-1}$ 和 request $j_r$ 的时间不重叠，即 $j_r\in R$
$\because$ Greedy Algorithm 选择 $f$ 最小的 available interval 且 $j_r\in R$
$\therefore$ $f(i_r)\le f(j_r)$

定理2表明了 Greedy Algorithm remains ahead of $\mathcal{O}$

定理3: The greedy algorithm returns an optimal set $A$.
证明：（反证法）
若 $A$ 不是最优的，那么 $|\mathcal{O}|>|A|$, 即 $m>k$.
由定理2，当 $r=k$时，$f(i_k)\le f(j_k)$。
$\because m>k$
$\therefore$ $j_{k+1}\in \mathcal{O}$
$j_{k+1}$ 在 $j_k$ 结束之后才开始，因此 $j_{k+1}$ 也是在 $i_k$ 结束之后才开始的，即 $j_{k+1}\in R$
但是我们假设贪婪算法在 $i_k$ 之后就结束了，矛盾

Implementation

Run-time: $O(n\log n)$

1. sort the requests in order of finishing time and label them, i.e., $f(i)<f(j)$ when $i<j$. $O(n\log n)$
2. Construct and array $S[1...n]$ ($S[i]=s(i)$). $O(n)$
3. 选择 finishing time 最小的，然后按顺序查找一个 $s(j)\ge f(1)$ 的 interval ，并选择它。如此往复。$O(n)$