on ajoute tout

laby/graph.c

+#include "graph.h"
+
+int ** creer_mat(int n)
+{
+	int ** mat= malloc(n*sizeof(int *));
+	if (!mat)
+		printf("erreur d'allocation de la matrice\n");
+	for (int i=0; i<n; i++)
+	{
+		mat[i]= malloc(n*sizeof(int));
+		if (!mat[i])
+			printf("erreur d'allocation de la ligne %d\n",i);
+	}
+	return mat;
+}
+
+void libere_mat(int ** mat, int n)
+{
+	for (int i=0; i<n; i++)
+	{
+		free(mat[i]);
+	}
+	free(mat);
+}
+
+void remplir_mat(int ** mat, int n)
+{
+	for (int i=0; i<n ;i++)
+	{
+		for (int j=0; j<i; j++)
+			mat[i][j]=rand()%8;
+	}
+}
+	
+
+void affiche_graph(int ** mat, int n)
+{
+	FILE *fichier;
+	fichier=fopen("graph1.dot","w");
+	if (fichier==NULL)
+		printf("echec de louverture du fichier\n");
+	else 
+		fprintf(fichier,"graph Nom{\n");
+	for (int i=0; i<n ;i++)
+	{
+		fprintf(fichier,"%d",i);
+		fprintf(fichier,";");
+		for (int j=0; j<i; j++)
+		{
+			if (mat[i][j]==1)
+			{
+				fprintf(fichier,"%d",i);
+				fprintf(fichier,"--");
+				fprintf(fichier,"%d",j);
+				fprintf(fichier,";");
+			}
+		}
+	}
+	fprintf(fichier, "}");
+	fclose(fichier);
+	system("dot -Tpng graph1.dot -o graph1.png");
+	system("display graph1.png &");
+	
+}
+
+void affiche_graph2(int **mat,int * tab, int n)
+{
+	FILE *fichier;
+	fichier=fopen("graph_co.dot","w");
+	if (fichier==NULL)
+		printf("echec de louverture du fichier\n");
+	else 
+		fprintf(fichier,"graph Nom{\n");
+	for (int i=0; i<n ;i++)
+	{
+		fprintf(fichier,"%d",tab[i]);
+		fprintf(fichier,";");
+		for (int j=0; j<i; j++)
+		{
+			if (mat[tab[i]][tab[j]]==1)
+			{
+				fprintf(fichier,"%d",tab[i]);
+				fprintf(fichier,"--");
+				fprintf(fichier,"%d",tab[j]);
+				fprintf(fichier,";");
+			}
+		}
+	}
+	fprintf(fichier, "}");
+	fclose(fichier);
+	system("dot -Tpng graph_co.dot -o graph_co.png");
+	system("display graph_co.png ");
+	
+}
+
+void partition_connexe(partition_t* part, int ** mat,int n)
+{
+	for (int i=0; i<n ;i++)
+		for (int j=0; j<i; j++)
+			if (mat[i][j]==1)
+				fusion(i,j,part);
+}
+
+int main()
+{
+	srand(time(0));
+	int ** mat=NULL;
+	mat= creer_mat(10);
+	remplir_mat(mat,10);
+	partition_t * part=creer(10);
+	int liste_classe[10];
+	int liste_part[10];
+	int nbpart;
+	int nbel;
+/*		for (int i=0; i<10 ;i++)
+	{
+		for (int j=0; j<i; j++)
+			printf("%d ", mat[i][j]);
+		printf("\n");
+	}
+*/
+	affiche_graph(mat, 10);
+	partition_connexe(part,mat,10);
+	affiche_part(part, 10);
+	
+	
+	system("dot -Tpng graph_part.dot -o graph_part.png");
+	nbpart=system("display graph_part.png &");
+	
+	nbpart=lister_partition(part,10,liste_part);	
+	for (int i=0;i<nbpart;i++)
+	{
+		nbel=lister_classe_naif(part,liste_part[i],10,liste_classe);
+		for (int j=0; j<nbel; j++)
+		{
+			printf("%d ",liste_classe[j]);
+		}
+		printf("\n");
+		affiche_graph2(mat,liste_classe,nbel);
+	}
+	libere_mat(mat,10);
+	free(part);
+	return 0;
+}			

laby/graph.h

+#ifndef _gard_graph_
+#define _gard_graph_
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include<ctype.h>
+#include <time.h>
+#include "partition.h"
+
+int ** creer_mat(int n);
+void remplir_mat(int ** mat, int n);
+
+void affiche_graph(int ** mat, int n);
+
+void partition_connexe(partition_t *,int **,int);
+
+void affiche_graph2(int ** mat, int *,int n);
+
+int main();
+#endif

laby/graph_aretes.c

+#include "graph_aretes.h"
+
+graph_t * creer_graph(int n)
+{
+	graph_t* graph= malloc(sizeof(graph_t));
+	graph->liste=NULL;
+	graph->noeuds=n;
+	return graph;
+}
+
+void ajouter_aretes(graph_t *graph, int un, int deux, int valuation)
+{
+	aretes_t * cours=graph->liste;
+	aretes_t * nouv= malloc(sizeof(aretes_t));
+	nouv->un=un;
+	nouv->deux=deux;
+	nouv->suiv=cours;
+	nouv->valuation=valuation;
+	graph->liste=nouv;
+	
+}
+
+aretes_t* liberer_aretes(aretes_t	* aretes)
+{
+	if (aretes)
+	{
+		aretes_t	* sauv=aretes->suiv;
+		free(aretes);
+		return liberer_aretes(sauv);
+	}
+	else
+		return aretes;
+}
+	
+void affiche_graph_couple(graph_t * graph,int taille)
+{
+	FILE *fichier;
+	fichier=fopen("graph1.dot","w");
+	if (fichier==NULL)
+		printf("echec de louverture du fichier\n");
+	else 
+		fprintf(fichier,"graph Nom{\n");
+
+	aretes_t * cours=graph->liste;
+	for (int i=0; i<taille; i++)
+	{
+		fprintf(fichier,"%d",i);
+		fprintf(fichier,";");
+	}
+		
+	while (cours)
+	{
+		fprintf(fichier,"%d",cours->un);
+		fprintf(fichier,"--");
+		fprintf(fichier,"%d",cours->deux);
+			fprintf(fichier," [label=%d]",cours->valuation);
+		fprintf(fichier,";");
+		cours=cours->suiv;
+	}
+
+	fprintf(fichier, "}");
+	fclose(fichier);
+	system("dot -Tpng graph1.dot -o graph1.png");
+	system("display graph1.png &");
+	
+}
+
+void affiche_graph2(graph_t * graph, partition_t * part, int classe,int taille )
+{
+	FILE *fichier;
+	fichier=fopen("graph_co.dot","w");
+	if (fichier==NULL)
+		printf("echec de louverture du fichier\n");
+	else 
+		fprintf(fichier,"graph Nom{\n");
+	int classe_cours;
+	aretes_t * cours=graph->liste;
+	for (int i=0; i<taille; i++)
+	{
+		classe_cours=recuperer_classe(i, part);
+		if (classe==classe_cours)
+		{
+			fprintf(fichier,"%d",i);
+			fprintf(fichier,";");
+		}
+	}
+		
+	while (cours)
+	{
+		classe_cours=recuperer_classe(cours->un, part);
+		if (classe==classe_cours)
+		{
+			fprintf(fichier,"%d",cours->un);
+			fprintf(fichier,"--");
+			fprintf(fichier,"%d",cours->deux);
+			fprintf(fichier," [label=%d]",cours->valuation);
+			fprintf(fichier,";");
+		}
+		cours=cours->suiv;
+	}
+
+	fprintf(fichier, "}");
+	fclose(fichier);
+	system("dot -Tpng graph_co.dot -o graph_co.png");
+	system("display graph_co.png ");
+	
+}
+
+void partition_connexe(partition_t* part, graph_t * graph)
+{
+	aretes_t * cours=graph->liste;
+	while (cours)
+	{
+		fusion(cours->un,cours->deux,part);
+		cours=cours->suiv;
+	}
+}
+
+int main()
+{
+	int noeuds=10;
+  	srand(time(0));
+//	int ** mat=NULL;
+ // 	mat= creer_mat(10);
+	graph_t * graph=creer_graph(noeuds);
+	partition_t * part=creer(noeuds);
+  	int liste_part[noeuds];
+  	int nbpart;
+/*		for (int i=0; i<10 ;i++)
+	{
+		for (int j=0; j<i; j++)
+			printf("%d ", mat[i][j]);
+		printf("\n");
+	}
+*/
+	for (int i=0; i<10; i++)
+		ajouter_aretes(graph,1+rand()%9,1+ rand()%9,1 +rand()%20);
+	
+	affiche_graph_couple(graph,noeuds);
+  	partition_connexe(part,graph);
+  	affiche_part(part,noeuds);
+	
+	
+  	system("dot -Tpng graph_part.dot -o graph_part.png");
+  	nbpart=system("display graph_part.png &");
+	
+  	nbpart=lister_partition(part,10,liste_part);	
+	for (int i=0;i<nbpart;i++)
+	{
+		affiche_graph2(graph,part,liste_part[i], noeuds);
+	}
+	
+	liberer_aretes (graph->liste);
+	free(graph);
+	free(part);
+	return 0;
+}			

laby/graph_aretes.h

+#ifndef _gard_graph_aretes_
+#define _gard_graph_aretes_
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include<ctype.h>
+#include <time.h>
+#include "partition.h"
+
+typedef struct aretes
+{
+	int un;
+	int deux;
+	int valuation;
+	struct aretes * suiv;
+}aretes_t;
+
+
+typedef struct graph
+{
+	int noeuds;
+	aretes_t * liste;
+}graph_t;
+
+
+graph_t * creer_couple(int n);
+void remplir_couple(graph_t *);
+
+void affiche_graph_couple(graph_t *,int);
+
+void partition_connexe(partition_t *,graph_t *);
+
+void affiche_graph2(graph_t *,partition_t *, int, int);
+
+void ajouter_aretes(graph_t *, int, int, int);
+
+aretes_t * liberer_aretes(aretes_t *);
+
+int main();
+#endif

laby/graph_aretes_tab.c

+#include "graph_aretes_tab.h"
+
+int plusgrand(aretes_t a, aretes_t b)
+{
+	return a.valuation>b.valuation;
+}
+
+graph_t * creer_graph(int n, int nb_aretes)
+{
+	graph_t* graph= malloc(sizeof(graph_t));
+	graph->liste= malloc(nb_aretes*sizeof(aretes_t));
+	graph->noeuds=n;
+	graph->nb_aretes=nb_aretes;
+	return graph;
+}
+
+void affiche_graph_couple(graph_t * graph,int taille, int nb_aretes)
+{
+	FILE *fichier;
+	fichier=fopen("graph1.dot","w");
+	if (fichier==NULL)
+		printf("echec de louverture du fichier\n");
+	else 
+		fprintf(fichier,"graph Nom{\n");
+
+	for (int i=0; i<taille; i++)
+	{
+		fprintf(fichier,"%d",i);
+		fprintf(fichier,";");
+	}
+		
+	
+	for (int j=0; j<nb_aretes; j++)
+	{
+		fprintf(fichier,"%d",graph->liste[j].un);
+		fprintf(fichier,"--");
+		fprintf(fichier,"%d",graph->liste[j].deux);
+		fprintf(fichier," [label=%d]",graph->liste[j].valuation);
+		fprintf(fichier,";");
+	}
+
+	fprintf(fichier, "}");
+	fclose(fichier);
+	system("dot -Tpng graph1.dot -o graph1.png");
+	system("display graph1.png &");
+	
+}
+
+void affiche_graph2(graph_t * graph, partition_t * part, int classe,int taille,int nb_aretes )
+{
+	FILE *fichier;
+	fichier=fopen("graph_co.dot","w");
+	if (fichier==NULL)
+		printf("echec de louverture du fichier\n");
+	else 
+		fprintf(fichier,"graph Nom{\n");
+	int classe_cours;
+	for (int i=0; i<taille; i++)
+	{
+		classe_cours=recuperer_classe(i, part);
+		if (classe==classe_cours)
+		{
+			fprintf(fichier,"%d",i);
+			fprintf(fichier,";");
+		}
+	}
+		
+	for (int j=0; j<nb_aretes;j++)
+	{
+		classe_cours=recuperer_classe(graph->liste[j].un, part);
+		if (classe==classe_cours)
+		{
+			fprintf(fichier,"%d",graph->liste[j].un);
+			fprintf(fichier,"--");
+			fprintf(fichier,"%d",graph->liste[j].deux);
+			fprintf(fichier," [label=%d]",graph->liste[j].valuation);
+			fprintf(fichier,";");
+		}
+	}
+
+	fprintf(fichier, "}");
+	fclose(fichier);
+	system("dot -Tpng graph_co.dot -o graph_co.png");
+	system("display graph_co.png ");
+	
+}
+
+void partition_connexe(partition_t* part, graph_t * graph,int nb_aretes)
+{
+	for (int j=0; j<nb_aretes;j++)
+	{
+		fusion(graph->liste[j].un,graph->liste[j].deux,part);
+	}
+}
+/*
+int main()
+{
+	int noeuds=10;
+  	srand(time(0));
+	int nb_aretes=5;
+//	int ** mat=NULL;
+ // 	mat= creer_mat(10);
+	graph_t * graph=creer_graph(noeuds,nb_aretes);
+	partition_t * part=creer(noeuds);
+  	int liste_part[noeuds];
+  	int nbpart;
+		for (int i=0; i<10 ;i++)
+	{
+		for (int j=0; j<i; j++)
+			printf("%d ", mat[i][j]);
+		printf("\n");
+	}
+
+	for (int i=0; i<nb_aretes; i++)
+	{
+		graph->liste[i].un=rand()%noeuds;
+		graph->liste[i].deux=rand()%noeuds;
+		graph->liste[i].valuation=rand()%noeuds;
+	}
+	
+	affiche_graph_couple(graph,noeuds,nb_aretes);
+  	partition_connexe(part,graph,nb_aretes);
+  	affiche_part(part,noeuds);
+	
+	
+  	system("dot -Tpng graph_part.dot -o graph_part.png");
+  	nbpart=system("display graph_part.png &");
+	
+  	nbpart=lister_partition(part,10,liste_part);	
+	for (int i=0;i<nbpart;i++)
+	{
+		affiche_graph2(graph,part,liste_part[i], noeuds,nb_aretes);
+	}
+
+	free(graph->liste);	
+	free(graph);
+	free(part);
+	return 0;
+}*/			

laby/graph_aretes_tab.h

+#ifndef _gard_graph_aretes_tab_
+#define _gard_graph_aretes_tab_
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include<ctype.h>
+#include <time.h>
+#include "partition.h"
+
+typedef struct aretes
+{
+	int un;
+	int deux;
+	int valuation;
+}aretes_t;
+
+
+typedef struct graph
+{
+	int noeuds;
+	int nb_aretes;
+	aretes_t * liste;
+}graph_t;
+
+int plusgrand(aretes_t, aretes_t);
+
+graph_t * creer_graph(int n,int);
+
+void remplir_couple(graph_t *);
+
+void affiche_graph_couple(graph_t *,int,int);
+
+void partition_connexe(partition_t *,graph_t *,int);
+
+void affiche_graph2(graph_t *,partition_t *, int, int,int);
+
+int main();
+#endif

laby/kruskal.c

+#include "kruskal.h"
+
+int ** tableau_ligne(graph_t * graph,int nb_aretes)
+{
+	int** tab=malloc(N*sizeof(int*));
+	for (int i=0; i<N; i++)
+		tab[i]=malloc(P*sizeof(int));	
+	int diff;
+	int x;
+	int y;
+	for (int i=0; i<nb_aretes; i++)
+	{
+		diff=graph->liste[i].un - graph->liste[i].deux;
+		x=graph->liste[i].un%N;
+		y=graph->liste[i].un%P;
+		if (x==0)
+			tab[x][y]+=8;
+		if (y==0)
+			tab[x][y]+=1;
+		if (diff==1)
+			tab[x][y]+=4;
+		else 
+			tab[x][y]+=2;
+	}
+	return tab;			
+}
+
+graph_t * kruskal(graph_t * graph,int noeuds, int nb_aretes,int * cours)
+{
+	int c1;
+	int c2;
+   graph_t * A=creer_graph(noeuds,nb_aretes);
+   partition_t * partA=creer(noeuds);
+
+	for (int i=0; i<nb_aretes;i++)
+	{
+//	printf("dans le for\n");
+//	printf("%d \n", graph->liste[i].un);
+  // affiche_part(partA,noeuds);
+		c1=recuperer_classe(graph->liste[i].un,partA);
+		c2=recuperer_classe(graph->liste[i].deux, partA);
+//	printf("%d %d\n",c1,c2);
+		if (c1!=c2)
+		{
+			A->liste[*cours]=graph->liste[i];
+			fusion(A->liste[*cours].un,A->liste[*cours].deux,partA);
+			*cours+=1;
+		}
+	}
+	return A;
+}	
+
+graph_t * Fisher(graph_t * graph, int nb_aretes)
+{
+	aretes_t aux;
+	int random;
+	for (int i=nb_aretes-1; i>0; i--)
+	{
+		random=rand()%i;
+//		printf("%d ",random);
+		aux=graph->liste[random];
+		graph->liste[random]=graph->liste[i];
+		graph->liste[i]=aux;
+	}
+	return graph;
+}
+
+int generation(graph_t * graph, int n, int p)
+{
+	int nb_aretes=0;
+	int rand1;
+	int rand2;
+	for (int i=0; i<n*p; i++)
+	{
+		rand1=(rand