Simple $k$-crashing Plan with a Good Approximation Ratio

TL;DR

This paper analyzes two greedy problems in combinatorial optimization: k-crashing on activity-on-edge networks and k-LIS on sequences. For k-crashing, it proves that repeatedly shortening by one day with minimum-cost 1-crashing steps yields a total-cost approximation of $\sum_{i=1}^{k} \frac{1}{i}$ relative to the optimum, using a cut-based decomposition of the critical graph. For k-LIS, it shows the greedy approach achieves a $(1-\frac{1}{e})$-approximation, while also exhibiting inputs where the ratio drops toward $0.75$ for any $k\ge 2$, highlighting the limits of greedy methods. The results emphasize the practical appeal and effectiveness of simple greedy algorithms in scheduling and subsequence problems, while also outlining nontrivial proof techniques and inviting future work to achieve constant-factor guarantees for k-crashing. Overall, the work connects classic network-flow insights with modern greedy analysis to derive meaningful performance bounds and practical guidance for project scheduling and sequence optimization.

Abstract

In project management, a project is typically described as an activity-on-edge network (AOE network), where each activity / job is represented as an edge of some network $N$ (which is a DAG). Some jobs must be finished before others can be started, as described by the topology structure of $N$. It is known that job $j_i$ in normal speed would require $b_i$ days to be finished after it is started. Given the network $N$ with the associated edge lengths $b_1,\ldots,b_m$, the duration of the project is determined, which equals the length of the critical path (namely, the longest path) of $N$. To speed up the project (i.e. reduce the duration), the manager can crash a few jobs (namely, reduce the length of the corresponding edges) by investing extra resources into that job. However, the time for completing $j_i$ has a lower bound due to technological limits -- it requires at least $a_i$ days to be completed. Moreover, it is expensive to buy resources. Given $N$ and an integer $k\geq 1$, the $k$-crashing problem asks the minimum amount of resources required to speed up the project by $k$ days. We show a simple and efficient algorithm with an approximation ratio $\frac{1}{1}+\ldots+\frac{1}{k}$ for this problem. We also study a related problem called $k$-LIS, in which we are given a sequence $ω$ of numbers and we aim to find $k$ disjoint increasing subsequence of $ω$ with the largest total length. We show a $(1-\frac{1}{e})$-approximation algorithm which is simple and efficient.

Figures (5)

• Figure 1: An example of the construction of $N_i,X_i,C_i$.
• Figure 2: Example of the definition of $S_i$, $T_i$, $RC_i$ and $C_i$
• Figure 3: Key notation used in the proof of Lemma \ref{['lem:cost_i']}.
• Figure 5: Construction of $P'$ in the proof of Proposition \ref{['prop:contain cut']} part 2.
• Figure 6: An example with 5 jobs. The parameters $a_i,b_i,c_i$ of job $j_i$ are shown as a label $i:[a_i, b_i](c_i)$ in the graph. The source $s$ equals 1, whereas the sink $t$ equals 4.

Theorems & Definitions (10)

• theorem 1
• lemma 1
• proposition 1
• proposition 2
• lemma 2
• proposition 3
• proposition 4
• lemma 3
• theorem 2
• lemma 4