SPT and LRPT finished and tested

src/main/java/jobshop/solvers/GreedySolver.java

@@ -34,7 +34,12 @@ public class GreedySolver implements Solver {
         return instance.duration(t);
     }
     private Integer heuristiqueLRPT(Task t, Instance instance){
-        return instance.duration(t);
+        int sum = 0;
+        // we sum all durations starting at the current tasks' in the job
+        for (int i = t.task; i < instance.numTasks; i++){
+            sum += instance.duration(t.job, i);
+        }
+        return sum;
     }
     private Integer heuristiqueEST_SPT(Task t, Instance instance){
         return instance.duration(t);
@@ -58,29 +63,71 @@ public class GreedySolver implements Solver {
                     .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
                     .toArray(Task[]::new)[0]
                 );
-                break;
             case LPT:
-                break;
+                // TODO
+                return(
+                        lTask.stream()
+                                .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
+                                .toArray(Task[]::new)[0]
+                );
             case SRPT:
-                break;
+                // TODO
+                return(
+                        lTask.stream()
+                                .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
+                                .toArray(Task[]::new)[0]
+                );
             case LRPT:
-                break;
+                return(
+                        lTask.stream()
+                                .max(Comparator.comparing(e -> heuristiqueLRPT(e, instance)))
+                                .get() // it returns an optional
+                );
             case EST_SPT:
-                break;
+                // TODO
+                return(
+                        lTask.stream()
+                                .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
+                                .toArray(Task[]::new)[0]
+                );
             case EST_LPT:
-                break;
+                // TODO
+                return(
+                        lTask.stream()
+                                .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
+                                .toArray(Task[]::new)[0]
+                );
             case EST_SRPT:
-                break;
+                // TODO
+                return(
+                        lTask.stream()
+                                .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
+                                .toArray(Task[]::new)[0]
+                );
             case EST_LRPT:
-                break;
+                // TODO
+                return(
+                        lTask.stream()
+                                .sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
+                                .toArray(Task[]::new)[0]
+                );
         }
+        return null;
     }
 
 
 
     @Override
     public Optional<Schedule> solve(Instance instance, long deadline) {
+        // keeps track of the next time the machine is free
+        int[] statusMachines = new int[instance.numMachines];
+        // keeps track of the next time the job is free
+        int[] statusJobs = new int[instance.numJobs];
+        Arrays.fill(statusMachines,0);
+        Arrays.fill(statusJobs,0);
 
+        int time ;
+        Schedule schedule = new Schedule(instance);
         ArrayList<Task> possibleTasks = new ArrayList<>();
         /* Initialization */
         for (int i = 0; i < instance.numJobs; i++){
@@ -91,12 +138,20 @@ public class GreedySolver implements Solver {
         while(possibleTasks.size() > 0){
             Task task = min(possibleTasks,instance);
             possibleTasks.remove(task);
-            // TODO : Add task to the solution
+
+            // Update schedule
+            time = Integer.max(statusMachines[instance.machine(task)], statusJobs[task.job]);
+            schedule.setStartTime(task.job, task.task, time);
+
+            // recalculate next free time for job/machine
+            statusMachines[instance.machine(task)] = time + instance.duration(task);
+            statusJobs[task.job] = time + instance.duration(task);
             if ((task.task + 1) < instance.numTasks){
                 possibleTasks.add(new Task(task.job, task.task+1));
             }
         }
 
+        return Optional.of(schedule);
     }
 
 

src/main/java/jobshop/solvers/Solver.java

@@ -22,6 +22,7 @@ public interface Solver {
         switch (name) {
             case "basic": return new BasicSolver();
             case "spt": return new GreedySolver(GreedySolver.Priority.SPT);
+            case "lrpt": return new GreedySolver(GreedySolver.Priority.LRPT);
             // TODO: add new solvers
             default: throw new RuntimeException("Unknown solver: "+ name);
         }