Commit de4059ec authored by Valentin MEUNIER's avatar Valentin MEUNIER
Browse files

on ajoute tout

parent b6d01776
#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"
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;
}*/
#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
#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()%8);
rand2=(rand()%8);
printf("%d %d\n",rand1,rand2);