disj

laby/Aetoile.c

+#include "Aetoile.h"
+
+int distance_euclidienne(int a, int b);
+{
+	return (int) sqrt((a/P - b/b)*(a/P - b/P) + (a%P -b%P)*(a%P -b%P));
+}
+
+int distance_tcheby(int a, int b)
+{
+	return max(abs(a/P-b/P),abs(a%P-b%P));
+}
+
+int distance_manhattan(int a, int b)
+{
+	return (abs(a/P - b/P) + abs(a%P - b%P));
+}
+
+int * Aetoile_euclidienne(int ** laby, int noeuds, int depart)
+{
+	int * parent = malloc(noeuds*sizeof(int));
+	parent[depart]=depart;
+	
+	poids_t * distance = malloc(noeuds*sizeof(poids_t));
+	for (int i=0; i<noeuds; i++)
+	{
+		distance[i].poids=noeuds;
+		distance[i].val=i;
+	}
+	distance[depart].poids=0;
+
+	int* indice_valeur = malloc(noeuds*sizeof(int));
+	for (int i=0; i<noeuds; i++)
+		indice_valeur[i]=-1;
+
+	tas_t * tas=init_tas(noeuds+1);
+	for (int i=0; i<noeuds; i++)
+		tas->tab[i]=distance[i];
+
+	int * voisin=malloc(4*sizeof(int));
+	for (int i=0; i<4; i++)
+		voisin[i]=-1;
+
+	int sommet= depart;
+	ajouter_tas_min(tas,distance[depart],indice_valeur);
+
+	while (tas->taille>-1)
+	{
+		if (laby[sommet%P][sommet/P] & FLAG_N)
+			voisin[0]=sommet-P;
+		if (laby[sommet%P][sommet/P] & FLAG_S)
+			voisin[1]=sommet+P;
+		if (laby[sommet%P][sommet/P] & FLAG_O)
+			voisin[2]=sommet-1;
+		if (laby[sommet%P][sommet/P] & FLAG_E)
+			voisin[3]=sommet+1;
+		for (int j=0; j<4; j++)
+		{	
+			
+			if (voisin[j]!=-1)
+			{
+				if (indice_valeur[voisin[j]]!=-2)
+				{
+					if (indice_valeur[voisin[j]]==-1)
+					{
+						distance[voisin[j]].poids=1 + distance[sommet].poids+ distance_euclidienne(voisin[j],sommet);
+						ajouter_tas_min(tas,distance[voisin[j]],indice_valeur);
+						parent[voisin[j]]=sommet;
+					}
+					else
+					{
+						if (distance[voisin[j]].poids>1+distance[sommet].poids+ distance_euclidienne(voisin[j],sommet))
+						{
+							distance[voisin[j]].poids=1 + distance[sommet].poids+ distance_euclidienne(voisin[j],sommet);
+							percolation_bas_tas_min(tas,indice_valeur[voisin[j]],indice_valeur);
+							parent[voisin[j]]=sommet;
+						}
+					}
+				}
+			}
+			voisin[j]=-1;
+		}
+		indice_valeur[tas->tab[0].val]=-2;
+		indice_valeur[tas->tab[tas->taille].val]=0;
+		
+
+		typetas aux=tas->tab[0];
+		tas->tab[0]=tas->tab[tas->taille];
+		tas->tab[tas->taille]=aux;
+	
+		tas->taille+=-1;
+		percolation_bas_tas_min(tas,0,indice_valeur);
+		sommet=tas->tab[0].val;
+		
+	}
+	free(distance);
+	free(indice_valeur);
+	liberer(tas);
+	return parent;	
+}
+
+int * Aetoile_tcheby(int ** laby, int noeuds, int depart)
+{
+	int * parent = malloc(noeuds*sizeof(int));
+	parent[depart]=depart;
+	
+	poids_t * distance = malloc(noeuds*sizeof(poids_t));
+	for (int i=0; i<noeuds; i++)
+	{
+		distance[i].poids=noeuds;
+		distance[i].val=i;
+	}
+	distance[depart].poids=0;
+
+	int* indice_valeur = malloc(noeuds*sizeof(int));
+	for (int i=0; i<noeuds; i++)
+		indice_valeur[i]=-1;
+
+	tas_t * tas=init_tas(noeuds+1);
+	for (int i=0; i<noeuds; i++)
+		tas->tab[i]=distance[i];
+
+	int * voisin=malloc(4*sizeof(int));
+	for (int i=0; i<4; i++)
+		voisin[i]=-1;
+
+	int sommet= depart;
+	ajouter_tas_min(tas,distance[depart],indice_valeur);
+
+	while (tas->taille>-1)
+	{
+		if (laby[sommet%P][sommet/P] & FLAG_N)
+			voisin[0]=sommet-P;
+		if (laby[sommet%P][sommet/P] & FLAG_S)
+			voisin[1]=sommet+P;
+		if (laby[sommet%P][sommet/P] & FLAG_O)
+			voisin[2]=sommet-1;
+		if (laby[sommet%P][sommet/P] & FLAG_E)
+			voisin[3]=sommet+1;
+		for (int j=0; j<4; j++)
+		{	
+			
+			if (voisin[j]!=-1)
+			{
+				if (indice_valeur[voisin[j]]!=-2)
+				{
+					if (indice_valeur[voisin[j]]==-1)
+					{
+						distance[voisin[j]].poids=1 + distance[sommet].poids+ distance_tcheby(voisin[j],sommet);
+						ajouter_tas_min(tas,distance[voisin[j]],indice_valeur);
+						parent[voisin[j]]=sommet;
+					}
+					else
+					{
+						if (distance[voisin[j]].poids>1+distance[sommet].poids+ distance_tcheby(voisin[j],sommet))
+						{
+							distance[voisin[j]].poids=1 + distance[sommet].poids+ distance_tcheby(voisin[j],sommet);
+							percolation_bas_tas_min(tas,indice_valeur[voisin[j]],indice_valeur);
+							parent[voisin[j]]=sommet;
+						}
+					}
+				}
+			}
+			voisin[j]=-1;
+		}
+		indice_valeur[tas->tab[0].val]=-2;
+		indice_valeur[tas->tab[tas->taille].val]=0;
+		
+
+		typetas aux=tas->tab[0];
+		tas->tab[0]=tas->tab[tas->taille];
+		tas->tab[tas->taille]=aux;
+	
+		tas->taille+=-1;
+		percolation_bas_tas_min(tas,0,indice_valeur);
+		sommet=tas->tab[0].val;
+		
+	}
+	free(distance);
+	free(indice_valeur);
+	liberer(tas);
+	return parent;	
+}
+
+int * Aetoile_manhattan(int ** laby, int noeuds, int depart)
+{
+	int * parent = malloc(noeuds*sizeof(int));
+	parent[depart]=depart;
+	
+	poids_t * distance = malloc(noeuds*sizeof(poids_t));
+	for (int i=0; i<noeuds; i++)
+	{
+		distance[i].poids=noeuds;
+		distance[i].val=i;
+	}
+	distance[depart].poids=0;
+
+	int* indice_valeur = malloc(noeuds*sizeof(int));
+	for (int i=0; i<noeuds; i++)
+		indice_valeur[i]=-1;
+
+	tas_t * tas=init_tas(noeuds+1);
+	for (int i=0; i<noeuds; i++)
+		tas->tab[i]=distance[i];
+
+	int * voisin=malloc(4*sizeof(int));
+	for (int i=0; i<4; i++)
+		voisin[i]=-1;
+
+	int sommet= depart;
+	ajouter_tas_min(tas,distance[depart],indice_valeur);
+
+	while (tas->taille>-1)
+	{
+		if (laby[sommet%P][sommet/P] & FLAG_N)
+			voisin[0]=sommet-P;
+		if (laby[sommet%P][sommet/P] & FLAG_S)
+			voisin[1]=sommet+P;
+		if (laby[sommet%P][sommet/P] & FLAG_O)
+			voisin[2]=sommet-1;
+		if (laby[sommet%P][sommet/P] & FLAG_E)
+			voisin[3]=sommet+1;
+		for (int j=0; j<4; j++)
+		{	
+			
+			if (voisin[j]!=-1)
+			{
+				if (indice_valeur[voisin[j]]!=-2)
+				{
+					if (indice_valeur[voisin[j]]==-1)
+					{
+						distance[voisin[j]].poids=1 + distance[sommet].poids+ distance_manhattan(voisin[j],sommet);
+						ajouter_tas_min(tas,distance[voisin[j]],indice_valeur);
+						parent[voisin[j]]=sommet;
+					}
+					else
+					{
+						if (distance[voisin[j]].poids>1+distance[sommet].poids+ distance_manhattan(voisin[j],sommet))
+						{
+							distance[voisin[j]].poids=1 + distance[sommet].poids+ distance_manhattan(voisin[j],sommet);
+							percolation_bas_tas_min(tas,indice_valeur[voisin[j]],indice_valeur);
+							parent[voisin[j]]=sommet;
+						}
+					}
+				}
+			}
+			voisin[j]=-1;
+		}
+		indice_valeur[tas->tab[0].val]=-2;
+		indice_valeur[tas->tab[tas->taille].val]=0;
+		
+
+		typetas aux=tas->tab[0];
+		tas->tab[0]=tas->tab[tas->taille];
+		tas->tab[tas->taille]=aux;
+	
+		tas->taille+=-1;
+		percolation_bas_tas_min(tas,0,indice_valeur);
+		sommet=tas->tab[0].val;
+		
+	}
+	free(distance);
+	free(indice_valeur);
+	liberer(tas);
+	return parent;	
+}

laby/dijsktra.c

 #include "dijsktra.h"
 
 
-int * dijsktra(graph_t * graph, int noeuds, int nb_aretes, int depart)
+int * dijsktra(int ** laby, int noeuds, int depart)
 {
 	int * parent = malloc(noeuds*sizeof(int));
 	parent[depart]=depart;
@@ -18,58 +18,52 @@ int * dijsktra(graph_t * graph, int noeuds, int nb_aretes, int depart)
 	for (int i=0; i<noeuds; i++)
 		indice_valeur[i]=-1;
 
-	aretes_t * A= malloc(nb_aretes*sizeof(aretes_t));
-	for (int i=0; i<nb_aretes; i++)
-		A[i]=graph->liste[i];	
-
 	tas_t * tas=init_tas(noeuds+1);
 	for (int i=0; i<noeuds; i++)
 		tas->tab[i]=distance[i];
 
+	int * voisin=malloc(4*sizeof(int));
+	for (int i=0; i<4; i++)
+		voisin[i]=-1;
+
 	int sommet= depart;
 	ajouter_tas_min(tas,distance[depart],indice_valeur);
-	int i=0;
-	int voisin;
-	while (nb_aretes)
+
+	while (tas->taille>-1)
 	{
+		if (laby[sommet%P][sommet/P] & FLAG_N)
+			voisin[0]=sommet-P;
+		if (laby[sommet%P][sommet/P] & FLAG_S)
+			voisin[1]=sommet+P;
+		if (laby[sommet%P][sommet/P] & FLAG_O)
+			voisin[2]=sommet-1;
+		if (laby[sommet%P][sommet/P] & FLAG_E)
+			voisin[3]=sommet+1;
 		for (int j=0; j<4; j++)
 		{	
-			i=0;
-			while (i<nb_aretes && A[i].un!=sommet && A[i].deux!=sommet)
-				i++;
-			if (A[i].un==sommet)
-				voisin=A[i].deux;
-			else if (A[i].deux==sommet)
-				voisin=A[i].un;
-			if (voisin!=-1)
+			
+			if (voisin[j]!=-1)
 			{
-				if (indice_valeur[voisin]!=-2)
+				if (indice_valeur[voisin[j]]!=-2)
 				{
-					if (indice_valeur[voisin]==-1)
+					if (indice_valeur[voisin[j]]==-1)
 					{
-						distance[voisin].poids=1 + distance[sommet].poids;
-						ajouter_tas_min(tas,distance[voisin],indice_valeur);
-						parent[voisin]=sommet;
-						A[i]=A[nb_aretes-1];
-						if (i!=nb_aretes)
-							nb_aretes--;
-						voisin=-1;
+						distance[voisin[j]].poids=1 + distance[sommet].poids;
+						ajouter_tas_min(tas,distance[voisin[j]],indice_valeur);
+						parent[voisin[j]]=sommet;
 					}
 					else
 					{
-						if (distance[voisin].poids>1+distance[sommet].poids)
+						if (distance[voisin[j]].poids>1+distance[sommet].poids)
 						{
-							distance[voisin].poids=1 + distance[sommet].poids;
-							percolation_bas_tas_min(tas,indice_valeur[voisin],indice_valeur);
-							parent[voisin]=sommet;
+							distance[voisin[j]].poids=1 + distance[sommet].poids;
+							percolation_bas_tas_min(tas,indice_valeur[voisin[j]],indice_valeur);
+							parent[voisin[j]]=sommet;
 						}
-						A[i]=A[nb_aretes-1];
-						voisin=-1;
-						if (i!=nb_aretes)
-							nb_aretes--;
 					}
 				}
 			}
+			voisin[j]=-1;
 		}
 		indice_valeur[tas->tab[0].val]=-2;
 		indice_valeur[tas->tab[tas->taille].val]=0;
@@ -86,7 +80,6 @@ int * dijsktra(graph_t * graph, int noeuds, int nb_aretes, int depart)
 	}
 	free(distance);
 	free(indice_valeur);
-	free(A);
 	liberer(tas);
 	return parent;	
 }

laby/dijsktra.h

@@ -8,7 +8,9 @@
 #include <time.h>
 #include "graph_aretes_tab.h"
 #include "tas.h"
+#include "kruskal.h"
+#include "main.h"
 
-int * dijsktra(graph_t *,int , int, int);
+int * dijsktra(int **, int, int);
 
 #endif

laby/kruskal.c

@@ -18,10 +18,14 @@ int ** tableau_ligne(graph_t * graph,int nb_aretes)
 		x=graph->liste[i].un%P;
 		y=graph->liste[i].un/P;
 //		printf("sommet1: %d sommet2: %d x :%d y :%d diff :%d\n",graph->liste[i].un,graph->liste[i].deux,x,y,diff);
-		if (diff==1)
+		if (diff==1){
 			tab[x][y]+=4;
-		else // ne marche pas c'est incomprehensibleif (diff==P)
+			tab[x+1][y]+=8;
+		}
+		else{ // ne marche pas c'est incomprehensibleif (diff==P)
 			tab[x][y]+=2;
+			tab[x][y+1]+=1;
+		}
 	}
 /*
 	for (int i=0; i<N; i++)
@@ -95,7 +99,6 @@ void generation(graph_t * graph)
 			graph->liste[c].un=i;
 			graph->liste[c].deux=i+1;
 			graph->liste[c].valuation=1;
-			graph->liste[c].etiqdji=-1;
 			c++;
 		}
 		if (i/P<N-1)
@@ -103,7 +106,6 @@ void generation(graph_t * graph)
 			graph->liste[c].un=i;
 			graph->liste[c].deux=i+P;
 			graph->liste[c].valuation=1;
-			graph->liste[c].etiqdji=-1;
 			c++;
 		}
 	}

laby/main.c

@@ -24,7 +24,6 @@ void end_sdl(char ok,char const* msg,SDL_Window* window, SDL_Renderer* renderer)
 
 	if (!ok) exit(EXIT_FAILURE);
 }
-
 void afficherEcranIntelligemment(SDL_Renderer *renderer,int **tab,int taille_cell)
 {
 	int x=0;
@@ -35,26 +34,31 @@ void afficherEcranIntelligemment(SDL_Renderer *renderer,int **tab,int taille_cel
 	SDL_GetCurrentDisplayMode(0,&screen);
 	int decalage_horizontale=(screen.w/taille_cell-P)*taille_cell/3;
 	int decalage_vertical=(screen.h/taille_cell-N)*taille_cell/4;
-	SDL_RenderDrawLine(renderer,decalage_horizontale,decalage_vertical,decalage_horizontale+P*taille_cell,decalage_vertical); //mur au nord
-	SDL_RenderDrawLine(renderer,decalage_horizontale,decalage_vertical+N*taille_cell,decalage_horizontale+P*taille_cell,(N)*taille_cell+decalage_vertical); //mur au sud 
-	SDL_RenderDrawLine(renderer,decalage_horizontale,decalage_vertical,decalage_horizontale,decalage_vertical+(N)*taille_cell); //mur à l'ouest
-	SDL_RenderDrawLine(renderer,decalage_horizontale+(P)*taille_cell,decalage_vertical,decalage_horizontale+(P)*taille_cell,decalage_vertical+(N)*taille_cell); //mur à l'est
 
 	SDL_SetRenderDrawColor(renderer,0,0,0,0);
-	for (int i=0;i<P;i++)
-	{
+	int i1,j1,noeud=0;
 	
-		for (int j=0;j<N;j++)
+	for (int i=0;i<N;i++)
+	{
+		for (int j=0;j<P;j++)
 		{
-			x=tab[i][j];
+			x=tab[j][i];
+			i1=(noeud%P);
+			j1=((int)noeud/P);
+
+			if (!(x & FLAG_N))
+				SDL_RenderDrawLine(renderer,i1*taille_cell+decalage_horizontale,j1*taille_cell+decalage_vertical,(i1+1)*taille_cell+decalage_horizontale,j1*taille_cell+decalage_vertical); //mur au nord
+			if ((x & FLAG_S)!=2)
+				SDL_RenderDrawLine(renderer,i1*taille_cell+decalage_horizontale,(j1+1)*taille_cell+decalage_vertical,(i1+1)*taille_cell+decalage_horizontale,(j1+1)*taille_cell+decalage_vertical); //mur au sud
+			if ((x & FLAG_E)!=4)
+				SDL_RenderDrawLine(renderer,(i1+1)*taille_cell+decalage_horizontale,j1*taille_cell+decalage_vertical,(i1+1)*taille_cell+decalage_horizontale,(j1+1)*taille_cell+decalage_vertical); //mur à l'est
+			if ((x & FLAG_O)!=8)
+				SDL_RenderDrawLine(renderer,i1*taille_cell+decalage_horizontale,j1*taille_cell+decalage_vertical,i1*taille_cell+decalage_horizontale,(j1+1)*taille_cell+decalage_vertical); //mur à l'ouest
+
+			noeud+=1;
 
-			if ((x!=2) && (x!=6))
-				SDL_RenderDrawLine(renderer,i*taille_cell+decalage_horizontale,(j+1)*taille_cell+decalage_vertical,(i+1)*taille_cell+decalage_horizontale,(j+1)*taille_cell+decalage_vertical); //mur au sud
-			if ((x!=4) &&  (x!=6)) 
-				SDL_RenderDrawLine(renderer,(i+1)*taille_cell+decalage_horizontale,j*taille_cell+decalage_vertical,(i+1)*taille_cell+decalage_horizontale,(j+1)*taille_cell+decalage_vertical); //mur à l'est
 		}
 	}
-
 }
 
 void chemin(SDL_Renderer * renderer, int depart, int arrivee, int taille_cell,int *parent)
@@ -134,7 +138,7 @@ int main (int argc, char** argv)
 	graph=Fisher(graph,nb_aretes);
 	graph=kruskal(graph,noeuds,nb_aretes,&cours,p);
 	tab=tableau_ligne(graph,cours);
-
+	int temps=600;
 	SDL_Event event;
 	while (running)
 	{
@@ -151,20 +155,24 @@ int main (int argc, char** argv)
 					case SDL_WINDOWEVENT_CLOSE:
 						running = 0;
 						break;
-					default:
-						break;
 					}
 					break;
 			break;
 			}
-			afficherEcranIntelligemment(renderer,tab,taille_cell);
-			depart=rand()%noeuds;
-			arrivee=rand()%noeuds;
-			parent=dijsktra(graph,noeuds,cours,arrivee);
-			chemin(renderer,depart, arrivee, taille_cell, parent);
+			if (temps>600)
+			{
+				temps=0;
+				SDL_RenderClear(renderer);
+				afficherEcranIntelligemment(renderer,tab,taille_cell);
+				depart=arrivee;
+				arrivee=rand()%noeuds;
+				parent=dijsktra(tab,noeuds,arrivee);
+				chemin(renderer,depart, arrivee, taille_cell, parent);
+			}
+			else
+				temps+=10;
 			SDL_RenderPresent(renderer);
-			SDL_Delay(1000);
-			SDL_RenderClear(renderer);
+			SDL_Delay(10);
 		}
 	}
 	end_sdl(1, "Normal ending", window, renderer);

laby/main.h

@@ -9,8 +9,16 @@
 #include "dijsktra.h"
 #include <math.h>
 
+typedef enum {
+	FLAG_N=1,
+	FLAG_S=2,
+	FLAG_E=4,
+	FLAG_O=8
+}flag_t;
+
 void end_sdl(char ok,char const* msg,SDL_Window* window, SDL_Renderer* renderer);
 void afficheEcranIntelligement(SDL_Renderer*,int**,int);
+void chemin(SDL_Renderer *,int, int, int, int *);
 int min(int , int);
 int main(int ,char**);