Next Article in Journal
Performance Evaluation of Hybrid WOA-SVR and HHO-SVR Models with Various Kernels to Predict Factor of Safety for Circular Failure Slope
Previous Article in Journal
Evaluation of Emotional Satisfaction Using Questionnaires in Voice-Based Human–AI Interaction
 
 
Search for Articles:
Title / Keyword
Author / Affiliation / Email
Journal
Article Type
 
 
Advanced Search
 
Section
Special Issue
Volume
Issue
Number
Page
 
Journals
Applied Sciences
Volume 11
Issue 4
10.3390/app11041921
applsci-logo
Submit to this Journal Review for this Journal Propose a Special Issue
► Article Menu

Article Menu

share Share announcement Help format_quote Cite question_answer Discuss in SciProfiles thumb_up
...
Endorse textsms
...
Comment
first_page
settings
Order Article Reprints
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Job Shop Scheduling Problem Optimization by Means of Graph-Based Algorithm

by
Jiri Stastny
1,2,*,
Vladislav Skorpil
3,
Zoltan Balogh
4 and
Richard Klein
1
1
Institute of Automation and Computer Science, Brno University of Technology, 616 69 Brno, Czech Republic
2
Department of Informatics, Mendel University in Brno, 613 00 Brno, Czech Republic
3
Department of Telecommunications, Brno University of Technology, 616 00 Brno, Czech Republic
4
Computer Science Department, Constantine the Philosopher University in Nitra, 949 74 Nitra, Slovakia
*
Author to whom correspondence should be addressed.
Appl. Sci. 2021, 11(4), 1921; https://doi.org/10.3390/app11041921
Submission received: 11 January 2021 / Revised: 15 February 2021 / Accepted: 17 February 2021 / Published: 22 February 2021
(This article belongs to the Section Applied Industrial Technologies)
Browse Figures
Versions Notes

Abstract

:
In this paper we introduce the draft of a new graph-based algorithm for optimization of scheduling problems. Our algorithm is based on the Generalized Lifelong Planning A* algorithm, which is usually used for path planning for mobile robots. It was tested on the Job Shop Scheduling Problem against a genetic algorithm’s classic implementation. The acquired results of these experiments were compared by each algorithm’s required time (to find the best solution) as well as makespan. The comparison of these results showed that the proposed algorithm exhibited a promising convergence rate toward an optimal solution. Job shop scheduling (or the job shop problem) is an optimization problem in informatics and operations research in which jobs are assigned to resources at particular times. The makespan is the total length of the schedule (when all jobs have finished processing). In most of the tested cases, our proposed algorithm managed to find a solution faster than the genetic algorithm; in five cases, the graph-based algorithm found a solution at the same time as the genetic algorithm. Our results also showed that the manner of priority calculation had a non-negligible impact on solutions, and that an appropriately chosen priority calculation could improve them.

1. Introduction

Nowadays, graph-based algorithms are a popular tool for solving various optimization problems. However, most optimization methods are only used for solving one type of task. On the other hand, methods for optimization of several problems, in most cases, lack sufficient computing power. There are a wide variety of different algorithms available for the optimization of scheduling problems. One of the most well-known is the genetic algorithm (GA).
In this article, we introduce the draft of a graph-based algorithm for scheduling optimization problems. The proposed algorithm aims to have the flexibility and scope of application of advanced optimization methods—such as genetic algorithms—and to retain most of the positive characteristics of advanced graph algorithms.
We researched the literature carefully and paid great attention—though the references contained mainly general literature reviews. Our proposed algorithm appears unique; we could not find any other reference with comparable results for the given problem.
There are many different methods, algorithms and modifications, some of which already contain some of the required properties. Their structure allows for further adaptation. Additionally, some algorithms are directly intended for further development into new algorithms. From various graph-based algorithms, the Forward Version of Generalized Lifelong Planning A* (GLPA*) [1] —used for path planning in mobile robot navigation— was chosen. We then attempted to modify it for use in other types of optimization and tested it on various travelling salesman problems against the genetic algorithm (GA) [2,3].
The solution was based on a new algorithm, a hybrid between graph-based and genetic algorithms. An algorithm was designed and implemented that combines the advantages of graph-based and genetic algorithms. We chose the genetic algorithm for comparison because it was suited for this purpose and remains one of the most well-known algorithms for optimization in the planning area. The key parameters for the solution in the given area were makespan and calculation speed. Optimization according to other parameters would be possible; however, given the importance of the above two key parameters, it would not make sense.
The task of developing new optimization procedures resulted from a general effort to optimize problem solving. Our proposed graph-based algorithm has been successfully tested on other problems (see references) and was more successful that the commonly-used genetic algorithm in solving the Job Scheduling. The motivation for the development of new algorithms was to obtain faster, more accurate results in the given area.
In this paper, the term “performance” refers to the success of our algorithm according to the following parameters: makespan and calculation speed. Using those parameters, our new graph-based algorithm was compared with a genetic algorithm (for makespan differences, see conclusion; for calculation speed, see Table 1). These parameters were chosen because they are key, and because, according to references, measuring other parameters would have made little sense. For the industry, improvements in makespan and calculation speed are economically-driven (e.g., seeking a reduction in price).
The graph-based algorithm had a better average deviation from best-known makespans than the GA. The average deviations of the best-known makespans from the best makespans were as follows: 5.19% for GA and 4.7% for α; 5.05% for β and 5.08% for γ, for the developed (graph-based) algorithm. The average calculation speed of the proposed graph algorithm is two to three times higher than the GA.
When researching the new graph-based algorithm, we proceeded through five steps: (1) analysis of graph-based algorithms, (2) analysis of genetic algorithms, (3) development and design of new algorithm, (4) verification of algorithm on job shop scheduling problem (JSSP), and (5) comparison with the genetic algorithm used in the given area. Let us take a look at our new algorithm’s performance on job shop scheduling problems.

2. Job Shop Scheduling Problem

The job shop scheduling problem (JSSP) is about allocating limited resources to a variety of tasks for the purpose of obtaining optimal scheduling solutions. These optimized scheduling solutions are important for achieving an efficient and orderly production process [4]. The JSSP is one of the most well-known problems in the fields of production management and combinatorial optimization. The classical n-by-m JSSP can be described as the flow shop problem generalization or the open shop problem specification: scheduling n jobs on m machines with the objective of minimizing the scheduled completion time (makespan) of all jobs. Each of n jobs consists of several operations on m specified machines, which need an uninterrupted processing time of a given length. Operations of the same job can be performed only on one machine at a time and each job must be processed on each machine exactly once [5].
In order to increase production efficiency, reduce cost and/or improve product quality, efficient methods for solving the JSSP are required. Additionally, the JSSP is acknowledged as one of the most challenging NP-hard problems—and no algorithms that can solve the JSSP consistently, even on small scale problems, are known to exist [5].
Nowadays, with the usage of metaheuristic algorithms, new ways of obtaining better results than were possible with classical methods (such as greedy or dispatching heuristic algorithms) have emerged. These metaheuristic algorithms are widely used because of their flexibility and global optimization capabilities [4]. Algorithms for the solution of the JSSP include population-based metaheuristic ones, including particle swarm optimization (detailed description in [6,7]), genetic algorithms, artificial immune systems and their hybrids (see [8,9,10]), construction and improvement heuristics including taboo search (described in [11,12,13]) and simulated annealing (described in [14,15]). Also, heuristic methods can be used for large-scale problems. These include dispatching priority rules (see [16,17,18]), the shifting bottleneck approach (detailed description in [19,20,21]) and Lagrangian relaxation (see [22,23,24]) [5].
However, each of these methods comes with their own drawback. Simulated annealing has the tendency to generate poor designs that have a high chance of missing local minima; its convergence is also quite slow. The taboo search uses the serial search method and is low-efficiency. Particle swarm optimization has the tendency to become trapped in local minima. Exact techniques, such as branch and bound (described in [25,26]) and dynamic programming (see [27,28]) can be used to solve only modest-scale problems, because of the complexity of the JSSP [5].
As the genetic algorithm can search efficiently through large search spaces and does not explicitly require additional information about the objective function in order to be optimized, it has been applied to many combinatorial problems, including scheduling [29]. Moreover, its architecture makes it well suited for parallel computation. On the other hand, the GA considers only one new solution at a time [4].

3. Algorithm Description

The proposed algorithm was developed based on the Generalized Lifelong Planning A*, which is the forward algorithm and framework that generalizes Lifelong Planning A* (LPA*) (described in detail in [30]) and its non-deterministic version of the Minimax LPA* (described in detail in [31]). Additionally, it is designed to allow further development of efficient versions of LPA* and Minimax LPA*, including versions that use inconsistent heuristics or good tiebreaking. That is described in detail in [32].
There are only two differences between LPA* and GLPA* algorithms—and those differences are the reason why GLPA* was chosen over the classical implementation of LPA*. One difference is that GLPA* generalizes the calculation of RHS values and priorities, which enables a considerable amount of adaptability in determination of the optimization criterion and the order in which new states are expanded. Another difference is that the priority queue of GLPA* does not contain all locally inconsistent states—only locally inconsistent states that have not yet been expanded as overconsistent during the current run of the function ComputePlan(). This difference can considerably speed up a search [32].
The first major modification made was the change in data representation. This change was heavily inspired by the genetic algorithm. Although the data representation in GLPA* is very suitable for solving path planning problems, it is less effective for other types of optimization—and for some problems, it is completely useless. For this reason, data of the proposed algorithm is now represented by the usage of bit strings. In most cases, this means that numerical parameters are represented by integers. When solving complex problems, a representation using Gray code can be used, which causes even greater changes in data of possible solutions when expanding new states and further reduces the possibility of converging on local extremes. Real numbers usage is not recommended, because it tends to cause problems for the expansion of new states [3].
The second significant change we made stems from the first; since the algorithm uses a different data representation, the values of newly acquired states may no longer depend on the values of their predecessors. Furthermore, the calculation of the RHS value may now vary depending on the problem—meaning the old way of calculation is not always possible. Therefore, a new function—StateEvaluation() [2]—was introduced, which calculated the RHS value of the given problem. This is basically an objective function used to determine how close the obtained solution is in order to achieve the goals of optimization. In order to prevent the algorithm from converging on an unsuitable solution or even not converging at all, the function must be appropriately chosen and must correlate with the goals of optimization. Additionally, this function must be rapidly calculated, because the calculation must be repeated many times in order to generate useful results for nontrivial problems. Therefore, the speed of calculation is very important [3]. The priority K(u) of the state u in the priority queue is a two-element vector: K(u) = [K1(u); K2(u)]. For basic application, K1(u) = rhs(u) and K2(u) = g(u) can be used. However, for better performance, more appropriate priority calculations can be chosen.
The method of calculating priorities K(u)—especially in the context of makespan—has a significant impact on the result. Making the appropriate choice in priority calculation will improve the result, and choosing inappropriately will impair the result. This further improved the performance of our algorithm.
Pseudo-code excerpts from our proposed algorithm are shown in Algorithms 1. The first difference is that the optimization of logistic problems may have more than one initial state, which is represented in {04–05}. Additionally, this type of optimization problem does not usually have a defined target state, represented by the while loop removal in ComputePlan(). Main() now continuously calls ComputePlan(), and therefore the algorithm tries continuously to improve the solution. However, we can easily add a new termination condition by replacing the forever loop in Main() by a while/until loop that terminates the optimization algorithm when a predetermined amount of time has elapsed, or after a certain number of repetitions of the procedure [2]. Also, the new state of the parameter ssol was introduced, see line {02} which represents the best-found state {13} and contains the current solution of the given optimization problem.
Algorithms 1: The pseudo-codes use the following functions to manage the priority queue: U.Insert(s, k) inserts state s into priority queue U with priority k. U.Remove(s) removes state s from priority queue U. U.Update(s, k) sets the priority of state s in the priority queue to k. U.Remove(s) removes state s from priority queue U. U.Pop() deletes the state with the smallest priority in priority queue U and returns the state. Insert(s, k) inserts state s into priority queue U with priority k. The predicate NotYet(s) is shorthand for “state s has not been expanded yet as overconsistent during the current call to ComputePlan().” Finally StateEvaluation() returns the value of optimized logistic problem.
 
procedure Initialize()
{01} U = Ø;
{02} rhs(ssol) = g(ssol) = ∞;
{03} for all s ∈ S rhs(s) = g(s) = ∞;
{04} for all sstart∈ Starting vertexes
{05}   rhs(sstart) = StateEvaluation();
{06}   UpdateState(sstart);
 
procedure UpdateState(u)
{07} if (u ≠ sstart) rhs(u) = StateEvaluation();
{08} if (u ∈ U and g(u) ≠ rhs(u)) U.Update(u,K(u));
{09} else if (u ∈U and g(u) = rhs(s)) U.Remove(u);
{10} else if (u ∉ U and g(u) ≠ rhs(u) and NotYet(u)) U.Insert(u,K(u));
 
procedure ComputePlan()
{11} u = U.Pop();
{12}   if (g(u) > rhs(u))
{13}            if (rhs(u) < rhs(ssol)) ssol = u;
{14}      g(u) = rhs(u);
{15}      for all s ∈ Succ(u) UpdateState(s);
{16}  else
{17}     g(u) = ∞;
{18}    for all s ∈ Succ(u) ∪ {u} UpdateState(s);

4. Computational Result

The algorithms were implemented in C# language on a personal computer with Intel Core P7550.
For these experiments, a variation of operation-based representation was chosen, wherein all operations for a job are named by the same symbol in the sequence and interpreted according to the order of occurrence in the given sequence. Therefore, each job appears in the sequence exactly m times and each repetition refers to a unique operation, which is dependent on the context and does not indicate a predetermined operation of the job. This way, any permutation of elements in a sequence always yields a feasible schedule [33].
Although the values of newly acquired states may no longer depend on their predecessors, the position of symbols in the sequence of the newly acquired states does. As for this problem, we changed the symbols position in the sequence only if it was not changed in one of their predecessors.
Experiments performed by means of the graph-based algorithm used three different methods of calculation of priority K(u). The results of experiments marked α were obtained by using the basic calculation of priority K(u): K1(u) = rhs(u) and K2(u) = g(u). For β, priority K(u) consisted of K1(u) = h(u) and K2(u) = rhs(u). Results for experiments marked γ used K1(u) = h(u) and K2(u) = −rhs(u), where rhs(u) represents the makespan and h(u) is the sum of completion times of all machines, calculated by the function StateEvaluation() as a byproduct.
Experiments solved by the genetic algorithm were performed using roulette wheel selection, one-point crossover with the corresponding repair process and reciprocal exchange mutation. All tests used the same crossover rate (0.8) and population size (100). The mutation used was relatively low (1/n), where n represents the number of genomes in a chromosome. These parameters were chosen because they showed the best results for this problem type.
Instances of problems for the job shop scheduling problem were commonly used as benchmarking instances [34] and were taken from the database of scheduling problems, OR-Library [35]. One hundred tests on each instance were performed for each algorithm. For a better variation of results, starting states of the graph algorithm were randomly generated.
These experiments were compared by several factors: the time taken to find the best solution, makespan, the average value of makespans found and the average time taken to find these makespans. The results of these tests are summarized in Table 1, which also lists number of jobs, number of machines, instances [36], the best-known solution and the overall time of optimization for the given problem.
We did not test the problem of limiting the proposed algorithm with respect to the number of jobs or machines. Limiting the algorithm by comparison through the most well-known makespans was sufficient enough for the given application area. An example of Gantt graphs for the instance la09 can be found in Figure 1 and Figure 2.
The purpose of the performed experiments was not necessarily to reach the best-known makespan, but rather to show what makespan could be found by our proposed algorithm in an allocated time; to how fast it performed and compare it to results reached under the same conditions by an unmodified GA. For this reason, we let each of the tested algorithms run for a certain amount of time—unless the best-known makespan was found.
The results of comparative experiments showed that our proposed graph-based algorithm was able to find the same or better solutions compared to the genetic algorithm— and managed to find them faster. The graph-based algorithm also managed to find the same average makespan as the GA on eight benchmarking instances, and a better average makespan on eighteen instances. However, detailed examination of the experimental results showed that with an increase in the number of parameters and iterations, the time required for the execution of each iteration will gradually start to rise; under those conditions, the proposed algorithm will perform its iterations slower than the tested genetic algorithm.
Table 1 shows that some of the operations sequences are not similar in order, but are very similar in calculation time. At times, the time to find the best makespan was the same as the time to test various best-known makespans (Table 1, fourth column). We did not discuss this fact in detail, but we do not expect a significant reason.
Despite this fact, the tested graph-based algorithm converged on the optimal solution quickly and obtained better results than the tested genetic algorithm, proving that the behavior shown on several travelling salesman problems in [2,3] can apply to different types of scheduling problems as well.

5. Conclusions

In this article, we proposed a graph-based algorithm that can be used for scheduling-related optimization problems. It was based on the Generalized Framework for Lifelong Planning A*. This algorithm was then tested against the classic genetic algorithm on forty benchmarking instances for the job shop scheduling problem.
The experimental results on the JSSP showed that our proposed algorithm reached the best known makespan in thirteen instances while the genetic algorithm did so only in twelve. The graph-based algorithm found a better solution than the genetic algorithm on twenty-two tested benchmarking instances, found a solution with at least the same makespan as the GA on another twelve instances, and ended in optimality in eleven of these instances. The best-known makespan’s average deviation from the best makespan acquired by the graph-based algorithm was 4.7% for α, 5.05% for β and 5.08% for γ; the genetic algorithm had an average deviation of 5.19%, and on all but fourteen instances, the proposed algorithm managed to find the solution faster (on average, about 200–300% faster) than the genetic algorithm. Additionally, on all remaining instances, the graph-based algorithm managed to find a solution in the same time frame as the GA.
The average makespan’s average deviation from the best-known makespan was 9.63% for the genetic algorithm, while the graph-based algorithm’s variations had an average deviation of 9.22% for α, 10.39% for β and 10.48% for γ. Additionally, on all but six benchmarking instances, the proposed algorithm managed to find a solution faster (on average, about 100%-200% faster) than the genetic algorithm; on five of these instances, the graph-based algorithm managed to find a solution in the same time frame as the GA.
Therefore, we can state that our proposed algorithm generally gives the same or better results—in comparison with the genetic algorithm’s basic implementation—on the job shop scheduling problem. The practical consequences of the identified improvements (in makespan and calculation speed) are economic; these improvements will bring a price reduction.
The manner of priority calculation has a nonnegligible impact on solutions. An appropriately chosen priority calculation can improve results, and an inappropriately chosen priority calculation can worsen them. Therefore, the proposed algorithm’s performance can be further improved by proposing new methods of priority calculation.

Author Contributions

Conceptualization, J.S. and V.S.; Methodology, J.S.; Software Z.B. and R.K.; Validation, V.S.; Formal Analysis, J.S. and V.S.; Investigation, J.S.; Resources, V.S.; Data Curation, Z.B.; Writing—Original Draft Preparation, J.S.; Writing—Review & Editing, V.S.; Visualization, R.K.; Supervision, V.S.; Project Administration, J.S.; Funding Acquisition, V.S. All authors have read and agreed to the published version of the manuscript.

Funding

The research described in this paper was financed by a grant from the Ministry of the Interior of the Czech Republic, Program of Security Research, VI20192022135 “Deep hardware detection of network traffic of next generation passive optical network in critical infrastructures”.

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Data Availability Statement

Data are contained within the article.

Acknowledgments

This article is based upon grant of the Ministry of the Interior of the Czech Republic, Program of Security Research, VI20192022135, “Deep hardware detection of network traffic of next generation passive optical network in critical infrastructures”.

Conflicts of Interest

The authors declare no conflict of interest. The funders had no role in the design of the study; in the collection, analyses, or interpretation of data; in the writing of the manuscript, or in the decision to publish the results.

Abbreviations

The following abbreviations are used in this manuscript.
GAGenetic Algorithm
GLPA*Generalized Lifelong Planning A*
JSSPJob Shop Scheduling Problem
LPA*Lifelong Planning A*

References

  1. Skorpil, V.; Cizek, L.; Stastny, J. Path Optimization by Graph Algorithms. In Proceedings of the International Conference CSCC 2012, Recent Researches in Communication and Computers, Kos island, Greece, 14–17 July 2012; pp. 73–78. [Google Scholar]
  2. Cizek, L.; Stastny, J. Comparison of Genetic Algorithm and Graph-based Algorithm for the TSP. In Proceedings of the MENDEL 2013, 19th International Conference on Soft Computing, Brno, Czech Republic, 14–18 July 2013; pp. 433–438. [Google Scholar]
  3. Stastny, J.; Skorpil, V.; Cizek, L. Traveling Salesman Problem Optimization by Means of Graph-Based Algorithm. In Proceedings of the 39 th International Conference on Telecommunications and Signal Processing (TSP), Vienna, Austria, 27–29 June 2016; p. 207. [Google Scholar]
  4. Chen, J.; Zhang, S.; Gao, Z.; Yang, L. Feature-based initial population generation for the optimization of job shop problems. J. Zhejiang Univ. Sci. C 2010, 11, 767–777. [Google Scholar] [CrossRef]
  5. Sun, L.; Cheng, X.; Liang, Y. Solving Job Shop Scheduling Problem Using Genetic Algorithm with Penalty Function. Int. J. Intell. Inf. Process. 2010, 1, 65–77. [Google Scholar]
  6. Liu, B.; Wang, L.; Jin, Y.H. An effective hybrid PSO-based algorithm for flow shop scheduling with limited buffers. Comput. Oper. Res. 2008, 35, 2791–2806. [Google Scholar] [CrossRef] [Green Version]
  7. Tasgetiren, M.F.; Liang, Y.C.; Sevkli, M. A particle swarm optimization algorithm for makespan and total flowtime minimization in the permutation flowshop sequencing problem. Eur. J. Oper. Res. 2007, 177, 1930–1947. [Google Scholar] [CrossRef]
  8. Ge, H.W.; Sun, L.; Liang, Y.C.; Qian, F. An effective PSO-and-AIS-based hybrid intelligent algorithm for job-shop scheduling. IEEE Trans. Syst. Man Cybern. Part A Syst. Hum. 2008, 38, 358–368. [Google Scholar]
  9. Coello, C.A.C.; Rivera, D.C.; Cortes, N.C. Use of an artificial immune system for job shop scheduling. Lect. Notes Comput. Sci. 2003, 2787, 1–10. [Google Scholar]
  10. Yang, J.H.; Sun, L.; Lee, H.P.; Qian, Y.; Liang, Y.C. Clonal selection based memetic algorithm for job shop scheduling problems. J. Bionic Eng. 2008, 5, 111–119. [Google Scholar] [CrossRef]
  11. Zhang, C.Y.; Li, P.G.; Rao, Y.Q. A very fast TS/SA algorithm for the job shop scheduling problem. Comput. Res. 2008, 35, 82–294. [Google Scholar] [CrossRef]
  12. Nowicki, E.; Smutnicki, C. A fast taboo search algorithm for the job shop scheduling problem. Manag. Sci. 1996, 41, 113–125. [Google Scholar]
  13. Dell, A.M.; Trubian, M. Applying tabu-search to job shop scheduling problem. Ann. Oper. Res. 1993, 41, 231–252. [Google Scholar] [CrossRef]
  14. Wang, T.Y.; Wu, K.B. A revised simulated annealing algorithm for obtaining the minimum total tardiness in job shop scheduling problems Operations. Int. J. Syst. Sci. 2000, 31, 537–542. [Google Scholar] [CrossRef]
  15. Kolonko, M. Some new results on simulated annealing applied to the job shop scheduling problem. Eur. J. Oper. Res. 1999, 113, 123–136. [Google Scholar] [CrossRef]
  16. Weng, M.X.; Ren, H.Y. An efficient priority rule for scheduling job shops to minimize mean tardiness. IIE Trans. 2006, 38, 789–795. [Google Scholar] [CrossRef]
  17. Canbolat, Y.B.; Gundogar, E. Fuzzy priority rule for job shop scheduling. J. Intell. Manuf. 2004, 15, 527–533. [Google Scholar] [CrossRef]
  18. Klein, R. Bidirectional planning: Improving priority rule-based heuristic for scheduling resource-constrained projects. Eur. J. Oper. Res. 2000, 127, 619–638. [Google Scholar] [CrossRef]
  19. Gao, J.; Gen, M.; Sun, L.Y. A hybrid of genetic algorithm and bottleneck shifting for multiobjective flexible job shop scheduling problems. Comput. Ind. Eng. 2007, 53, 149–162. [Google Scholar] [CrossRef]
  20. Zhao, L.H.; Deng, F.Q. A hybrid shifting bottleneck algorithm for the job shop scheduling problem. Dyn. Contin. Discret. Impulsive Syst. Ser. A-Math. Anal. Part 3 2006, 13, 1069–1073. [Google Scholar]
  21. Pezzella, F.; Merelli, E. A tabu search method guided by shifting bottleneck for the job shop scheduling problem. Eur. J. Oper. Res. 2000, 120, 297–310. [Google Scholar] [CrossRef]
  22. Baptiste, P.; Flamini, M.; Sourd, F. Lagrangian bounds for just-in-time job shop scheduling. Comput. Oper. Res. 2008, 35, 906–915. [Google Scholar] [CrossRef] [Green Version]
  23. Chen, H.X.; Luh, P.B. An alternative framework to Lagrangian relaxation approach for job shop scheduling. Eur. J. Oper. Res. 2003, 149, 499–512. [Google Scholar] [CrossRef]
  24. Kaskavelis, C.A.; Caramanis, M.C. Efficient Lagrangian relaxation algorithms for industry size job-shop scheduling problems. IIE Trans. 1998, 30, 1085–1097. [Google Scholar] [CrossRef]
  25. Brucker, P.; Jurisch, B.; Sievers, B. A branch and bound algorithm for job shop scheduling problem. Discret. Appl. Math 1994, 49, 105–127. [Google Scholar] [CrossRef] [Green Version]
  26. Artigues, C.; Feillet, D. A branch and bound method for the job shop problem with sequence dependent setup times. Ann. Oper. Res. 2008, 159, 135–159. [Google Scholar] [CrossRef]
  27. Lorigeon, T. A dynamic programming algorithm for scheduling jobs in a two-machine open shop with an availability constraint. J. Oper. Res. Soc. 2002, 53, 1239–1246. [Google Scholar] [CrossRef]
  28. Potts, C.N.; Van Wassonhove, L.N. Dynamic programming and decomposition approaches for the single machine total tardiness problem. Eur. J. Oper. Res. 1987, 32, 405–414. [Google Scholar] [CrossRef]
  29. Kofjac, D.; Knaflic, A.; Kljajic, M. Development of a Web Application for Dynamic Production Scheduling in Small and Medium Enterprises. Organizacija 2010, 43, 125–135. [Google Scholar] [CrossRef]
  30. Koenig, S.; Likhachev, M.; Furcy, D. Lifelong Planning A*. Artif. Intell. J. 2004, 155, 93–146. [Google Scholar] [CrossRef] [Green Version]
  31. Koenig, S.; Likhachev, M.; Furcy, D. Speeding up the Parti-Game Algorithm. In Proceedings of the The Neural Information Processing Systems (NIPS), Whistler, BC, Canada, 9–14 December 2002; pp. 1563–1570. [Google Scholar]
  32. Likhachev, M.; Koenig, S. A Generalized Framework for Lifelong Planning A* Search. In Proceedings of the International Conference on Automated Planning and Scheduling (ICAPS), Monterey, CA, USA, 5–10 June 2005; pp. 99–108. [Google Scholar]
  33. Seda, M. Mathematical Models of Flow Shop and Job Shop Scheduling Problems. Int. J. Appl. Math. Comput. Sci. 2007, 4, 241–246. [Google Scholar]
  34. Taillard, E. Benchmarks for basic scheduling problems. Eur. J. Oper. Res. 1993, 64, 278–285. [Google Scholar] [CrossRef]
  35. Beasley, J.E. OR-Library: Distributing test problems by electronic mail. J. Oper. Res. Soc. 1990, 41, 1069–1072. [Google Scholar] [CrossRef]
  36. Lawrence, S. Resource Constrained Project Scheduling: An Experimental Investigation of Heuristic Scheduling Techniques; Technical Report, GSIA; Carnegie Mellon University: Pittsburgh, PA, USA, 1984. [Google Scholar]
Applsci 11 01921 g001 550
Figure 1. Gantt graph of makespan for la09 as found by graph-based algorithm.
Figure 1. Gantt graph of makespan for la09 as found by graph-based algorithm.
Applsci 11 01921 g001
Applsci 11 01921 g002 550
Figure 2. Gantt graph of makespan for la09 as found by genetic algorithm (GA).
Figure 2. Gantt graph of makespan for la09 as found by genetic algorithm (GA).
Applsci 11 01921 g002
Table
Table 1. Comparison of algorithms on job shop scheduling problem (JSSP) by time and makespan.
Table 1. Comparison of algorithms on job shop scheduling problem (JSSP) by time and makespan.
JobsMachinesInstanceBest Known MakespanTime of OptimizationAlgorithm UsedMakespanTime of Finding Best Makespan
[mm:ss]		Average MakespanAverage Time of Finding Makespan
[mm:ss]
105la0166690Graph-based α66600:00.04678.1800:07.38
Graph-based β66600:00.04683.7900:06.54
Graph-based γ66600:00.03682.5400:03.83
Genetic66600:00.99666.1900:28.65
105la0265590Graph-based α67200:00.03728.800:17.91
Graph-based β70900:00.02773.0900:06.95
Graph-based γ67800:00.02769.400:06.29
Genetic65500:04.44686.6700:50.59
105la0359790Graph-based α61700:00.04655.2300:11.06
Graph-based β60900:00.03657.6600:06.73
Graph-based γ61700:00.03666.6100:03.55
Genetic61300:02.41638.200:50.81
105la0459090Graph-based α60400:00.04634.1700:09.94
Graph-based β59500:00.04641.7700:09.34
Graph-based γ60000:00.02643.0700:06.08
Genetic59500:01.32612.8900:48.42
105la0559390Graph-based α59300:00.0259300:00.04
Graph-based β59300:00.02593.2700:00.74
Graph-based γ59300:00.02593.2400:00.11
Genetic59300:00.0159300:00.12
155la06926120Graph-based α92600:00.06926.100:01.22
Graph-based β92600:00.06926.5900:02.22
Graph-based γ92600:00.06926.2700:02.18
Genetic92600:00.0492600:03.41
155la07890120Graph-based α89000:00.12915.8300:34.05
Graph-based β90300:00.07957.1500:13.01
Graph-based γ90300:00.08957.4300:08.24
Genetic89000:09.89909.0401:10.46
155la08863120Graph-based α86300:00.08869.5800:18.09
Graph-based β86300:00.07886.2700:09.32
Graph-based γ86300:00.07883.5800:11.99
Genetic86300:00.12864.2800:45.89
155la09951120Graph-based α95100:00.0795100:00.10
Graph-based β95100:00.08951.4800:00.45
Graph-based γ95100:00.06951.2800:01.40
Genetic95100:00.0395100:00.81
155la10958120Graph-based α95800:00.0795800:00.10
Graph-based β95800:00.1095800:00.15
Graph-based γ95800:00.0695800:01.33
Genetic95800:00.0395800:00.27
205la111222150Graph-based α122200:00.14122200:00.82
Graph-based β122200:00.141224.7200:07.29
Graph-based γ122200:00.131224.7200:10.09
Genetic122200:00.06122200:08.97
205la121039150Graph-based α103900:00.141039.300:00.75
Graph-based β103900:00.131040.1100:03.03
Graph-based γ103900:00.131039.1300:00.51
Genetic103900:00.05103900:09.49
205la131150150Graph-based α115000:00.13115000:00.18
Graph-based β115000:00.141150.2500:02.55
Graph-based γ115000:00.13115000:01.27
Genetic115000:00.04115000:03.73
205la141292150Graph-based α129200:00.14129200:00.16
Graph-based β129200:00.13129200:00.17
Graph-based γ129200:00.13129200:00.18
Genetic129200:00.04129200:00.06
205la151207150Graph-based α122100:00.181284.9200:53.47
Graph-based β123500:00.131341.4500:38.72
Graph-based γ124600:00.141344.6600:42.69
Genetic122700:01.691270.5901:33.41
1010la16945120Graph-based α98200:00.141057.6500:31.06
Graph-based β99400:00.131068.9500:17.09
Graph-based γ98200:00.191071.7700:19.66
Genetic97900:01.571022.9101:11.39
1010la17784120Graph-based α79300:00.17835.6500:23.33
Graph-based β79300:00.17841.7200:14.33
Graph-based γ79300:00.14842.900:17.10
Genetic79500:00.13832.9600:55.36
1010la18848120Graph-based α84900:00.14917.2800:22.30
Graph-based β86100:00.19920.3400:16.73
Graph-based γ86100:00.13921.5100:20.68
Genetic87100:00.16914.8300:47.57
1010la19842120Graph-based α87700:00.13934.0300:21.21
Graph-based β88900:00.13951.4300:15.39
Graph-based γ88600:00.11954.8900:13.99
Genetic87500:02.52925.9201:02.01
1010la20902120Graph-based α92100:00.15976.800:22.44
Graph-based β91400:00.14967.7200:18.57
Graph-based γ90700:00.12960.9300:23.14
Genetic92400:00.68976.0400:57.70
1510la211046150Graph-based α114400:01.461201.8600:54.14
Graph-based β112200:00.511230.3600:42.71
Graph-based γ114900:00.481230.8600:46.21
Genetic114000:06.321218.3301:15.78
1510la22927150Graph-based α99900:00.501093.9300:44.53
Graph-based β105100:00.531109.5300:44.76
Graph-based γ102700:01.691113.6700:38.11
Genetic102900:08.061105.701:25.18
1510la231032150Graph-based α106800:00.431131.9600:37.00
Graph-based β107600:00.351144.0700:31.82
Graph-based γ108600:00.361141.7400:33.06
Genetic104600:01.641140.2601:12.26
1510la24935150Graph-based α101300:00.411070.5300:55.55
Graph-based β102900:01.641075.8200:40.20
Graph-based γ99200:00.541082.8900:37.05
Genetic102400:01.161088.2401:07.66
1510la25977150Graph-based α107900:00.501125.7500:38.39
Graph-based β107600:00.501150.3800:44.80
Graph-based γ108300:00.541155.4900:34.43
Genetic106000:03.241155.1401:17.27
2010la261218180Graph-based α131100:00.841395.8601:06.53
Graph-based β134000:02.171405.401:27.17
Graph-based γ132800:04.801411.5701:11.35
Genetic134000:04.131428.1201:36.13
2010la271235180Graph-based α136800:00.791459.3801:00.30
Graph-based β139000:01.041486.9501:24.53
Graph-based γ137900:01.061483.4601:04.60
Genetic141100:04.291485.7801:38.00
2010la281216180Graph-based α132800:00.871399.7201:04.58
Graph-based β134900:00.711437.1800:53.57
Graph-based γ134800:00.901435.3600:57.33
Genetic136400:01.271431.8701:28.75
2010la291157180Graph-based α132000:00.771401.500:58.80
Graph-based β131600:01.971402.0301:13.52
Graph-based γ132600:00.761404.501:15.13
Genetic135000:05.841435.201:26.83
2010la301355180Graph-based α146700:00.831549.2100:43.81
Graph-based β145800:00.901560.1700:47.64
Graph-based γ148100:00.801558.4200:55.33
Genetic147200:04.831544.501:47.72
2010la311784180Graph-based α178400:06.401837.2302:10.06
Graph-based β178400:08.731841.6602:39.27
Graph-based γ178400:14.421835.8702:47.32
Genetic180700:16.381898.8302:18.27
3010la321850240Graph-based α185100:13.641914.2602:41.29
Graph-based β185000:10.021917.6202:39.39
Graph-based γ185000:10.871921.6902:30.43
Genetic189500:16.501993.3202:05.09
3010la331719240Graph-based α173900:02.391796.3802:08.04
Graph-based β172500:05.581817.6702:44.53
Graph-based γ174400:02.561819.5302:36.41
Genetic178000:08.461845.4302:12.57
3010la341721240Graph-based α181900:02.291878.3401:51.83
Graph-based β179700:02.551889.4302:11.28
Graph-based γ181900:02.331897.3801:57.48
Genetic184600:11.641909.8602:04.97
3010la351888240Graph-based α198000:02.432115.1502:32.74
Graph-based β206700:09.872197.1102:20.97
Graph-based γ207800:06.732193.4702:36.02
Genetic202100:17.322143.5902:48.95
1515la361268180Graph-based α142700:00.991494.5500:51.76
Graph-based β138700:00.991511.6300:48.84
Graph-based γ141900:01.071513.3201:01.04
Genetic137300:02.111482.901:30.90
1515la371397180Graph-based α157600:01.031667.0201:16.16
Graph-based β154600:05.631664.6301:20.99
Graph-based γ156500:04.331663.8501:24.34
Genetic154900:08.891681.1201:48.09
1515la381196180Graph-based α137500:00.991448.1700:52.06
Graph-based β138100:00.991446.8901:02.95
Graph-based γ137800:01.151449.0101:04.43
Genetic139700:01.461469.1601:19.78
1515la391233180Graph-based α138500:01.041455.5401:00.09
Graph-based β137700:00.991452.0201:21.56
Graph-based γ137100:01.571454.5701:12.73
Genetic140500:01.161475.1401:20.90
1515la401222180Graph-based α138600:01.501446.4101:16.11
Graph-based β135600:03.921435.0301:25.09
Graph-based γ136400:05.211438.5101:34.75
Genetic141200:10.561484.7201:40.72
Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Share and Cite

MDPI and ACS Style

Stastny, J.; Skorpil, V.; Balogh, Z.; Klein, R. Job Shop Scheduling Problem Optimization by Means of Graph-Based Algorithm. Appl. Sci. 2021, 11, 1921. https://doi.org/10.3390/app11041921

AMA Style

Stastny J, Skorpil V, Balogh Z, Klein R. Job Shop Scheduling Problem Optimization by Means of Graph-Based Algorithm. Applied Sciences. 2021; 11(4):1921. https://doi.org/10.3390/app11041921

Chicago/Turabian Style

Stastny, Jiri, Vladislav Skorpil, Zoltan Balogh, and Richard Klein. 2021. "Job Shop Scheduling Problem Optimization by Means of Graph-Based Algorithm" Applied Sciences 11, no. 4: 1921. https://doi.org/10.3390/app11041921

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop