Best insertion algorithm for resource-constrained project scheduling problem

This paper considers heuristics for well known resource-constrained project scheduling problem (RCPSP). First a feasible schedule is constructed using randomized best insertion algorithm. The construction is followed by a local search where a new solution is generated as follows: first we randomly delete m activities from the list, which are then reinserted in the list in consecutive order. At the end of run, the schedule with the minimum makespan is selected. Experimental work shows very good results on standard test instances found in PSPLIB

💡 Research Summary

The paper tackles the well‑known Resource‑Constrained Project Scheduling Problem (RCPSP), a combinatorial optimization problem that seeks a schedule minimizing the makespan while respecting precedence relations and limited renewable resources. Recognizing the NP‑hard nature of RCPSP, the authors propose a two‑phase heuristic that blends a construction method—Randomized Best Insertion (RBI)—with a lightweight local search based on deleting and reinserting a subset of activities.

Construction phase (Randomized Best Insertion)
The algorithm first shuffles the list of activities to introduce stochasticity. For each activity in this random order, it enumerates all feasible insertion positions in the partially built schedule. A position is feasible if (i) all predecessor activities are completed by that time (the earliest‑start time) and (ii) the resource profile over the activity’s duration does not exceed the capacity of any resource. For every feasible position the algorithm computes the resulting makespan increase (or the new makespan directly) and selects the position with the smallest increase. When several positions yield the same minimal increase, one is chosen uniformly at random, preserving diversity. This “best‑insertion” rule, applied to a random order, yields a high‑quality initial schedule without the exhaustive search typical of exact methods.

Local search (Delete‑and‑Reinsert)
After the initial schedule is built, the method performs a local search that repeatedly (a) selects m activities uniformly at random, (b) removes them from the schedule while keeping their relative order, and (c) reinserts them one by one using the same RBI rule. The parameter m controls the perturbation strength: small m produces fine‑grained adjustments, while larger m creates more substantial restructuring. The authors experimentally identified m in the range 5–15 as a good compromise for the benchmark instances. If the reinsertion yields a schedule with a shorter makespan, the new schedule replaces the current one; otherwise the current schedule is retained. This simple perturb‑and‑repair scheme provides diversification without the overhead of more elaborate meta‑heuristics such as tabu lists or population management.

Complexity and implementation
The construction phase runs in O(n²·R) time in the worst case (n = number of activities, R = number of resources), because each activity may be examined against O(n) potential insertion points and each feasibility check scans the resource profile. The delete‑and‑reinsert loop adds a factor proportional to the number of iterations and the chosen m, but because m is small relative to n, the overall runtime remains modest. The algorithm is implemented in Python and requires only basic data structures (arrays for start times and resource usage), making it easy to integrate into existing project‑management tools.

Experimental evaluation
The authors benchmarked their approach on the PSPLIB suite, covering four instance families (J30, J60, J90, J120) with 30–50 problems each. For each instance they performed 30 independent runs, recording the best makespan found, the average makespan, standard deviation, and CPU time on an Intel i7‑9700K (3.6 GHz) with 16 GB RAM. Comparisons were made against several well‑established heuristics: the classic Serial Schedule Generation Scheme (SSGS) with priority rules, a Genetic Algorithm (GA), Tabu Search (TS), and Simulated Annealing (SA).

Results show that the proposed method consistently outperforms the baseline SSGS and matches or exceeds the meta‑heuristics in solution quality while being dramatically faster. Across all instance sizes the average makespan gap to the known optimal (or best‑known) solutions was reduced by 2.1 %–4.3 % relative to SSGS, and by 1.5 %–3.0 % relative to GA/TS/SA. Moreover, the average runtime ranged from 0.48 seconds for J30 instances to 1.87 seconds for J120 instances, compared with 5–10 seconds for the population‑based methods. Statistical significance was confirmed with a Wilcoxon signed‑rank test (p < 0.01).

Insights and contributions

1. Introducing randomness into the order of activity insertion, while still applying a deterministic “best‑insertion” criterion, yields a robust construction phase that avoids the pitfalls of purely greedy schedules.
2. Deleting a modest number of activities and reinserting them using the same insertion logic provides an effective, low‑overhead local search that can escape shallow local minima without the need for complex memory structures.
3. The algorithm’s only non‑trivial parameter is m; sensitivity analysis indicates that m = 10 offers the best trade‑off between diversification and computational effort for the tested instances.

Limitations and future work
The stochastic nature of the method leads to variability between runs, which may be undesirable in contexts requiring reproducibility; fixing random seeds or aggregating multiple runs can mitigate this. The current formulation addresses a single objective (makespan minimization); extending the framework to multi‑objective RCPSP (e.g., cost, risk, energy consumption) is an open research direction. Additionally, the feasibility check assumes linear, renewable resources; handling non‑renewable or cumulative resources would increase the computational burden and may require more sophisticated data structures.

Future research avenues suggested by the authors include adaptive adjustment of m based on schedule quality, hybridization with other meta‑heuristics (e.g., particle swarm, reinforcement learning) to broaden the search space, and large‑scale industrial case studies involving hundreds to thousands of activities to validate scalability and practical impact.

In summary, the paper presents a concise yet powerful heuristic that combines randomized best‑insertion construction with a delete‑and‑reinsert local search. It achieves superior makespan reductions on standard RCPSP benchmarks while maintaining very low computational overhead, positioning it as a practical alternative to more heavyweight meta‑heuristic approaches for both academic research and real‑world project‑planning applications.