Abstract
The Capacitated Planned Maintenance Problem (CPMP) schedules maintenance activities that cover a set of periods before they must be executed again and require a maintenance time. This chapter presents specific heuristics because finding a feasible solution is already strongly \(\mathcal{N}\mathcal{P}\)-complete. Three construction heuristics are presented and the obtained initial feasible solution is potentially improved by metaheuristics. Two Lagrangean heuristics are provided that use the Lagrangean relaxations of the period covering constraint and of the capacity constraint. The fundamental difference in the so called pseudo-subgradient optimization is that the Lagrangean relaxation is solved heuristically, whereas many approaches in literature prefer an optimal solution to derive subgradients from. For this purpose new lower and upper bounds to a Lagrangean relaxation are presented. A general, problem independent approach links two Lagrangean relaxations and uses the relations between Benders’ and Lagrangean decomposition. This yields a novel Lagrangean hybrid heuristic. A tabu search heuristic is proposed, which features a multi-state search and an extended objective function.
This is a preview of subscription content, log in via an institution to check access.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Notes
- 1.
The term ‘serial heuristic’ refers to the project planning terminology (Kolisch 1996).
- 2.
This strategy gives the name ‘First Fit Heuristic’.
- 3.
Implementation detail: Use a list to store all open periods.
- 4.
The term ‘parallel heuristic’ refers to the project planning terminology (Kolisch 1996).
- 5.
Implementation detail: An efficient data structure stores only the affected periods. Let a tuple (l, r) represent an interval of periods where the periods l, …, r are affected by the labeled maintenance activity i. From the definition follows a = t ′ + 1 and b = t ′ +π i . Assume that n maintenance activities are labeled. Sort all tuples in an increasing order of values of l in time O(n ⋅ logn) (e.g., use introsort from Footnote 32 on page 63). Given an empty stack of tuples and let (a, b) be the top element of the stack. Insert the first tuple (l, r) in the stack with (a, b) = (l, r). Afterwards, consider the tuples 2, …, n: If (a, b) and the tuple (l, r) have b > l, do not insert the tuple in the stack but update (a, b) with (a, b) = (a, max{b, r}). Otherwise, insert (l, r) in the stack. Sorting is the most time consuming step and hence, the stack is obtained in O(n ⋅ logn). Removing the tuples from the top of the stack, all affected periods are accessible in an increasing order of periods.
- 6.
This strategy gives the name ‘Overlap Heuristic’.
- 7.
Implementation detail: A maximum priority queue (Cormen et al. 2001, pp. 138–140) provides an efficient data structure. Given a data record of size n. Each element in the data record contains an ID and a key. Let a maximum heap be linearized in an array (Cormen et al. 2001, pp. 127–135). Whenever, a heap operation ‘upheap’ or ‘downheap’ is executed, a reference to the final position of the element in the heap array is stored in an additional array. Therefore, it takes O(1) to access any element in the heap via the ID. The operation ‘update key’ has two functions. If the key of an element, which is contained in the heap, changes, the element is accessed in O(1), the key is updated and an ‘upheap’ or respectively, ‘downheap’ operation is done in O(logn). If the element is not in the heap, it is inserted with O(logn). This modified heap allows an ‘erase element’ operation with O(logn) as follows: Access the element in O(1), remove it from the heap by replacing it with the last element and perform a ‘downheap’ operation on the last element.
In the algorithm, the heap is emptied at the beginning of an iteration. The heap holds a temporary schedule for each affected period with the period as the ID and the score as the key. If the temporary schedule is empty, it is removed from the heap. Otherwise, it is inserted in the heap.
- 8.
Implementation detail: Use a list to store all open periods of (x, y)ref and of (x, y).
- 9.
An instance with a fractional extreme point to ZL(C) (X)(Y) is given in Example 4.3. Let r = (1, 1)T, \(\bar{r} = (1, 0, 1)^{T}\) and \(\mu = (\frac{1} {2}, 1, \frac{1} {2})^{T}\) to obtain the WUPMP objective function coefficients.
- 10.
- 11.
- 12.
This behavior is observed for other combinatorial optimization problems that are in \(\mathcal{P}\) and polynomially solvable with the Primal-dual Simplex algorithm such as the SPP (Papadimitriou and Steiglitz 1998, pp. 109–113; Chvátal 2002, pp. 390–400). However, the Maximum Flow Problem is in \(\mathcal{P}\) but the Ford-Fulkerson algorithm that is based on a Primal-dual Simplex algorithm has a pseudo-polynomial worst case running time (Ahuja et al. 1993, p. 186).
- 13.
Erratum: Only (6.37a) holds. However, (6.37b) is not considered as insightful because of the reason mentioned in the proof.
- 14.
Implementation detail: Algorithm 4.1 examines all periods 1, …, T in a breadth-first search. An improvement is to exclude the periods t ∉ L i since they do not improve the shortest path due to infinite arc lengths: Order the set L i with respect to increasing values of periods when it is obtained from d it ′. Let p be an index in L i such that L i (p) returns the period at the pth position in L i . A simple modification now traverses only the periods L i (t), …, L i (t) +π i where t is an index instead of all periods t, …, t +π i .
- 15.
Implementation detail: An efficient implementation uses a minimum priority queue. In every iteration, the heap holds one shortest path for each maintenance activity i ∈ J with i as the ID and the length of the shortest path as the key. Recomputed shortest paths for the maintenance activities \(i \in \bar{ I}\) are inserted with the heap operation ‘update key’.
- 16.
- 17.
Implementation detail: The KP objective function coefficients \(c_{it} =\sum _{ \tau =\max \left \{1,t-\pi _{i}+1\right \}}^{\min \left \{t,T-\pi _{i}+1\right \}}\upsilon _{i\tau }\;\forall i; t\) are efficiently calculated as follows. Set c i0 = 0, υ i0 = 0 and \(\upsilon _{i,T-\pi _{i}+2} = 0\). Calculate \(c_{it} = c_{i,t-1} -\upsilon _{i,\max \{0,t-\pi _{i}\}} +\upsilon _{i,\min \{t,T-\pi _{i}+2\}}\;\forall i; t\).
- 18.
\(UBL =\sum _{ t=1}^{T}\min \left \{0, 1 - LB_{t}^{KP}\right \} +\sum _{ i=1}^{n}\sum _{t=1}^{T-\pi _{i}+1}\upsilon _{it}\).
- 19.
Implementation detail: (6.41) requires to find \(\overline{LB}\) and L B. An efficient implementation uses a priority queue of a fixed size . This variant is a priority queue, which is modified to hold a restricted, maximal number of elements. The array, which is used to access the elements in the heap, is cyclically traversed such that the priority queue has a fixed size. Thus, the ID of an element is already used for the data structure. Every element holds the value of the lower bound as a key and the iteration in which the lower bound was obtained.
- 20.
ZLinit (6.42) is directly obtained from ZL(C) with μ init (Lemma 6.9). Alternatively, consider the CPMP LP relaxation of (Y) and completely relax (V) as well as (Sy). Since the objective function coefficients of y are non-negative and y is continuous, there exists an optimal solution that satisfies (C) an equality. A substitution with \(y_{t} =\sum _{ i=1}^{n}\frac{r_{i}} {\bar{r}_{t}} \cdot x_{it}\;\forall t\) yields (6.42).
- 21.
This can be concluded from a proof similar to Lemma 4.13.
- 22.
Implementation detail: It is efficient to verify ∑ t = 1 T y t < UB ∗ before \(\hat{g} \leq 0\). Whereas the latter is executed in time O(T) for ZL(C), it takes the time O(n ⋅ T) for ZL(P).
- 23.
- 24.
- 25.
Implementation detail: To make the algorithm efficient, use introsort for sorting the items in the first step and apply a binary search for finding the items a and b. Both algorithms are outlined in Footnotes 33 and 32 on page 63.
- 26.
Implementation detail: Omit cliques with a cardinality of one because (V) has been already inserted.
- 27.
Some inequalities are redundant since (L) is tighter than (V).
- 28.
- 29.
Implementation detail: Covers with a cardinality of two are not inserted because (L), which is tighter, has been added already.
- 30.
Implementation detail: In one iteration of the Knapsack Heuristic (Algorithm 6.7), T KPs are solved. When the tth KP is considered, obtain the continuous solution to the Continuous KP from the critical item and solve the separation problem (3.56) with the methods from Sect. 3.6.2. This generates at most T extended cover inequalities (O). Covers with one or two elements are omitted because they are already added since they are special cases of (V) or of 2nd-degree clique inequalities (L).
As a consequence of using a heuristic to solve the separation problem (3.56), not all existing cover inequalities are found and a cover is not necessarily minimal.
- 31.
Implementation detail: Use a triplet with checksums and a hash table as explained in Sect. 6.4 to prevent a multiple insertion of the same cutting plane or cover inequality.
- 32.
This follows because LB (C) ≤ Z (X)(Y) and Z (X)(Y) ≤ Z (P) hold by Geoffrion’s Theorem 3.11.
- 33.
- 34.
Erratum: In the left of Fig. 6.4, the convexification of the variables is not correct. The Benders’ cut DL(I) should be 2. as a vertical line, the Benders’ cut DL(II) should be 4. as a horizontal line and the squared area between 2., 6. and the cutting plane is the third convexification.
- 35.
The Lagrangean dual Z (P) = max υ ≥ 0 ZL (P)(υ) is obtained with (5.41) as given in (6.68)–(6.70) below. The extreme rays are omitted because the polyhedron of ZL(P) is bounded. (6.75) is obtained from (6.69).
$$\displaystyle\begin{array}{rcl} Z_{\mbox{ (P)}} =\max \eta \qquad \mbox{ subject to}& & {}\end{array}$$(6.68)$$\displaystyle\begin{array}{rcl} \eta \leq \sum \limits _{t=1}^{T}y_{t}^{p} -\sum \limits _{ i=1}^{n}\sum \limits _{ t=1}^{T-\pi _{i}+1}\left (\sum \limits _{\tau =t}^{t+\pi _{i}-1}x_{ i\tau }^{p} - 1\right ) \cdot \upsilon _{ it}\qquad \forall p \in P& & {}\end{array}$$(6.69)$$\displaystyle\begin{array}{rcl} \eta \geq 0 \wedge \upsilon _{it} \geq 0\;\forall i = 1,\ldots,n; t = 1,\ldots,T -\pi _{i} + 1& & {}\end{array}$$(6.70) - 36.
Implementation detail: Preventing recalculations in (6.86), the slack of (C) and the tabu objective function value are updated per period whenever a maintenance activity is scheduled or planned out.
- 37.
Implementation detail: It is efficient to store how the move changes the current solution instead of an entire solution. Such a move object contains a list that holds the periods in which tasks of a maintenance activity i are scheduled, a list where the tasks of i are planned out and a stack with the tabu search objective function values per period of (6.86). After every move this information is used to recover the solution from the beginning of the iteration. The scope is implemented as a list and is updated with the move object.
- 38.
Implementation detail: Working on this tabu list requires O(1). Let iter be an iteration of the tabu search algorithm and let (a it ) i = 1, …, n∧t = 1, …, T be a matrix. A move that schedules the task of the maintenance activity i in period t in is set tabu by \(a_{i,t^{in}} = iter\). A move that tries to plan out this task from t out is tabu if \(iter < a_{i,t^{out}} + \text{SIZE}\) with size as the length of the tabu list.
- 39.
Two 16-bit sums are calculated from a given message with the modulo of 65521. The Adler32 checksum is obtained from a concentration of both sums into a 32-bit integer by multiplying one sum with 216 and adding the second sum. A short discussion of its errors is provided in Stone and Stewart (2002). The source code is available at Adler (1996) and it is programmed in C.
- 40.
The Cyclic Redundancy Check (CRC) check value is often referred to as CRC checksum although it is not a mathematical sum. The calculation is as follows: 32-bits are appended to a given message and this expression is divided by a given 33-bit polynomial. The remainder of the division is the CRC32 checksum. Tanenbaum (1981, pp. 128–132) provides a discussion of the errors of this checksum. This algorithm uses the well-known CRC-32 polynomial x 32 + x 26 + x 23 + x 22 + x 16 + x 12 + x 11 + x 10 + x 8 + x 7 + x 5 + x 4 + x 2 + x 1 + 1 (ANSI/IEEE Std 1985) that provides a sufficient error detection for this application. An exhaustive comparison of polynomials with a lower probability of undetected errors is given in Koopman (2002). The source code is available at Brown (1986) in C. The implementation uses look-up tables and the ‘backwards’ version.
- 41.
Implementation detail: Since both checksums require that the message consists of entries from 0 to 255, a representation of t with a precalculated tuple \((\big\lfloor \frac{t} {256}\big\rfloor,t\bmod 256)\) is necessary if t > 255.
- 42.
Implementation detail: If the current solution has the same number of open periods as a triplet of the list, the solution is encoded and the Adler32 checksums are compared. Upon equivalence an additional comparison of the CRC32 checksum follows. Being computationally expensive, the Adler32 and the CRC32 checksums are calculated in that order, only if their values are necessary for a comparison and once calculated the values are stored in the aforementioned move object for further purposes (e.g., further scanning of the list and setting the solution tabu).
- 43.
Implementation detail: The C++ source code is available at Fog (2008).
- 44.
If and only if c is a power of two, a multiplication a ⋅ c is equivalent to a bitshift of the multiplicand a by log2 c positions to the left in the CPU register.
- 45.
In a 32-bit CPU register, a signed non-zero integer a is shifted at most 30 −⌊log2 a⌋ positions to the left with a single bitshift operation.
References
Adler, M. (1996). Implementation of the Adler32 checksum algorithm in C. Online. Accessed June 2010.
Ahuja, R. K., Magnanti, T. L., & Orlin, J. B. (1993). Network flows: Theory, algorithms, and applications. Upper Saddle River, NJ: Prentice-Hall.
ANSI/IEEE Std. (1985). IEEE Standards for Local Area Networks: Carrier Sense Multiple Access with Collision Detection (CSMA/CD) Access Method and Physical Layer Specifications. ANSI/IEEE Std 802.3-1985 (p. 27).
Balakrishnan, A., Magnanti, T. L., & Wong, R. T. (1989). A dual-ascent procedure for large-scale uncapacitated network design. Operations Research, 37, 716–740.
Brown, G. S. (1986). Implementation of the CRC32 checksum algorithm in C. Online. Accessed June 2010.
Caprara, A., Fishetti, M., & Toth, P. (1999). A heuristic method for the set covering problem. Operations Research, 47, 730–743.
Chambers, J., & Barnes, J. W. (1998). Reactive Search for Flexible Job Shop Scheduling. ORP98-04, Graduate program in Operations Research and Industrial Engineering, The University of Texas at Austin.
Chvátal, V. (2002). Linear programming. New York: W.H. Freeman and Company.
Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2001). Introduction to algorithms (2nd ed.). Cambridge: The MIT Press.
Deutsch, P., & Gailly, J.-L. (1996). ZLIB compressed data format specification version 3.3. The Internet Engineering Task Force RFC 1950.
Erlenkotter, D. (1978). A dual-based procedure for uncapacitated facility location. Operations Research, 26, 992–1009.
Fog, A. (2008). Implementation of the Mersenne Twister algorithm in C++. Online. Accessed September 2010.
Gendron, B. (2002). A note on a dual-ascent approach to the fixed-charge capacitated network design problem. European Journal of Operational Research, 138, 671–675.
Guignard, M., & Spielberg, K. (1979). A direct dual method for the mixed plant location problem with some side constraints. Mathematical Programming, 17, 198–228.
Herrmann, J., Ioannou, G., Minis, I., & Proth, J. M. (1996). A dual ascent approach to the fixed-charge capacitated network design problem. European Journal of Operational Research, 95, 476–490.
Klose, A. (2001). Standortplanung in distributiven Systemen. Heidelberg: Physica.
Klose, A., & Drexl, A. (2005). Facility location models for distribution system design. European Journal of Operational Research, 162, 4–29.
Kolisch, R. (1996). Serial and parallel resource-constrained project scheduling methods revisited: Theory and computation. European Journal of Operational Research, 90, 320–333.
Koopman, P. J. (2002). 32-bit cyclic redundancy codes for internet applications. In The International Conference on Dependable Systems and Networks (DSN 2002) (pp. 459–468).
Matsumoto, M., & Nishimura, T. (1998). Mersenne Twister: A 623-dimensionally equidistributed uniform pseudo-random number generator. ACM Transactions on Modeling and Computer Simulation, 8, 3–30.
Maxino, T. C. (2006). The Effectiveness of Checksums for Embedded Networks. Master’s thesis, Department of Electrical and Computer Engineering, Carnegie Mellon University, Pittsburgh.
Maxino, T. C., & Koopman, P. J. (2009). The effectiveness of checksums for embedded control networks. IEEE Transactions on Dependable and Secure Computing, 6, 59–72.
Nemhauser, G. L., & Wolsey, L. A. (1988). Integer and combinatorial optimization. New York: Wiley.
Ottmann, T., & Widmayer, P. (2012). Algorithmen und Datenstrukturen (5th ed.). Heidelberg: Spektrum Akdemischer Verlag.
Papadimitriou, C. H., & Steiglitz, K. (1998). Combinatorial optimization: Algorithms and complexity. Mineola: Dover.
Peterson, W. W., & Brown, D. T. (1961). Cyclic codes for error detection. Proceedings of the IRE, 49, 228–235.
Sheinwald, D., Satran, J., Thaler, P., & Cavanna, V. (2002). Internet protocol small computer system interface (iSCSI) cyclic redundancy check (CRC)/checksum considerations. The Internet Engineering Task Force RFC 3385.
Stone, J., & Stewart, R. (2002). Stream control transmission protocol (SCTP) checksum change. The Internet Engineering Task Force RFC 3309.
Tanenbaum, A. S. (1981). Computer networks. New York: Prentice Hall.
Thompson, D. R., Maxwell, B., & Parkerson, J. P. (2004). Building the big message authentication code. In Proceedings 8th World Multiconference on Systemics, Cybernetics and Informatics (SCI 2004) (pp. 544–549).
Woodruff, D. L., & Zemel, E. (1993). Hashing vectors for tabu search. Annals of Operations Research, 41, 123–137.
Author information
Authors and Affiliations
Rights and permissions
Copyright information
© 2017 Springer International Publishing Switzerland
About this chapter
Cite this chapter
Kuschel, T. (2017). Algorithms for the Capacitated Planned Maintenance Problem. In: Capacitated Planned Maintenance. Lecture Notes in Economics and Mathematical Systems, vol 686. Springer, Cham. https://doi.org/10.1007/978-3-319-40289-5_6
Download citation
DOI: https://doi.org/10.1007/978-3-319-40289-5_6
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-319-40288-8
Online ISBN: 978-3-319-40289-5
eBook Packages: Business and ManagementBusiness and Management (R0)