From 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0 Mon Sep 17 00:00:00 2001
From: Matteo <sabben@insa-toulouse.fr>
Date: Mon, 26 May 2025 18:21:48 +0200
Subject: [PATCH 1/3] correction fastest path pour A* et avancement
 ProblemeOuvert

---
 .../shortestpath/AStarAlgorithm.java          |   3 +-
 .../shortestpath/LabelProblemeOuvert          |  16 --
 .../shortestpath/LabelProblemeOuvert.java     |  30 ++++
 .../algorithm/shortestpath/LabelStar.java     |  55 ++++++-
 .../shortestpath/ProblemeOuvert.java          | 150 ++++++++++++++++++
 5 files changed, 230 insertions(+), 24 deletions(-)
 delete mode 100644 be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert
 create mode 100644 be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java

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 4db278f..29df1a0 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
@@ -9,7 +9,8 @@ public class AStarAlgorithm extends DijkstraAlgorithm {
     
     @Override
     protected LabelStar createLabel(Node node) {
-        return new LabelStar(node, false, Double.POSITIVE_INFINITY, null, getInputData().getDestination());
+        ShortestPathData data = getInputData(); //pour récupérer la vitesse maximale du graphe, la destination et si on est en fastestpath ou shortestpath
+        return new LabelStar(node, false, Double.POSITIVE_INFINITY,null,data);
     }
 
 
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert
deleted file mode 100644
index 3478429..0000000
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert
+++ /dev/null
@@ -1,16 +0,0 @@
-/*public class LabelProblemeOuvert extends Label {
-    private double autonomieRestante;
-
-    public LabelProblemeOuvert(Node sommet, boolean marque, double cout, Arc pere, double autonomieRestante) {
-        super(sommet, marque, cout, pere);
-        this.autonomieRestante = autonomieRestante;
-    }
-
-    public double getAutonomieRestante() {
-        return autonomieRestante;
-    }
-
-    public void setAutonomieRestante(double autonomieRestante) {
-        this.autonomieRestante = autonomieRestante;
-    }
-}*/
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
new file mode 100644
index 0000000..e4f32fd
--- /dev/null
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
@@ -0,0 +1,30 @@
+package org.insa.graphs.algorithm.shortestpath;
+
+import org.insa.graphs.model.Arc;
+import org.insa.graphs.model.Node;
+public class LabelProblemeOuvert extends Label {
+    private double autonomieRestante; //double pour la cohérence avec les autres couts qui sont en double eux aussi
+
+    public LabelProblemeOuvert(Node sommet, boolean marque, double cout, Arc pere, double autonomieRestante) {
+        super(sommet, marque, cout, pere);
+        this.autonomieRestante = autonomieRestante;
+    }
+
+    public double getAutonomieRestante() {
+        return autonomieRestante;
+    }
+
+    public void setAutonomieRestante(double autonomieRestante) {
+        this.autonomieRestante = autonomieRestante;
+    }
+
+    @Override
+    public double getTotalCost() { //normalement pas besoin
+            return this.getCoutRealise();
+    }
+
+    /*@Override
+    public int compareTo(LabelProblemeOuvert other) {
+        return Double.compare(this.getTotalCost(), other.getTotalCost());
+    }*/
+}
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java
index 3ebdc92..88a9240 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java
@@ -1,5 +1,6 @@
 package org.insa.graphs.algorithm.shortestpath;
 
+import org.insa.graphs.algorithm.AbstractInputData;
 import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Node;
 import org.insa.graphs.model.Point;
@@ -7,30 +8,70 @@ import org.insa.graphs.model.Point;
 
 
 public class LabelStar extends Label {
-
-    private Node destination;
-    public LabelStar(Node sommetCourant, Boolean marque, double coutRealise, Arc pere,Node destination) {
+;
+    private ShortestPathData pathData;
+    public LabelStar(Node sommetCourant, Boolean marque, double coutRealise, Arc pere, ShortestPathData data) {
         super(sommetCourant, marque, coutRealise, pere);
-        this.destination=destination;  
+        this.pathData = data; //pour récupérer la vitesse maximale du graphe, la destination et si on est en fastestpath ou shortestpath
     }
 
 
     //pour optimiser l'algo : ATTENTION PAS à L'initialisation pas le faire sinon ça va le faire pr tout les pts
     //on rajoute un paremètre distance ds le label et quand on passe sur le label si c'est linfini on le calcule
 
-    @Override
+    /*@Override
     public double getTotalCost() { //pourquoi getTotalCost ? psq il est utilisé dans le compareTo
         //System.out.println("cout realise : " + getCoutRealise()+ "\n distance : "distance(getSommetCourant().getPoint(),this.destination.getPoint()));
         double cout=getCoutRealise();
-        Point calcul = this.destination.getPoint();
+        Point calcul = this.pathData.getDestination().getPoint();
         cout+=calcul.distanceTo(this.getSommetCourant().getPoint());
         return (cout); 
-    }
+    }*/
 
     //pas nécessaire normalement
     /*public int compareTo(LabelStar other) {
         return Double.compare(this.getTotalCost(), other.getTotalCost());
     }*/
     
+    /**
+     * Calcule le coût total estimé (f = g + h) pour l'algorithme A*.
+     * g (getCoutRealise()) est le coût actuel depuis le départ.
+     * h est l'heuristique :
+     * - En mode DISTANCE: distance à vol d'oiseau (via distanceTo) jusqu'à la destination.
+     * - En mode TEMPS: distance à vol d'oiseau (via distanceTo) / vitesse maximale sur le graphe.
+     * @return Le coût total estimé.
+     */
+    @Override
+    public double getTotalCost() {
+        double gCost = getCoutRealise(); // Coût actuel depuis l'origine (distance ou temps)
+        double hCost = 0.0;              
+
+        Node current = getSommetCourant();
+        Node destinationNode = this.pathData.getDestination(); // Obtention de la destination depuis pathData
+        Point currentPoint = current.getPoint();
+        Point destinationPoint = destinationNode.getPoint();
+        if (currentPoint == null || destinationPoint == null) {
+            return gCost; // Heuristique nulle si points non valides
+        }
+
+        //calcul vol d'oiseau
+        double distanceToDestinationMeters = currentPoint.distanceTo(destinationPoint);
+
+        //différencier TIME et DISTANCE
+        if (this.pathData.getMode() == AbstractInputData.Mode.TIME) {
+            int maxSpeedKmH = this.pathData.getGraph().getGraphInformation().getMaximumSpeed();
+
+            // Conversion de la vitesse max en mètres par seconde (m/s)
+            double maxSpeedMpS = maxSpeedKmH / 3.6;
+            hCost = distanceToDestinationMeters / maxSpeedMpS; // hCost est maintenant en secondes
+
+        } else {
+            // Heuristique pour le mode DISTANCE (ou par défaut)
+            hCost = distanceToDestinationMeters; // hCost est en mètres
+        }
+
+        return gCost + hCost;
+    }
+
 }
  
\ No newline at end of file
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
index 0658cce..d66b785 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
@@ -106,3 +106,153 @@ gérer le problème de la recharge, quand la faire ?
 */
 
 
+package org.insa.graphs.algorithm.shortestpath;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import org.insa.graphs.algorithm.AbstractSolution.Status;
+import org.insa.graphs.algorithm.utils.BinaryHeap;
+import org.insa.graphs.model.Arc;
+import org.insa.graphs.model.Graph;
+import org.insa.graphs.model.Node;
+import org.insa.graphs.model.Path;
+import org.insa.graphs.model.RoadInformation.RoadType;
+//import org.insa.graphs.algorithm.shortestpath.ProblemeOuvert;
+
+public class ProblemeOuvert extends DijkstraAlgorithm {
+
+
+    private double MAX_BATTERY = 200;
+
+    public ProblemeOuvert(ShortestPathData data) {
+        super(data);
+    }
+
+    @Override
+    protected LabelProblemeOuvert createLabel(Node node) {
+        return new LabelProblemeOuvert(node, false, Double.POSITIVE_INFINITY, null, MAX_BATTERY);
+    }
+
+    protected void tryUpdateLabel(LabelProblemeOuvert[] labels, BinaryHeap<Label> heap, Node node,
+                               double newCost, double newBatteryLeft, Arc pere, Arc[] tableauArcs) {
+
+        LabelProblemeOuvert label = labels[node.getId()];
+
+        if (newCost < label.getCoutRealise()) {
+            if (label.getCoutRealise() != Double.POSITIVE_INFINITY) {
+                heap.remove(label);
+            }
+
+            label.setCoutRealise(newCost);
+            label.setAutonomieRestante(newBatteryLeft);
+            label.setPere(pere);
+
+            tableauArcs[pere.getDestination().getId()] = pere;
+
+            heap.insert(label);
+            notifyNodeReached(node);
+
+        }
+
+    }
+
+    /*@Override
+    protected void fonctionProblemeOuvert(RoadType typeDeRoute,LabelProblemeOuvert[] labels, BinaryHeap<LabelProblemeOuvert> heap, Node node,
+                               double newCost, Arc pere){
+        if (typeDeRoute == RoadType.MOTORWAY) {
+            tryUpdateLabel(labels, heap,node, newCost, MAX_BATTERY, pere);
+        }
+    }*/
+
+    
+    @Override
+    protected ShortestPathSolution doRun() {
+
+        final ShortestPathData data = getInputData();
+        ShortestPathSolution solution = null;
+        // accès au graphe
+        Graph graph = data.getGraph();
+        int nbNodes = graph.size();
+
+        // Tableau des labels pour chaque sommet
+        LabelProblemeOuvert[] labels = new LabelProblemeOuvert[nbNodes];
+        // Tableau des arcs prédécesseurs pour reconstruire le chemin
+        Arc[] predecessorArcs = new Arc[nbNodes];
+
+        // Initialisation des labels
+        for (Node node : graph.getNodes()) {
+            labels[node.getId()] =createLabel(node);
+        }
+        // Origine : coût 0, non marqué, pas de père
+        labels[data.getOrigin().getId()].setCoutRealise(0);
+
+        BinaryHeap<Label> heap = new BinaryHeap<>();
+        heap.insert(labels[data.getOrigin().getId()]);
+
+        notifyOriginProcessed(data.getOrigin());
+
+        while (!heap.isEmpty()) {
+            Label LabelActuel = heap.deleteMin();
+            Node NodeActuel = LabelActuel.getSommetCourant();
+
+            // sommet traité
+            LabelActuel.setMarque(true);
+
+            // On a atteint la destination on s'arrête
+            if (NodeActuel.equals(data.getDestination())) {
+                notifyDestinationReached(NodeActuel);
+                break;
+            }
+
+            // Pour chaque successeur
+            for (Arc arc : NodeActuel.getSuccessors()) {
+                     if (!data.isAllowed(arc)) continue; // ici c'est pour l'amélioration voiture ou a pied
+
+
+                    Node succ = arc.getDestination();
+                    LabelProblemeOuvert succLabel = labels[succ.getId()];
+
+                    if (succLabel.getMarque()) continue;
+
+                    double arcCost = data.getCost(arc);
+                    double batteryLeft = ((LabelProblemeOuvert) LabelActuel).getAutonomieRestante();
+
+                    if (batteryLeft < arcCost) continue; // Pas assez de batterie pour ce chemin
+
+                    double newCost = LabelActuel.getCoutRealise() + arcCost;
+                    double newBatteryLeft = batteryLeft - arcCost;
+
+                    // 1. On fais le test d'avant qui vérfie si le coût avec ce chemin est meilleur
+                    tryUpdateLabel(labels, heap, succ, newCost, newBatteryLeft, arc,predecessorArcs);
+
+                    // 2. On fait aussi le test avec une autonmie pleine pour voir si la solution est meilleure (il faudra rajouter 2mn au temps de trajet)
+                    //si on recharge effectivement et détecter cette recharge
+                    if (arc.getRoadInformation().getType() == RoadType.MOTORWAY) {
+                        tryUpdateLabel(labels, heap, succ, newCost, MAX_BATTERY, arc,predecessorArcs);
+                    }
+            }
+        }
+
+        // Construction de la solution
+        if (predecessorArcs[data.getDestination().getId()] == null) {
+            solution = new ShortestPathSolution(data, Status.INFEASIBLE);
+        }
+        else {
+            // Reconstruire le chemin
+            ArrayList<Arc> arcs = new ArrayList<>();
+            Arc arc = predecessorArcs[data.getDestination().getId()];
+            while (arc != null) {
+                arcs.add(arc);
+                arc = predecessorArcs[arc.getOrigin().getId()];
+            }
+            Collections.reverse(arcs);// on inverse le chemin
+            solution = new ShortestPathSolution(data, Status.OPTIMAL,new Path(graph, arcs));
+        }
+
+        return solution;
+    }
+
+}
+
+

From fe280a1f4252ec69bc1598fcc61e0dc4a86b1fb1 Mon Sep 17 00:00:00 2001
From: bezza <bezza@git.etud.insa-toulouse.fr>
Date: Mon, 26 May 2025 18:28:48 +0200
Subject: [PATCH 2/3] ajout test probleme ouvert dijkstra

---
 .../shortestpath/DijkstraAlgorithm.java       |  40 ++--
 .../shortestpath/LabelProblemeOuvert          |  16 --
 .../shortestpath/LabelProblemeOuvert.java     |  26 +++
 .../shortestpath/ProblemeOuvert.java          | 197 +++++++++++++++++-
 .../insa/graphs/gui/simple/TestDijkstra.java  |  69 +++---
 5 files changed, 276 insertions(+), 72 deletions(-)
 delete mode 100644 be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert
 create mode 100644 be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java

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 110c233..3abd48c 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
@@ -9,7 +9,7 @@ import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Graph;
 import org.insa.graphs.model.Node;
 import org.insa.graphs.model.Path;
-
+import org.insa.graphs.model.RoadInformation.RoadType;
 
 public class DijkstraAlgorithm extends ShortestPathAlgorithm {
 
@@ -21,6 +21,29 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
         return new Label(node, false, Double.POSITIVE_INFINITY, null);
     }
 
+    protected void tryUpdateLabel(Label[] labels, BinaryHeap<Label> heap, Node node,
+                               double newCost, Arc pere) {
+
+        Label label = labels[node.getId()];
+
+        if (newCost < label.getCoutRealise()) {
+            if (label.getCoutRealise() != Double.POSITIVE_INFINITY) {
+                heap.remove(label);
+            }
+
+            label.setCoutRealise(newCost);
+            label.setPere(pere);
+
+            heap.insert(label);
+            notifyNodeReached(node);
+
+        }
+
+    }
+
+    protected void fonctionProblemeOuvert(RoadType typeDeRoute,Label[] labels, BinaryHeap<Label> heap, Node node,
+                               double newCost, Arc pere){}
+
 
     @Override
     protected ShortestPathSolution doRun() {
@@ -75,21 +98,10 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
                 // Correction ici : on utilise getCoutRealise() pour Dijkstra
                 double newCost = LabelActuel.getCoutRealise() + data.getCost(arc);
 
-                if (newCost < succLabel.getCoutRealise()) {
-                    if (succLabel.getCoutRealise() != Double.POSITIVE_INFINITY) {
-                        heap.remove(succLabel);
-                        //System.out.println(succLabel.getTotalCost());// print de confirmation , pour verif si tous les couts qui sortent du tas sont croissant. getTotalcost pas croissant!!
-                    }
-                    succLabel.setCoutRealise(newCost);
-                    succLabel.setPere(arc);
-                    predecessorArcs[succ.getId()] = arc;
+                tryUpdateLabel(labels, heap, succ, newCost, arc);
 
-                    // Insertion dans le tas car on est sûr qu'il n'est pas 
-                    
-                    heap.insert(succLabel);
+                fonctionProblemeOuvert(arc.getRoadInformation().getType(),labels, heap, succ, newCost, arc); //fonction uniquement pour probleme ouvert, permet de ne pas réécrire l'algorithme pour le problème ouvert
 
-                    notifyNodeReached(succ);
-                }
             }
         }
 
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert
deleted file mode 100644
index 3478429..0000000
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert
+++ /dev/null
@@ -1,16 +0,0 @@
-/*public class LabelProblemeOuvert extends Label {
-    private double autonomieRestante;
-
-    public LabelProblemeOuvert(Node sommet, boolean marque, double cout, Arc pere, double autonomieRestante) {
-        super(sommet, marque, cout, pere);
-        this.autonomieRestante = autonomieRestante;
-    }
-
-    public double getAutonomieRestante() {
-        return autonomieRestante;
-    }
-
-    public void setAutonomieRestante(double autonomieRestante) {
-        this.autonomieRestante = autonomieRestante;
-    }
-}*/
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
new file mode 100644
index 0000000..798459c
--- /dev/null
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
@@ -0,0 +1,26 @@
+package org.insa.graphs.algorithm.shortestpath;
+
+import org.insa.graphs.model.Arc;
+import org.insa.graphs.model.Node;
+
+public class LabelProblemeOuvert extends Label {
+    private double batteryLeft; //double pour la cohérence avec les autres couts qui sont en double eux aussi
+
+    public LabelProblemeOuvert(Node sommet, boolean marque, double cout, Arc pere, double batteryLeft) {
+        super(sommet, marque, cout, pere);
+        this.batteryLeft = batteryLeft;
+    }
+
+    public double getBatteryLeft() {
+        return batteryLeft;
+    }
+
+    public void setBatteryLeft(double batteryLeft) {
+        this.batteryLeft = batteryLeft;
+    }
+
+    @Override
+    public double getTotalCost() { //pourquoi getTotalCost ? psq il est utilisé dans le compareTo
+            return this.getCoutRealise();
+    }
+}
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
index 0658cce..3466b03 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
@@ -1,6 +1,3 @@
-
-
-
 /*  je considère que les 200km d'autonomie atteint (200km avec le 22 kWh - Q90 Renault ZOE chargé à 90%)
     cette autonomie est considéré en ville à 200km (à 30km/h de moyenne)
     en mixte elle devient 154 km (47km/h de moyenne) ~3/4 de l'autonmie
@@ -106,3 +103,197 @@ gérer le problème de la recharge, quand la faire ?
 */
 
 
+package org.insa.graphs.algorithm.shortestpath;
+
+import org.insa.graphs.algorithm.AbstractSolution.Status;
+import org.insa.graphs.algorithm.utils.BinaryHeap;
+import org.insa.graphs.model.Arc;
+import org.insa.graphs.model.Graph;
+import org.insa.graphs.model.Node;
+import org.insa.graphs.model.RoadInformation.RoadType;
+
+
+public class ProblemeOuvert extends DijkstraAlgorithm {
+
+
+    private double MAX_BATTERY = 200;
+
+    public ProblemeOuvert(ShortestPathData data) {
+        super(data);
+    }
+
+    @Override
+    protected LabelProblemeOuvert createLabel(Node node) {
+        return new LabelProblemeOuvert(node, false, Double.POSITIVE_INFINITY, null, MAX_BATTERY);
+    }
+
+    // Surcharge pour compatibilité avec DijkstraAlgorithm
+    @Override
+    protected void tryUpdateLabel(Label[] labels, BinaryHeap<Label> heap, Node node,
+                                  double newCost, Arc pere) {
+        // Si c'est bien un label de probleme ouvert, on applique la logique spécifique
+        if (labels instanceof LabelProblemeOuvert[]) {
+            LabelProblemeOuvert[] plabels = (LabelProblemeOuvert[]) labels;
+            double batteryLeft = plabels[node.getId()].getBatteryLeft();
+            tryUpdateLabelSpecifique(plabels, heap, node, newCost, batteryLeft, pere);
+        } else {
+            // Sinon, on garde le comportement normal du Dijkstra
+            super.tryUpdateLabel(labels, heap, node, newCost, pere);
+        }
+    }
+
+    // Version spécifique pour le problème ouvert (pas d'@Override ici)
+    protected void tryUpdateLabelSpecifique(LabelProblemeOuvert[] labels, BinaryHeap<Label> heap, Node node,
+                                  double newCost, double newBatteryLeft, Arc pere) {
+        LabelProblemeOuvert label = labels[node.getId()];
+
+        // On ne met à jour que si on a assez de batterie
+        if (newBatteryLeft < 0) return;
+
+        if (newCost < label.getCoutRealise() || (Math.abs(newCost - label.getCoutRealise()) < 1e-6 && newBatteryLeft > label.getBatteryLeft())) {
+            if (label.getCoutRealise() != Double.POSITIVE_INFINITY) {
+                heap.remove(label);
+            }
+
+            label.setCoutRealise(newCost);
+            label.setBatteryLeft(newBatteryLeft);
+            label.setPere(pere);
+
+            heap.insert(label);
+            notifyNodeReached(node);
+        }
+    }
+
+    // Surcharge pour compatibilité avec DijkstraAlgorithm
+    // (Pas d'@Override ici car il n'y a pas de méthode à surcharger dans la superclasse)
+    protected void fonctionProblemeOuvert(RoadType typeDeRoute, Label[] labels, BinaryHeap<Label> heap, Node node,
+                                          double newCost, Arc pere) {
+        // Si c'est bien un label de probleme ouvert, on applique la logique spécifique
+        if (labels instanceof LabelProblemeOuvert[]) {
+            fonctionProblemeOuvertSpecifique(typeDeRoute, (LabelProblemeOuvert[]) labels, heap, node, newCost, pere);
+        } else {
+            // Sinon, on garde le comportement normal du Dijkstra
+            super.fonctionProblemeOuvert(typeDeRoute, labels, heap, node, newCost, pere);
+        }
+    }
+
+    // Version spécifique pour le problème ouvert (pas d'@Override ici)
+    protected void fonctionProblemeOuvertSpecifique(RoadType typeDeRoute, LabelProblemeOuvert[] labels, BinaryHeap<Label> heap, Node node,
+                                          double newCost, Arc pere) {
+        if (typeDeRoute == RoadType.MOTORWAY) {
+            tryUpdateLabelSpecifique(labels, heap, node, newCost, MAX_BATTERY, pere);
+        }
+    }
+
+    @Override
+    protected ShortestPathSolution doRun() {
+
+        final ShortestPathData data = getInputData();
+        ShortestPathSolution solution = null;
+        Graph graph = data.getGraph();
+        int nbNodes = graph.size();
+
+        // Tableau des labels pour chaque sommet
+        LabelProblemeOuvert[] labels = new LabelProblemeOuvert[nbNodes];
+        // Tableau des arcs prédécesseurs pour reconstruire le chemin
+        Arc[] predecessorArcs = new Arc[nbNodes];
+
+        // Initialisation des labels
+        for (Node node : graph.getNodes()) {
+            labels[node.getId()] = createLabel(node);
+        }
+        // Origine : coût 0, batterie pleine
+        labels[data.getOrigin().getId()].setCoutRealise(0);
+        labels[data.getOrigin().getId()].setBatteryLeft(MAX_BATTERY);
+
+        BinaryHeap<Label> heap = new BinaryHeap<>();
+        heap.insert(labels[data.getOrigin().getId()]);
+
+        notifyOriginProcessed(data.getOrigin());
+
+        while (!heap.isEmpty()) {
+            LabelProblemeOuvert currentLabel = (LabelProblemeOuvert) heap.deleteMin();
+            Node currentNode = currentLabel.getSommetCourant();
+
+            // sommet traité
+            currentLabel.setMarque(true);
+
+            // On a atteint la destination on s'arrête
+            if (currentNode.equals(data.getDestination())) {
+                notifyDestinationReached(currentNode);
+                break;
+            }
+
+            // Pour chaque successeur
+            for (Arc arc : currentNode.getSuccessors()) {
+                if (!data.isAllowed(arc)) continue;
+
+                Node succ = arc.getDestination();
+                LabelProblemeOuvert succLabel = labels[succ.getId()];
+
+                if (succLabel.getMarque()) continue;
+
+                double arcCost = data.getCost(arc);
+                double batteryLeft = currentLabel.getBatteryLeft();
+
+                // Calcul de la batterie restante après avoir parcouru l'arc
+                double newBatteryLeft = batteryLeft - arcCost;
+                double newCost = currentLabel.getCoutRealise() + arcCost;
+
+                // Si pas assez de batterie, on ne continue pas
+                if (newBatteryLeft < 0) continue;
+
+                // Mise à jour du label si meilleur coût ou plus de batterie à coût égal
+                if (newCost < succLabel.getCoutRealise() ||
+                    (Math.abs(newCost - succLabel.getCoutRealise()) < 1e-6 && newBatteryLeft > succLabel.getBatteryLeft())) {
+                    if (succLabel.getCoutRealise() != Double.POSITIVE_INFINITY) {
+                        heap.remove(succLabel);
+                    }
+                    succLabel.setCoutRealise(newCost);
+                    succLabel.setBatteryLeft(newBatteryLeft);
+                    succLabel.setPere(arc);
+                    heap.insert(succLabel);
+                    notifyNodeReached(succ);
+                }
+
+                // Si on arrive sur une autoroute, possibilité de recharger
+                if (arc.getRoadInformation().getType() == RoadType.MOTORWAY) {
+                    double rechargeCost = newCost; // ici, pas de coût supplémentaire pour la recharge
+                    double rechargeBattery = MAX_BATTERY;
+                    if (rechargeCost < succLabel.getCoutRealise() ||
+                        (Math.abs(rechargeCost - succLabel.getCoutRealise()) < 1e-6 && rechargeBattery > succLabel.getBatteryLeft())) {
+                        if (succLabel.getCoutRealise() != Double.POSITIVE_INFINITY) {
+                            heap.remove(succLabel);
+                        }
+                        succLabel.setCoutRealise(rechargeCost);
+                        succLabel.setBatteryLeft(rechargeBattery);
+                        succLabel.setPere(arc);
+                        heap.insert(succLabel);
+                        notifyNodeReached(succ);
+                    }
+                }
+            }
+        }
+
+        // Construction de la solution
+        if (labels[data.getDestination().getId()].getPere() == null) {
+            solution = new ShortestPathSolution(data, Status.INFEASIBLE);
+        }
+        else {
+            // Reconstruire le chemin
+            java.util.ArrayList<Arc> arcs = new java.util.ArrayList<>();
+            Arc arc = labels[data.getDestination().getId()].getPere();
+            while (arc != null) {
+                arcs.add(arc);
+                arc = labels[arc.getOrigin().getId()].getPere();
+            }
+            java.util.Collections.reverse(arcs);
+            solution = new ShortestPathSolution(data, Status.OPTIMAL, new org.insa.graphs.model.Path(graph, arcs));
+        }
+
+        return solution;
+    }
+
+}
+
+
diff --git a/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/TestDijkstra.java b/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/TestDijkstra.java
index df873f2..0b33395 100644
--- a/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/TestDijkstra.java
+++ b/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/TestDijkstra.java
@@ -1,14 +1,9 @@
-package org.insa.graphs.gui.simple;
 
-import java.awt.BorderLayout;
-import java.awt.Dimension;
+
 import java.io.BufferedInputStream;
 import java.io.DataInputStream;
 import java.io.FileInputStream;
 
-import javax.swing.JFrame;
-import javax.swing.SwingUtilities;
-
 import org.insa.graphs.algorithm.AbstractInputData.Mode;
 import org.insa.graphs.algorithm.ArcInspector;
 import org.insa.graphs.algorithm.MyArcInspector;
@@ -18,32 +13,16 @@ import org.insa.graphs.algorithm.shortestpath.DijkstraAlgorithm;
 import org.insa.graphs.algorithm.shortestpath.ShortestPathData;
 import org.insa.graphs.algorithm.shortestpath.ShortestPathSolution;
 import org.insa.graphs.gui.drawing.Drawing;
-import org.insa.graphs.gui.drawing.components.BasicDrawing;
+import org.insa.graphs.gui.simple.Launch;
+import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Graph;
 import org.insa.graphs.model.Node;
 import org.insa.graphs.model.Path;
-import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.io.BinaryGraphReader;
 import org.insa.graphs.model.io.GraphReader;
 
 public class TestDijkstra {
 
-    public static Drawing createDrawing() throws Exception {
-        BasicDrawing basicDrawing = new BasicDrawing();
-        SwingUtilities.invokeAndWait(new Runnable() {
-            @Override
-            public void run() {
-                JFrame frame = new JFrame("BE Graphes - Launch");
-                frame.setLayout(new BorderLayout());
-                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-                frame.setVisible(true);
-                frame.setSize(new Dimension(800, 600));
-                frame.setContentPane(basicDrawing);
-                frame.validate();
-            }
-        });
-        return basicDrawing;
-    }
 
     // fonction pour tester un scénario
     public static void testScenario(String map, int depart, int arrivee, Mode mode, boolean petitGraphe, boolean Astar, boolean restreint) throws Exception {
@@ -73,7 +52,13 @@ public class TestDijkstra {
             dijkstra = new DijkstraAlgorithm(data);
         }
         
-        
+        // Affichage graphique 
+              final Drawing drawing = Launch.createDrawing();
+              //On utilise les observateurs pour Astar
+              
+              drawing.drawGraph(graph);
+              
+
         ShortestPathSolution solution = dijkstra.run();
 
         if (solution.getStatus() == ShortestPathSolution.Status.OPTIMAL) {
@@ -144,11 +129,8 @@ public class TestDijkstra {
                 }
             }
 
-            // Affichage graphique 
-            //   final Drawing drawing = createDrawing();
-            //  drawing.drawGraph(graph);
-            //  drawing.drawPath(path); 
-
+            
+            drawing.drawPath(path); 
         } else {
             System.out.println("Aucun chemin trouvé.");
         }
@@ -165,20 +147,29 @@ public class TestDijkstra {
         // testScenario("carre.mapgr", 0, 9999, Mode.LENGTH, true,false,false);
 
         //cartes routières
-        System.out.println("== Test en distance ==");
-        testScenario("insa.mapgr", 369, 838, Mode.LENGTH, true,false,false);
+        // System.out.println("== Test en distance ==");
+        // testScenario("insa.mapgr", 369, 838, Mode.LENGTH, true,false,false);
         
-        System.out.println("== Test en temps ==");
-        testScenario("insa.mapgr", 369, 838, Mode.TIME, true,false,false);
-        // autres scénarios 
+        // System.out.println("== Test en temps ==");
+        // testScenario("insa.mapgr", 369, 838, Mode.TIME, true,false,false);
+        // // autres scénarios 
 
         //  System.out.println("== Trajet long (et pénible avec les enfants) ==");
         // testScenario("bretagne.mapgr",564429,602395 , Mode.LENGTH, false,false,false);
         
-        System.out.println("== Test bug dijkstra temps ==");
-        testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,false,false);
+        // System.out.println("== Test bug dijkstra temps ==");
+        // testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,false,false); // ce test mettait en lumière un problème d'arrondi qui est mtn résolu.
         
-        // System.out.println("== Trajet impossible (piste cyclable) ==");
-        // testScenario("insa.mapgr",90,922 , Mode.LENGTH, false,false,true); //marche pas 
+        //System.out.println("== Trajet impossible (piste cyclable) ==");
+        //testScenario("insa.mapgr",90,922 , Mode.LENGTH, false,false,true); 
+        //System.out.println("== Trajet impossible (piste cyclable) == sans restriction");
+        //testScenario("insa.mapgr",90,922 , Mode.LENGTH, true,false,false); //marche pas 
+        
+        //scénarios de comparaison Dijkstra vs Astar
+        System.out.println("== Dijkstra vs Astar (en temps) ==");
+        testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,false,false);
+        testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,true,false);
+        
+
     }
 }

From 27c1f7f5dc1919109d087e6a29b60b8742a3915b Mon Sep 17 00:00:00 2001
From: Matteo <sabben@insa-toulouse.fr>
Date: Mon, 26 May 2025 18:43:36 +0200
Subject: [PATCH 3/3] =?UTF-8?q?version=20=C3=A0=20jour=20sauf=20TestDijkst?=
 =?UTF-8?q?ra?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../shortestpath/LabelProblemeOuvert.java     |  23 ---
 .../shortestpath/ProblemeOuvert.java          | 158 +-----------------
 .../src/test/java/TestDijkstra.java           |  20 ---
 3 files changed, 3 insertions(+), 198 deletions(-)

diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
index c3355fe..e0f6d6b 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelProblemeOuvert.java
@@ -2,29 +2,7 @@ package org.insa.graphs.algorithm.shortestpath;
 
 import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Node;
-<<<<<<< HEAD
 
-public class LabelProblemeOuvert extends Label {
-    private double batteryLeft; //double pour la cohérence avec les autres couts qui sont en double eux aussi
-
-    public LabelProblemeOuvert(Node sommet, boolean marque, double cout, Arc pere, double batteryLeft) {
-        super(sommet, marque, cout, pere);
-        this.batteryLeft = batteryLeft;
-    }
-
-    public double getBatteryLeft() {
-        return batteryLeft;
-    }
-
-    public void setBatteryLeft(double batteryLeft) {
-        this.batteryLeft = batteryLeft;
-    }
-
-    @Override
-    public double getTotalCost() { //pourquoi getTotalCost ? psq il est utilisé dans le compareTo
-            return this.getCoutRealise();
-    }
-=======
 public class LabelProblemeOuvert extends Label {
     private double autonomieRestante; //double pour la cohérence avec les autres couts qui sont en double eux aussi
 
@@ -50,5 +28,4 @@ public class LabelProblemeOuvert extends Label {
     public int compareTo(LabelProblemeOuvert other) {
         return Double.compare(this.getTotalCost(), other.getTotalCost());
     }*/
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
 }
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
index d180d8c..d66b785 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/ProblemeOuvert.java
@@ -1,3 +1,6 @@
+
+
+
 /*  je considère que les 200km d'autonomie atteint (200km avec le 22 kWh - Q90 Renault ZOE chargé à 90%)
     cette autonomie est considéré en ville à 200km (à 30km/h de moyenne)
     en mixte elle devient 154 km (47km/h de moyenne) ~3/4 de l'autonmie
@@ -105,25 +108,17 @@ gérer le problème de la recharge, quand la faire ?
 
 package org.insa.graphs.algorithm.shortestpath;
 
-<<<<<<< HEAD
-=======
 import java.util.ArrayList;
 import java.util.Collections;
 
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
 import org.insa.graphs.algorithm.AbstractSolution.Status;
 import org.insa.graphs.algorithm.utils.BinaryHeap;
 import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Graph;
 import org.insa.graphs.model.Node;
-<<<<<<< HEAD
-import org.insa.graphs.model.RoadInformation.RoadType;
-
-=======
 import org.insa.graphs.model.Path;
 import org.insa.graphs.model.RoadInformation.RoadType;
 //import org.insa.graphs.algorithm.shortestpath.ProblemeOuvert;
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
 
 public class ProblemeOuvert extends DijkstraAlgorithm {
 
@@ -139,75 +134,17 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
         return new LabelProblemeOuvert(node, false, Double.POSITIVE_INFINITY, null, MAX_BATTERY);
     }
 
-<<<<<<< HEAD
-    // Surcharge pour compatibilité avec DijkstraAlgorithm
-    @Override
-    protected void tryUpdateLabel(Label[] labels, BinaryHeap<Label> heap, Node node,
-                                  double newCost, Arc pere) {
-        // Si c'est bien un label de probleme ouvert, on applique la logique spécifique
-        if (labels instanceof LabelProblemeOuvert[]) {
-            LabelProblemeOuvert[] plabels = (LabelProblemeOuvert[]) labels;
-            double batteryLeft = plabels[node.getId()].getBatteryLeft();
-            tryUpdateLabelSpecifique(plabels, heap, node, newCost, batteryLeft, pere);
-        } else {
-            // Sinon, on garde le comportement normal du Dijkstra
-            super.tryUpdateLabel(labels, heap, node, newCost, pere);
-        }
-    }
-
-    // Version spécifique pour le problème ouvert (pas d'@Override ici)
-    protected void tryUpdateLabelSpecifique(LabelProblemeOuvert[] labels, BinaryHeap<Label> heap, Node node,
-                                  double newCost, double newBatteryLeft, Arc pere) {
-        LabelProblemeOuvert label = labels[node.getId()];
-
-        // On ne met à jour que si on a assez de batterie
-        if (newBatteryLeft < 0) return;
-
-        if (newCost < label.getCoutRealise() || (Math.abs(newCost - label.getCoutRealise()) < 1e-6 && newBatteryLeft > label.getBatteryLeft())) {
-=======
     protected void tryUpdateLabel(LabelProblemeOuvert[] labels, BinaryHeap<Label> heap, Node node,
                                double newCost, double newBatteryLeft, Arc pere, Arc[] tableauArcs) {
 
         LabelProblemeOuvert label = labels[node.getId()];
 
         if (newCost < label.getCoutRealise()) {
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
             if (label.getCoutRealise() != Double.POSITIVE_INFINITY) {
                 heap.remove(label);
             }
 
             label.setCoutRealise(newCost);
-<<<<<<< HEAD
-            label.setBatteryLeft(newBatteryLeft);
-            label.setPere(pere);
-
-            heap.insert(label);
-            notifyNodeReached(node);
-        }
-    }
-
-    // Surcharge pour compatibilité avec DijkstraAlgorithm
-    // (Pas d'@Override ici car il n'y a pas de méthode à surcharger dans la superclasse)
-    protected void fonctionProblemeOuvert(RoadType typeDeRoute, Label[] labels, BinaryHeap<Label> heap, Node node,
-                                          double newCost, Arc pere) {
-        // Si c'est bien un label de probleme ouvert, on applique la logique spécifique
-        if (labels instanceof LabelProblemeOuvert[]) {
-            fonctionProblemeOuvertSpecifique(typeDeRoute, (LabelProblemeOuvert[]) labels, heap, node, newCost, pere);
-        } else {
-            // Sinon, on garde le comportement normal du Dijkstra
-            super.fonctionProblemeOuvert(typeDeRoute, labels, heap, node, newCost, pere);
-        }
-    }
-
-    // Version spécifique pour le problème ouvert (pas d'@Override ici)
-    protected void fonctionProblemeOuvertSpecifique(RoadType typeDeRoute, LabelProblemeOuvert[] labels, BinaryHeap<Label> heap, Node node,
-                                          double newCost, Arc pere) {
-        if (typeDeRoute == RoadType.MOTORWAY) {
-            tryUpdateLabelSpecifique(labels, heap, node, newCost, MAX_BATTERY, pere);
-        }
-    }
-
-=======
             label.setAutonomieRestante(newBatteryLeft);
             label.setPere(pere);
 
@@ -229,16 +166,12 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
     }*/
 
     
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
     @Override
     protected ShortestPathSolution doRun() {
 
         final ShortestPathData data = getInputData();
         ShortestPathSolution solution = null;
-<<<<<<< HEAD
-=======
         // accès au graphe
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
         Graph graph = data.getGraph();
         int nbNodes = graph.size();
 
@@ -249,18 +182,10 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
 
         // Initialisation des labels
         for (Node node : graph.getNodes()) {
-<<<<<<< HEAD
-            labels[node.getId()] = createLabel(node);
-        }
-        // Origine : coût 0, batterie pleine
-        labels[data.getOrigin().getId()].setCoutRealise(0);
-        labels[data.getOrigin().getId()].setBatteryLeft(MAX_BATTERY);
-=======
             labels[node.getId()] =createLabel(node);
         }
         // Origine : coût 0, non marqué, pas de père
         labels[data.getOrigin().getId()].setCoutRealise(0);
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
 
         BinaryHeap<Label> heap = new BinaryHeap<>();
         heap.insert(labels[data.getOrigin().getId()]);
@@ -268,17 +193,6 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
         notifyOriginProcessed(data.getOrigin());
 
         while (!heap.isEmpty()) {
-<<<<<<< HEAD
-            LabelProblemeOuvert currentLabel = (LabelProblemeOuvert) heap.deleteMin();
-            Node currentNode = currentLabel.getSommetCourant();
-
-            // sommet traité
-            currentLabel.setMarque(true);
-
-            // On a atteint la destination on s'arrête
-            if (currentNode.equals(data.getDestination())) {
-                notifyDestinationReached(currentNode);
-=======
             Label LabelActuel = heap.deleteMin();
             Node NodeActuel = LabelActuel.getSommetCourant();
 
@@ -288,60 +202,10 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
             // On a atteint la destination on s'arrête
             if (NodeActuel.equals(data.getDestination())) {
                 notifyDestinationReached(NodeActuel);
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
                 break;
             }
 
             // Pour chaque successeur
-<<<<<<< HEAD
-            for (Arc arc : currentNode.getSuccessors()) {
-                if (!data.isAllowed(arc)) continue;
-
-                Node succ = arc.getDestination();
-                LabelProblemeOuvert succLabel = labels[succ.getId()];
-
-                if (succLabel.getMarque()) continue;
-
-                double arcCost = data.getCost(arc);
-                double batteryLeft = currentLabel.getBatteryLeft();
-
-                // Calcul de la batterie restante après avoir parcouru l'arc
-                double newBatteryLeft = batteryLeft - arcCost;
-                double newCost = currentLabel.getCoutRealise() + arcCost;
-
-                // Si pas assez de batterie, on ne continue pas
-                if (newBatteryLeft < 0) continue;
-
-                // Mise à jour du label si meilleur coût ou plus de batterie à coût égal
-                if (newCost < succLabel.getCoutRealise() ||
-                    (Math.abs(newCost - succLabel.getCoutRealise()) < 1e-6 && newBatteryLeft > succLabel.getBatteryLeft())) {
-                    if (succLabel.getCoutRealise() != Double.POSITIVE_INFINITY) {
-                        heap.remove(succLabel);
-                    }
-                    succLabel.setCoutRealise(newCost);
-                    succLabel.setBatteryLeft(newBatteryLeft);
-                    succLabel.setPere(arc);
-                    heap.insert(succLabel);
-                    notifyNodeReached(succ);
-                }
-
-                // Si on arrive sur une autoroute, possibilité de recharger
-                if (arc.getRoadInformation().getType() == RoadType.MOTORWAY) {
-                    double rechargeCost = newCost; // ici, pas de coût supplémentaire pour la recharge
-                    double rechargeBattery = MAX_BATTERY;
-                    if (rechargeCost < succLabel.getCoutRealise() ||
-                        (Math.abs(rechargeCost - succLabel.getCoutRealise()) < 1e-6 && rechargeBattery > succLabel.getBatteryLeft())) {
-                        if (succLabel.getCoutRealise() != Double.POSITIVE_INFINITY) {
-                            heap.remove(succLabel);
-                        }
-                        succLabel.setCoutRealise(rechargeCost);
-                        succLabel.setBatteryLeft(rechargeBattery);
-                        succLabel.setPere(arc);
-                        heap.insert(succLabel);
-                        notifyNodeReached(succ);
-                    }
-                }
-=======
             for (Arc arc : NodeActuel.getSuccessors()) {
                      if (!data.isAllowed(arc)) continue; // ici c'est pour l'amélioration voiture ou a pied
 
@@ -367,30 +231,15 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
                     if (arc.getRoadInformation().getType() == RoadType.MOTORWAY) {
                         tryUpdateLabel(labels, heap, succ, newCost, MAX_BATTERY, arc,predecessorArcs);
                     }
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
             }
         }
 
         // Construction de la solution
-<<<<<<< HEAD
-        if (labels[data.getDestination().getId()].getPere() == null) {
-=======
         if (predecessorArcs[data.getDestination().getId()] == null) {
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
             solution = new ShortestPathSolution(data, Status.INFEASIBLE);
         }
         else {
             // Reconstruire le chemin
-<<<<<<< HEAD
-            java.util.ArrayList<Arc> arcs = new java.util.ArrayList<>();
-            Arc arc = labels[data.getDestination().getId()].getPere();
-            while (arc != null) {
-                arcs.add(arc);
-                arc = labels[arc.getOrigin().getId()].getPere();
-            }
-            java.util.Collections.reverse(arcs);
-            solution = new ShortestPathSolution(data, Status.OPTIMAL, new org.insa.graphs.model.Path(graph, arcs));
-=======
             ArrayList<Arc> arcs = new ArrayList<>();
             Arc arc = predecessorArcs[data.getDestination().getId()];
             while (arc != null) {
@@ -399,7 +248,6 @@ public class ProblemeOuvert extends DijkstraAlgorithm {
             }
             Collections.reverse(arcs);// on inverse le chemin
             solution = new ShortestPathSolution(data, Status.OPTIMAL,new Path(graph, arcs));
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0
         }
 
         return solution;
diff --git a/be-graphes-gui/src/test/java/TestDijkstra.java b/be-graphes-gui/src/test/java/TestDijkstra.java
index 1d1bd5b..352bf80 100644
--- a/be-graphes-gui/src/test/java/TestDijkstra.java
+++ b/be-graphes-gui/src/test/java/TestDijkstra.java
@@ -12,11 +12,6 @@ import org.insa.graphs.algorithm.shortestpath.BellmanFordAlgorithm;
 import org.insa.graphs.algorithm.shortestpath.DijkstraAlgorithm;
 import org.insa.graphs.algorithm.shortestpath.ShortestPathData;
 import org.insa.graphs.algorithm.shortestpath.ShortestPathSolution;
-<<<<<<< HEAD:be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/TestDijkstra.java
-import org.insa.graphs.gui.drawing.Drawing;
-import org.insa.graphs.gui.simple.Launch;
-=======
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0:be-graphes-gui/src/test/java/TestDijkstra.java
 import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Graph;
 import org.insa.graphs.model.Node;
@@ -162,26 +157,11 @@ public class TestDijkstra {
         
         // System.out.println("== Test bug dijkstra temps ==");
         // testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,false,false); // ce test mettait en lumière un problème d'arrondi qui est mtn résolu.
-<<<<<<< HEAD:be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/TestDijkstra.java
-        
-        //System.out.println("== Trajet impossible (piste cyclable) ==");
-        //testScenario("insa.mapgr",90,922 , Mode.LENGTH, false,false,true); 
-        //System.out.println("== Trajet impossible (piste cyclable) == sans restriction");
-        //testScenario("insa.mapgr",90,922 , Mode.LENGTH, true,false,false); //marche pas 
-        
-        //scénarios de comparaison Dijkstra vs Astar
-        System.out.println("== Dijkstra vs Astar (en temps) ==");
-        testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,false,false);
-        testScenario("paris.mapgr", 27361, 36108, Mode.TIME, true,true,false);
-        
-
-=======
         
         System.out.println("== Trajet impossible (piste cyclable) ==");
         testScenario("insa.mapgr",90,922 , Mode.LENGTH, false,false,true); 
         System.out.println("== Trajet impossible (piste cyclable) == sans restriction");
         testScenario("insa.mapgr",90,922 , Mode.LENGTH, false,false,false); //marche pas 
         
->>>>>>> 1aee5a57c3b4966b14ac38a33ed9e52af7a882d0:be-graphes-gui/src/test/java/TestDijkstra.java
     }
 }