BE_graphes/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java

	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.AccessRestrictions.AccessMode;
import org.insa.graphs.model.AccessRestrictions.AccessRestriction;
import org.insa.graphs.model.Arc;
import org.insa.graphs.model.Node;
	import org.insa.graphs.model.Path;
	import java.util.ArrayList;
	import java.util.Collections;//trier tout ça
	
	public class DijkstraAlgorithm extends ShortestPathAlgorithm {
		
	
		//facilite la comparaison de Dijkstra et A* en temps
		private int nbnodes= Integer.MAX_VALUE;
		
		public int getnbnodes() {
			return this.nbnodes;
		}
		
	    public DijkstraAlgorithm(ShortestPathData data) {
	        super(data);
	    }
	    
	    public Label LabelTyped(Node sommet,Arc padre, float prix){
	    	return new Label(sommet,padre, prix);
	    }
	    
	    @Override
	    protected ShortestPathSolution doRun() {
	    	
	    	this.nbnodes=0;
	    	
	    	int mul=1;//problème ouvert
	    	
	        final ShortestPathData data = getInputData();
	        ShortestPathSolution solution = new ShortestPathSolution(data,Status.UNKNOWN);//modifié
	        
	        if (data.getDestination()==null || data.getOrigin()==null) {
	        	solution= new ShortestPathSolution(data, Status.INFEASIBLE, new Path(data.getGraph()));
	        }else {
	        	
	        //initialisation
	        BinaryHeap<Label> tas=new BinaryHeap<Label>();//les Label sont comparés via leurs coûts
	        
	        Label[] tablabel=new Label[data.getGraph().size()];
	        for (int i=0;i<tablabel.length;i++) {
	        	tablabel[i]=LabelTyped(data.getGraph().get(i),null,Float.MAX_VALUE);//non marqué par défaut
	        }//dans le tablabel[idnode] on peut retrouver node
	        tablabel[data.getOrigin().getId()].cout=0;
	        
	        tas.insert(tablabel[data.getOrigin().getId()]);                
	        int nomark=tablabel.length;//nombre de sommets non marqués (pas optimal?)
	        int x;//id du node qu'on étudie
	        boolean arrive=false;//node de destination atteint ou pas
	        
	        
	        //itérations
	        while (nomark>0 && !arrive && !tas.isEmpty()){
	        	
	        	x=tas.deleteMin().sommet_courant.getId();
	        	
	        	if (x==data.getDestination().getId()) {
	        		arrive=true;//marche aussi si le départ et l'arrivée sont le même node
	        	}else {
	        		
		        	tablabel[x].marque=true;
		        	this.nbnodes++;
		        	this.notifyNodeMarked(tablabel[x].sommet_courant);
		        	//System.out.printf("%f\n",tablabel[x].getTotalCost());
		        	//System.out.printf("%d\n",tablabel[x].sommet_courant.getNumberOfSuccessors());
		        	nomark--;
		        	int y;
		        	
		        	for (Arc arcy: tablabel[x].sommet_courant.getSuccessors()) {
		        		
		        		y=arcy.getDestination().getId();
		        		//System.out.println(tas.isValid());
		        		
		        		if (!tablabel[y].marque && data.isAllowed(arcy)) {
		        			
		        			if (arcy.getRoadInformation().getAccessRestrictions().isAllowedFor(AccessMode.MOTORCAR,
		        					AccessRestriction.ALLOWED))
		        				mul=1;
		        			else//ce bloc sert à l'implémentation du problème ouvert
		        				mul=1;
		        			if (tablabel[y].getCost()>tablabel[x].getCost()+mul*(float)data.getCost(arcy)) {
		        				
		        				if (tablabel[y].getCost()!=Float.MAX_VALUE) {
		        					tas.remove(tablabel[y]);
		        					this.notifyNodeReached(arcy.getDestination());
		        				}
		        				
		        				tablabel[y].cout=tablabel[x].getCost()+mul*(float)data.getCost(arcy);
		        				tablabel[y].pere=arcy;
		        				tas.insert(tablabel[y]);
		        				
		        			}
		        		}
		        	}
		        }
	        }
	        
	        if (!arrive) {
	        		solution= new ShortestPathSolution(data,Status.INFEASIBLE, new Path(data.getGraph()));
	        }else {
	        	
	        	this.notifyDestinationReached(data.getDestination());
	        	
	        	ArrayList<Arc> bonsarcs=new ArrayList<Arc>();
	        	Label labelact=tablabel[data.getDestination().getId()];
	        	
	        	while (labelact.pere!=null) {
	        		bonsarcs.add(labelact.pere);
	        		labelact=tablabel[labelact.pere.getOrigin().getId()];
	        	}
	        	
	        	Collections.reverse(bonsarcs);
	        	solution = new ShortestPathSolution(data,Status.OPTIMAL,new Path(data.getGraph(),bonsarcs));
	        	
	        	//Path chemin= new Path(data.getGraph(),bonsarcs);//y'a t-il un retour si le chemin est infaisable? 
	        	//System.out.printf("valide: %b, longueur: %f\n",chemin.isValid(), chemin.getLength());
	        	//System.out.printf("distance réelle origine-destination (test): %f", (float)this.getInputData().getOrigin().getPoint().distanceTo(this.getInputData().getDestination().getPoint()));
	        	
	        	
	        	}
	        }
	        
        return solution;
    }

}