Commit 7921572e authored by Valentin MEUNIER's avatar Valentin MEUNIER
Browse files

Merge branch 'valentinSDL' into 'master'

Valentin sdl

See merge request !6
parents 8ebb2c87 c5c8df88
No preview for this file type
......@@ -98,7 +98,7 @@ int vie_mort(int * survie)
vie=0;
else if (total==3)
vie=1;
else if (total==2 && survie[9]==1)
else if (total==2 && survie[8]==1)
vie=1;
free(survie);
return vie;
......
#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;
}
#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
#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;
}
#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
#include "graph_aretes_tab.h"
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;
}
#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;
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
#include "kruskal.h"
int * tableau_ligne(graph_t * graph,int noeuds,int nb_aretes)
{
for (int i=0; i<nb_aretes; i++)
{
diff=graph->liste[i].un - graph->liste[i].deux
if (diff==1)
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()%8);
rand2=(rand()%8);
printf("%d %d\n",rand1,rand2);
if (rand1 && (i+1)%n)
{
graph->liste[nb_aretes].un=i;
graph->liste[nb_aretes].deux=i+1;
graph->liste[nb_aretes].valuation=1;
nb_aretes++;
}
if (rand2 && i<(n-1)*p)
{