diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
index d646dc1..d76e03b 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
@@ -14,46 +14,27 @@ public class AStarAlgorithm extends DijkstraAlgorithm {
         super(data);
     }
 
-    @Override
-    protected void initializeHeap(ShortestPathData data) {
-        System.out.println("==> Initialisation du tas binaire (LabelStar)");
-        final HashMap<Integer, Label> labels = new HashMap<>(); // clé-valeur pour retrouver le label associé à un noeud à partir de son id
-        final BinaryHeap<Label> heap = new BinaryHeap<>(); // tas binaire pour retrouver le min en temps constant
-        final Double estimation = data.getDestination().getPoint().distanceTo(data.getOrigin().getPoint());
-        // Au lieu de mettre des Labels, on met des LabelStar, comme ça la comparaison prend en compte l'estimation
-        final LabelStar label = new LabelStar(data.getOrigin(), null, 0.0, false, estimation);
-        heap.insert(label);
-        labels.put(data.getOrigin().getId(), label);
-        System.out.println("==> Tas initialisé (LabelStar)");
-
-        this.heap = heap;
-        this.labels = labels;
-    }
-
     @Override
     protected Label createLabel(Node node) {
-        return new LabelStar(node);
-    }
+        final LabelStar labelStar = new LabelStar(node);
+        final ShortestPathData data = (ShortestPathData)this.data;
+        final Double distance = data.getDestination().getPoint().distanceTo(node.getPoint()); // en mètres
+        
+        switch (data.getMode()) {
+            case LENGTH:
+                labelStar.setCoutEstime(distance); // en mètres
+                break;
 
-    @Override
-    protected void updateLabel(Label label, Arc arc) {
-        //System.out.println("==> updateLabel(" + label + ")");
-        final Label originLabel = this.labels.get(arc.getOrigin().getId());
-        label.setCoutRealise(originLabel.getCoutRealise() + data.getCost(arc));
-        label.setArc(arc);
-
-        // Distance entre l'objectif final et là ou on en est
-        final Double distance = ((ShortestPathData)this.data).getDestination().getPoint().distanceTo(arc.getDestination().getPoint()); // en m
-        if (((ShortestPathData)this.data).getMode() == Mode.LENGTH) {
-            ((LabelStar)label).setCoutEstime(distance); // en m
-        } else { // TIME
-            final Double speed = ((ShortestPathData)this.data).getMaximumSpeed()/3.6; // en m/s
-            ((LabelStar)label).setCoutEstime(distance/speed); // en sec
+            case TIME:
+                final Double speed = 1.5*(data.getMaximumSpeed()/3.6); // km/h converti en m/s, +50% pour garantir que l'estimation est une bonne strictement inférieure
+                labelStar.setCoutEstime(distance/speed); // en secondes
+                break;
+        
+            default:
+                break;
         }
-            
 
-        this.heap.insert(label);
-        this.labels.put(arc.getDestination().getId(), label);
+        return labelStar;
     }
 
 }
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
index beb962d..6f13a93 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
@@ -3,6 +3,7 @@ package org.insa.graphs.algorithm.shortestpath;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Optional;
 
 import org.insa.graphs.algorithm.AbstractSolution.Status;
 import org.insa.graphs.algorithm.utils.BinaryHeap;
@@ -18,92 +19,80 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
         super(data);
     }
 
-    protected HashMap<Integer, Label> labels = new HashMap<>();
-    protected BinaryHeap<Label> heap = new BinaryHeap<>();
+    protected HashMap<Integer, Label> labels; // clé-valeur pour retrouver le label associé à un noeud à partir de son id
+    protected BinaryHeap<Label> heap; // tas binaire pour retrouver le min en temps constant
 
-    // L'initialisation du tas et de la hashmap sont déportés dans une fonction, afin de pouvoir override cette dernière pour l'algo A*
-    // On retourne un Tuple (classe crée pour l'occasion dans le package utils) avec le tas binaire et la hashmap.
-    protected void initializeHeap(ShortestPathData data) {
-        System.out.println("==> Initialisation du tas binaire (Label)");
-        final HashMap<Integer, Label> labels = new HashMap<>(); // clé-valeur pour retrouver le label associé à un noeud à partir de son id
-        final BinaryHeap<Label> heap = new BinaryHeap<>(); // tas binaire pour retrouver le min en temps constant
-        final Label label = new Label(data.getOrigin(), null, 0.0, false);
-        heap.insert(label);
-        labels.put(data.getOrigin().getId(), label);
-        System.out.println("==> Tas initialisé (Label)");
-
-        this.heap = heap;
-        this.labels = labels;
-    }
 
     // Fonction pour créer un label inexistant, à override pour utiliser les LabelStar
     protected Label createLabel(Node node) {
         return new Label(node);
     }
 
-    // Fonction de MAJ d'un label, à override pour mettre a jour l'estimation du labelstar
-    protected void updateLabel(Label label, Arc arc) {
-        //System.out.println("==> updateLabel(" + label + ")");
-        final Label originLabel = this.labels.get(arc.getOrigin().getId());
-        label.setCoutRealise(originLabel.getCoutRealise() + data.getCost(arc));
-        label.setArc(arc);
-        this.heap.insert(label);
-        this.labels.put(arc.getDestination().getId(), label);
-    }
-
     @Override
     protected ShortestPathSolution doRun() {
         final ShortestPathData data = getInputData();
 
-        this.initializeHeap(data);
+        this.labels = new HashMap<>(); 
+        this.heap = new BinaryHeap<>(); 
+        
+        Label currentLabel = this.createLabel(data.getOrigin());
+        currentLabel.setCoutRealise(0D);
+        this.heap.insert(currentLabel);
+        this.labels.put(data.getOrigin().getId(), currentLabel);
 
-        System.out.println("==> Dijkstra commence");
-        notifyOriginProcessed(data.getOrigin());
-        Label currentLabel = null;
         boolean destinationReached = false;
-        while (!destinationReached && !this.heap.isEmpty() && (currentLabel=this.heap.deleteMin()) != null) {
-            //System.out.println(currentLabel instanceof LabelStar ? ((LabelStar)currentLabel).toString() : currentLabel.toString());
+        notifyOriginProcessed(data.getOrigin());
+        while (!destinationReached && !this.heap.isEmpty() && currentLabel != null) {
             if (currentLabel.getTotalCost() == Double.MAX_VALUE)
                 break;
+            
+            final Node currentNode = currentLabel.getNode();
+            //System.out.println("currentNode = " + currentNode);
 
             currentLabel.setMarque(true);
+            notifyNodeMarked(currentNode);
             // On constate que les coûts des sommets marqués est bel et bien croissant
-            //System.out.println("-> Sommet marqué: " + currentLabel.getCoutRealise());
-            notifyNodeMarked(currentLabel.getNode());
+            // System.out.println("-> Sommet marqué: " + currentLabel.getCoutRealise());
 
             // Si on atteint notre destination, on arrête l'algo
-            if (currentLabel.getNode().equals(data.getDestination())) {
+            if (currentNode.equals(data.getDestination())) {
                 destinationReached = true;
             } else {
-                for (Arc arc : currentLabel.getNode().getSuccessors()) {
+                for (final Arc arc : currentNode.getSuccessors()) {
                     if (data.isAllowed(arc)) {
-                        Label successorLabel = this.labels.get(arc.getDestination().getId());
-                        if (successorLabel == null) successorLabel = this.createLabel(arc.getDestination());
+                        final Node successorNode = arc.getDestination();
+                        //System.out.println("successorNode = " + successorNode);
+                        final Label successorLabel = Optional.ofNullable(this.labels.get(successorNode.getId())).orElse(this.createLabel(successorNode));
+                        //System.out.println("successorLabel = " + successorLabel);
+
                         if (successorLabel.getTotalCost() > currentLabel.getTotalCost() + data.getCost(arc)) {
                             try {
-                                heap.remove(successorLabel);
+                                this.heap.remove(successorLabel);
                             } catch(ElementNotFoundException e) {
                                 // BinaryHeap#remove a échoué, donc ça veut dire qu'on doit juste insérer, pas mettre à jour, mais ça ne change rien au niveau du code
                             }
 
-                            this.updateLabel(successorLabel, arc);
-                            notifyNodeReached(arc.getDestination());
+                            notifyNodeReached(successorNode);
+
+                            successorLabel.setCoutRealise(currentLabel.getCoutRealise() + data.getCost(arc));
+                            successorLabel.setArc(arc);
+                            this.heap.insert(successorLabel);
+                            this.labels.put(successorNode.getId(), successorLabel);
                         }
                     }
                 }
+                currentLabel = heap.deleteMin();
             }
         }
 
         ShortestPathSolution solution = null;
         if (destinationReached) {
             notifyDestinationReached(data.getDestination());
-            System.out.println("==> Dijkstra termine et a trouvé");
 
-            // On part de la fin, et on remonte petit à petit vers le sommet d'origine
-            System.out.println("==> On recompose le chemin");
-            
-            List<Arc> arcs = new ArrayList<>();Node currentNode = data.getDestination();
-            while(currentNode != data.getOrigin()) {
+            // On part de la fin, et on remonte petit à petit vers le sommet d'origine          
+            final List<Arc> arcs = new ArrayList<>();
+            Node currentNode = data.getDestination();
+            while (currentNode != data.getOrigin()) {
                 final Arc arc = labels.get(currentNode.getId()).getArc();
                 if (arc != null) {
                     arcs.add(arc);
@@ -112,12 +101,10 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
                     break;
                 }
             }
-            System.out.println("==> Fini");
 
-            Path path = new Path(data.getGraph(), arcs.reversed());
+            final Path path = new Path(data.getGraph(), arcs.reversed());
             solution = new ShortestPathSolution(data, Status.OPTIMAL, path);
         } else {
-            System.out.println("==> Dijkstra termine mais n'a pas trouvé");
             solution = new ShortestPathSolution(data, Status.INFEASIBLE);
         }