/*Cette fonction affiche tous les éléments de la pile*/
void affiche_pile (pile *p)
{
if (!estVide(p))
{
Cell *c=p->top;
while (c!=NULL)
{
printf("joueur:%d x:%d y:%d, borne=%d\n",c->elt.joueur,c->elt.coordonnee_x,c->elt.coordonnee_y,c->elt.borne);
c=c->next;
}
}
}
/**
* Retire le premier élément de la Pile 'p' et l'incrit dans 'tn'.
*
* Note : si la pile 'p' est vide, l'appel est bloquant jusqu'à ce qu'un élément
* y soit inséré.
*/
void depile( Pile * p, TabNombres * val)
{
while ( estVide( p ) )
{
//if(stop){
pthread_exit(NULL);
//}
}
*val = p->T [ p->sommet ];
--( p->sommet );
}
/*Cette fonction renvoie l'élément qui est au sommet de la pile*/
element sommet (pile *p)
{
element som;
som.coordonnee_x=0;
som.coordonnee_y=0;
som.joueur=-1;
som.borne=0;
if (!estVide(p))
{
Cell *c=p->top;
som=c->elt;
}
return som;
}
void afficherParcoursLargeur(const Abin a)
{
FileAttente f;
init(f);
ajoutQueue(f, a);
while (!estVide(f)) {
if (!estVide(gauche(getTete(f)))) {
ajoutQueue(f, gauche(getTete(f)));
}
if (!estVide(droite(getTete(f)))) {
ajoutQueue(f, droite(getTete(f)));
}
cout << racine(getTete(f));
retirerTete(f);
}
//desinit(f);
}
Mras2an_struct * suppDebut(Mras2an_struct * l)
{
Mras2an_struct * temp;
if (estVide(l))
{
return NULL;
}
else
{
temp=l;
l = l->suivant;
free(temp);
return l;
}
}
/*Cette fonction dépile la pile, elle renvoie l'élément dépilé*/
element depiler(pile *p)
{
element e_depile;
e_depile.coordonnee_x=0;
e_depile.coordonnee_y=0;
e_depile.joueur=-1;
e_depile.borne=0;
if (!estVide(p))
{
Cell *cellule_depilee=p->top;
e_depile=cellule_depilee->elt;
p->top=cellule_depilee->next;
free(cellule_depilee);
}
return e_depile;
}
llist supprimerElementEnTete(llist liste)
{
if(!estVide(liste))
{
/* Si la liste est non vide, on se prépare à renvoyer l'adresse de
l'élément en 2ème position */
element* aRenvoyer = liste->nxt;
/* On libère le premier élément */
free(liste);
/* On retourne le nouveau début de la liste */
return aRenvoyer;
}
else
{
return NULL;
}
}
void afficherListe(llist liste)
{
if(estVide(liste)){
printf("La liste est vide");
}
else{
element *tmp = liste;
/* Tant que l'on n'est pas au bout de la liste */
while(tmp != NULL)
{
/* On affiche */
printf("%d ", tmp->val);
/* On avance d'une case */
tmp = tmp->nxt;
}
}
}
Arbre ajout(const Arbre arbre, int e) {
Cell* newCell;
newCell = (Cell*)malloc(sizeof(Cell));
newCell->racine = e;
newCell->gauche = NULL;
newCell->gauche = NULL;
if(estVide(arbre)) {
arbre = newCell;
} else {
if(e <= arbre->racine) {
arbre->gauche = ajout(arbre->gauche, e);
} else {
arbre->droite = ajout(arbre->droite, e);
}
}
return arbre;
}
int recherche(Mras2an_struct * l, int X)
{
if (estVide(l))
{
return 0;
}
else
{
if (X == l->compt)
{
return 1;
}
else
{
return(recherche(l->suivant,X));
}
}
}
T_ELT acceder(const cartouchiere &c, int p)//throw std::exception
{
if(p < 0 || p >= c.nb || estVide(c,p))//indice incorrect ou le maillon p n'existe pas
{
throw std::exception();
}
else
{
maillon *m = c.tete;
while(m != 0)//parcourt des maillons
{
if((*m).numero == p)//on retourne l'élément du maillon numéro p
{
return (*m).elt;
}
m = (*m).suiv;
}
}
}
calcIA(Jeu *jeu, int prof){
int i,j,tmp;
int max = MINEVAL;
int maxi=-1,maxj=-1;
if((prof!=0)){
for(i=0;i<10; i++)
for(j=0;j<10;j++){
if(estVide(i,j)){
joue(i,j);
tmp = calcMin(jeu, prof-1);
if((tmp>max)||((tmp==max)&&(Rand::randi(2)))){
max = tmp;
maxi = i;
maxj = j;
}
}
}
}
jeu->joue(maxi,maxj);
}
void parcourirTouteau(s_grille* g, int x,int y)
{
liste_element *file = (liste_element*)malloc(sizeof(liste_element));// liste finale des noeuds de la file d'attente
element *s = (element*)malloc(sizeof(element));
element *ps = (element*)malloc(sizeof(element));
element*p = (element*)malloc(sizeof(element)); // noeuds du chemin
int i,j;
int ii,jj;
int compteur=500;/// LIMITE pour le dessalement
ps=&g->elem[x][y];
//on met toutes les marques à zero
for(i=0; i<L; i++)
{
for(j=0; j<H; j++)
{
if(g->elem[i][j].etatsssol==1)
g->elem[i][j].marque_eau=0;
}
}
// on alloue la liste, on enfile le premier noeud dans la liste
file->queue=file->tete=NULL;
file->taille=0;
// enfiler(g,file, ps);
////////////////////////////////////////////////////////////////////////////////////////////
element* nouveau=(element*)malloc(sizeof(element));
nouveau->next=NULL;
nouveau->i=ps->i;
nouveau->j=ps->j;
if (file->taille==0)
file->tete = file->queue = nouveau ;
else
{
file->queue->next = nouveau ;
file->queue = nouveau ;
}
file->taille++ ;
/////////////////////////////////////////////////////////////////////////////////////////////
// si le noeud de départ ps n'a pas de voisin, retourner la liste qui ne contient que ce noeud
/* if (g->[ps->i][ps->j]==NULL)
return ;
*/
// marquer le noeud de départ ps
g->elem[ps->i][ps->j].marque_eau = 1;
g->elem[ps->i][ps->j].alimeau= 1;//on dit que la canalisation est alimentée en eau
// tant que la file d'attente n'est pas vide et que le noeud out n'est pas atteint
while (!estVide(file) && compteur>0)
{
//printf("passage\n");
s = defiler(file); // défiler le premier noeud de la liste
// printf("defiler: %d::%d\n",s->i,s->j);
// si le noeud défilé arrive au noeud de sortie out (s'il existe), on sort
//printf("taille:%d\n",g->file_elemeau[s->i][s->j].taille);
// le noeud défilé n'est pas out, enfiler ses voisins non marqués
if (&g->elem[s->i][s->j] != NULL && (g->file_elemeau[s->i][s->j].taille!=0))
{
//printf("passage\n");
for(p = g->file_elemeau[s->i][s->j].tete ; p != NULL ; p = p->next)
{
if (g->elem[p->i][p->j].marque_eau==0)
{
// printf("coucou%d::%d",p->i,p->j);
////////////////////////////////////////////////////////////////////////////////////////////////////////
element* nouveau=(element*)malloc(sizeof(element));
nouveau->next=NULL;
nouveau->i=p->i;
nouveau->j=p->j;
if (file->taille==0)
file->tete = file->queue = nouveau ;
else
{
file->queue->next = nouveau ;
file->queue = nouveau ;
}
file->taille++ ; // empiler le noeud voisin dans la liste
/////////////////////////////////////////////////////////////////////////////////////////////////
///VERIFICATION DES MAISONS AUX ALENTOURS DE LA CASE D'EAU
if(compteur>0)
{
int temp=0;
for(ii=-5; ii<6; ii++)
{
for(jj=-temp; jj<temp+1; jj++)
{
if((g->elem[p->i+jj][p->j+ii].etatsol==3)&&(p->i+jj<L)&&(p->j+ii<H)&&(p->i+jj>0)&&(p->j+ii>0)&&(g->elem[p->i+jj][p->j+ii].alimeau==0))
{
g->elem[p->i+jj][p->j+ii].alimeau=1;
compteur=compteur-g->elem[p->i+jj][p->j+ii].habitant; /// On décrémente le compteur
printf("alim_maison eau");
}
}
if(ii<0) temp++;
else temp--;
}
}
/* for(ii=0; ii<5; ii++)
{
if((g->elem[p->i+ii][p->j].etatsol==3)&&(p->i+ii<40)&&(g->elem[p->i+ii][p->j].alimeau==0))//3 conditions : La case est une maison, blindage i
{
printf("alim_maison");
//Et la maison n'est pas encore alimentée
g->elem[p->i+ii][p->j].alimeau=1;/// La maison est connectée à la canalisation
compteur=compteur-g->elem[p->i+ii][p->j].habitant; /// On décrémente le compteur
}
if((g->elem[p->i-ii][p->j].etatsol==3)&&(i-ii>0)&&(g->elem[p->i-ii][p->j].alimeau==0))
{
printf("alim_maison");
g->elem[p->i-ii][p->j].alimeau=1;
compteur=compteur-g->elem[p->i-ii][p->j].habitant; /// On décrémente le compteur
}
if((g->elem[p->i][p->j-ii].etatsol==3)&&(p->j-ii>0)&&(g->elem[p->i][p->j-ii].alimeau==0))
{
printf("alim_maison");
g->elem[p->i][p->j-ii].alimeau=1;
compteur=compteur-g->elem[p->i][p->j-ii].habitant; /// On décrémente le compteur
}
if((g->elem[p->i][p->j+ii].etatsol==3)&&(p->j+ii<40)&&(g->elem[p->i][p->j+ii].alimeau==0))
{
printf("alim_maison");
g->elem[p->i][p->j+ii].alimeau=1;
compteur=compteur-g->elem[p->i][p->j+ii].habitant; /// On décrémente le compteur
}
}*/
/// FIN de vérification des maisons autour de la case
g->elem[p->i][p->j].marque_eau = 1; // marquer le noeud du noeud voisin
g->elem[p->i][p->j].alimeau= 1;//on dit que la canalisation est alimentée en eau
}
// printf("coucou\n");
// soprintf("voisinsuiv:%d::%d\n",p->next->i,p->next->j);
}
}
}
}
Expression& Pile::top() const {
if (estVide()) throw ComputerException("Aucune expression sur la pile");
return *items.top();
}
/**
* @brief Résout un puzzle
* @param[in,out] p le puzzle à résoudre
* @param[in] t le damier initial
* @param[in,out] os flux de sortie
*/
void jouer(Puzzle& p, const Tab2D& t, std::ostream& os) {
Etat etatInitial;
Etat etatCourant;
Tab2D damierFinal;
Etat etatDerive;
double tempsDebutRecherche = getTime();
but(damierFinal, t.nbL, t.nbC);
initialiser(etatInitial.damier, t.nbL, t.nbC);
etatInitial.mouvement = FIXE;
etatInitial.precedent = 0;
etatInitial.g = 0;
//Copie du damier inititial dans etatInitial
for (unsigned int l = 0; l < t.nbL; ++l) {
for (unsigned int c = 0; c < t.nbC; ++c) {
etatInitial.damier.tab[l][c] = t.tab[l][c];
}
}
etatInitial.h = manhattan(etatInitial.damier, damierFinal);
initialiser(etatDerive.damier, t.nbL, t.nbC);
inserer(p.lEAE, 0, etatInitial); //étatInitial dans LEAE
bool solutionTrouvee = false;
bool mvtPossible;
unsigned int pos;
while (p.lEAE.nb != 0) {
pos = minimal(p.lEAE);
etatCourant = lire(p.lEAE, pos); //on prend le 1er état à explorer
//insérer étatCourant dans LEE
inserer(p.lEE, longueur(p.lEE), etatCourant);
supprimer(p.lEAE, pos); //supprimer étatCourant de LEAE
if (etatCourant.h == 0) { // le damier de étatCourant est le damier but
solutionTrouvee = true;
break; //sortir de la boucle while
}
/*pour_tout (mouvement possible associé à étatCourant)
mouvement possible relatif à damier de étatCourant (etatCourant.damier)
ordre d'exploration (obligatoire) NORD, EST, SUD, OUEST */
//initialiser un étatDérivé // d'après le mouvement
for(int m = OUEST; m >= NORD; --m) {
mvtPossible = deriver(etatCourant, (Mouvement) m, etatDerive);
if (mvtPossible && !rechercher(etatDerive, p.lEAE)\
&& !rechercher(etatDerive, p.lEE)) {
etatDerive.precedent = longueur(p.lEE) - 1;
etatDerive.h = manhattan(etatDerive.damier, damierFinal);
etatDerive.g = etatCourant.g + 1;
//insérer étatDérivé dans LEAE
inserer(p.lEAE, longueur(p.lEAE), etatDerive);
}
}
}
double tempsFinRecherche = getTime();
cout << "Durée de recherche : " << tempsFinRecherche - tempsDebutRecherche
<<" seconde(s)."<< endl;
if (solutionTrouvee) {
Pile sol;
Etat etatSol;
initialiser(sol, 3, 2);
initialiser(etatSol.damier, t.nbL, t.nbC);
//Stockage de la solution
etatSol = lire(p.lEE, longueur(p.lEE)-1);
empiler(sol, etatSol);
while (etatSol.precedent != 0) {
etatSol = lire(p.lEE, etatSol.precedent);
empiler(sol, etatSol);
}
empiler(sol, etatInitial);
//Affichage de la solution
os << "Damier : " << t.nbL << " lignes " << t.nbC << " colonnes"
<< endl;
os << "Solution en " << sol.sommet << " mouvements" << endl;
while (!estVide(sol)) {
afficher(sommet(sol), os);
os << endl;
depiler(sol);
}
detruire(sol);
detruire(etatSol.damier);
}
else {
os << "Solution non trouvée" << endl;
}
detruire(etatInitial.damier);
detruire(etatCourant.damier);
detruire(etatDerive.damier);
detruire(damierFinal);
}
int main() {
int i;
liste li = nouvListe(), li2 = nouvListe();
adjt(1, li);
adjt(5, li);
adjt(-7, li);
printf ("liste : "); affiche(li);
printf("taille : %d\n", taille(li));
printf("vide ? : %s\n", (estVide(li)?"oui":"non"));
for(i=1; i <= 10; ++i) {
adjq(i*i, li2);
}
printf ("liste : "); affiche(li2);
printf("tete : %d queue : %d\n", tete(li2), queue(li2));
printf("====== suppressions =========\n");
supt(li2);
printf ("apres supt : "); affiche(li2);
supq(li2);
printf ("apres supq : "); affiche(li2);
// creation de deux listes avec des elements choisis au hasard
printf("====== tris et renversement =========\n");
srand(time(NULL)); // initialisation de la suite aleatoire
printf("liste 11 : ");
liste l1 = nouvListe();
for(i=0; i < 15; ++i) {
adjt(rand()%30, l1);
}
affiche (l1);
printf("liste 12 : ");
liste l2 = nouvListe();
for(i=0; i < 10; ++i) {
adjt(rand()%30, l2);
}
affiche (l2);
liste l1t = trie(l1);
liste l2t = trie(l2);
printf("liste 11 apres trie : "); affiche(l1t);
printf("liste 12 apres trie : "); affiche(l2t);
liste l3t = interclasse(l1t,l2t);
printf("interclassement : "); affiche(l3t);
printf("renversement iter : "); affiche(renverse_iter(l3t));
printf("renversement recur : "); affiche(renverse_recur(l3t));
printf("====== palindrome =========\n");
liste lpalin = nouvListe();
adjt(1, lpalin);
adjt(2, lpalin); adjq(2, lpalin);
adjt(8, lpalin); adjq(8, lpalin);
printf("liste : "); affiche(lpalin);
printf("Palindrome (iter) ? %s\n", (palindrome_iter(lpalin)?"oui":"non"));
printf("Palindrome (recur) ? %s\n", (palindrome_recur(lpalin)?"oui":"non"));
supt(lpalin);
printf("liste : "); affiche(lpalin);
printf("Palindrome (iter) ? %s\n", (palindrome_iter(lpalin)?"oui":"non"));
printf("Palindrome (recur) ? %s\n", (palindrome_recur(lpalin)?"oui":"non"));
return 0;
}
