void propage(int x , int y , int val, int dir){
printf(" -------- %d %d \n\n", x , y );
//gauche
if(dir!= 4 && x -2 >0 && laby[x-2][y] == val){
laby[x -1][y] = laby[x][y];
laby[x -2][y] = laby[x][y];
// nb_point_laby--;
propage(x-2,y ,val,2);
}
// droite
if (dir!= 2 && x+2 < MT-1 && laby[x+2][y] == val){
laby[x +1][y] = laby[x][y];
laby[x +2][y] = laby[x][y];
// nb_point_laby--;
propage(x+2,y ,val , 4);
}
//haut
if (dir!= 1 && y-2 >0 &&laby[x][y-2] == val){
laby[x][y - 1] = laby[x][y];
laby[x][y - 2] = laby[x][y];
// nb_point_laby--;
propage(x,y-2,val, 3);
}
//bas
if (dir!= 3 && y+2 < MT-1 && laby[x][y+2] == val){
laby[x][y + 1] = laby[x][y];
laby[x][y + 2] = laby[x][y];
// nb_point_laby--;
propage(x,y+2,val,1);
}
else return;
}
/**
* Détermine si l'une des clauses de la formule est insatisfaite selon une interprétation donnée et effectue la propagation des valeurs qui peuvent être déduites.
* Si la valeur de vérité de l'une des clauses est indéterminée et que la valeur d'une seule variable n'est pas définie, elle est définie à VRAI.
* @param id_var La variable dont on veut tester si elle rend la formule insatisfiable.
* @param interpretation L'interprétation selon laquelle les clauses seront évaluées.
* @param index L'index des clauses de la formule.
* @param deduites La liste des variables dont la valeur est déduite des précédentes affectations.
* @return VRAI si l'une des clauses n'est pas satisfiable avec l'interprétation donnée. FAUX sinon.
* @see indexeClauses(forme_conjonctive&)
* @see contientInsatisfaite(const unsigned int, const short int*, const index_clauses&)
* @see cherche4(const forme_conjonctive&, short int *, const unsigned int, const index_clauses&, const unsigned int)
*/
bool propage(const unsigned int id_var, short int *interpretation, const index_clauses &index, vector<unsigned int> &deduites) {
unsigned int indice = id_var - 1;
int litt_var_suiv = 0;
short int clause_satisfaite;
map< unsigned int, vector<clause*> >::const_iterator it_clauses;
vector<clause*> clauses;
if(interpretation[indice] == 0) {
return false;
}
if(interpretation[indice] > 0) {
if((it_clauses = index.neg.find(id_var)) == index.neg.end()) {
return false;
}
} else {
if((it_clauses = index.pos.find(id_var)) == index.pos.end()) {
return false;
}
}
clauses = it_clauses->second;
for(vector<clause*>::const_iterator it=it_clauses->second.begin(); it!=it_clauses->second.end(); it++) {
clause_satisfaite = clause_est_satisfaite((**it), interpretation);
if(clause_satisfaite == -1) { // clause insatisfaite
return true;
} else if(clause_satisfaite == 0) { // clause indeterminée
for(vector<int>::iterator it_litt=(*it)->begin(); it_litt!=(*it)->end(); it_litt++) {
if(interpretation[abs(*it_litt)-1] == 0) {
if(litt_var_suiv == 0) { // 1° variable indéterminée
litt_var_suiv = *it_litt;
} else { // 2° variable indéterminée -> pas de propagation possible
litt_var_suiv = 0;
break;
}
}
}
}
if(litt_var_suiv != 0) { // propagation
unsigned int id_var_suiv = abs(litt_var_suiv);
deduites.push_back(id_var_suiv);
interpretation[id_var_suiv-1] = litt_var_suiv / id_var_suiv;
propage(id_var_suiv, interpretation, index, deduites);
}
}
return false;
}
/**
* Cherche une interprétation pour laquelle la forme conjonctive est satisfaite.
* S'appelle récursivement pour tester les interprétations possibles.
* Si l'affectation d'une valeur à une variable rend la formule insatisfiable, toutes les interprétations utilisant cette affectation sont ignorées.
* Si la fonction retourne VRAI, le paramètre interprétation contient l'interprétation satisfaisant la forme conjonctive.
* @param fc La forme conjonctive à évaluer.
* @param interpretation L'interprétation courante.
* @param nb_var Le nombre de variables de la formule.
* @param index L'index des clauses selon les littéraux qu'elles contiennent.
* @param id_var Le numéro de la variable en cours de traitement. Ce paramètre DOIT ÊTRE OMIS ou mis à sa valeur par défaut : 1.
* @return VRAI si la forme conjonctive est satisfiable. FAUX sinon.
* @see cherche1(const forme_conjonctive&, short int*, const unsigned int, const unsigned int)
* @see cherche2(const forme_conjonctive&, short int*, const unsigned int, const unsigned int)
* @see cherche3(const forme_conjonctive&, short int *, const unsigned int, const index_clauses&, const unsigned int)
*/
bool cherche4(const forme_conjonctive &fc, short int *interpretation, const unsigned int nb_var, const index_clauses &index, const unsigned int id_var) {
const int indice = id_var - 1;
vector<unsigned int> deduites;
for(interpretation[indice]=1; interpretation[indice]>=-1; interpretation[indice] -= 2) { // 1,-1
if(!propage(id_var, interpretation, index, deduites)) {
if(id_var < nb_var) { // S'il reste des variables indéfinies
if(cherche4(fc, interpretation, nb_var, index, id_var + 1)) {
return true;
}
} else {
return true;
}
}
}
for(vector<unsigned int>::iterator it_ded=deduites.begin(); it_ded!=deduites.end(); it_ded++) {
interpretation[(*it_ded)-1] = 0;
}
return false;
}
void creat_laby(void){
int x , y ;
int h =0, v=0 ,old_value = 0 , ob, direction = 0;;
int nb_point_laby = M*M;
while ( nb_point_laby !=1){
x = (rand()% 5 ) *2 +1 ;
y = (rand()% 5 ) *2 +1 ;
ob = rand()% 2;
if(ob ==0)
h = (rand()%2)*2 -1;
else
v = (rand()%2)*2 -1;
if(h ==-1) direction = 4;
if(h == 1) direction = 2;
if( x+ h*2 > MT-1 ||x+ h*2< 0 || y+ v*2 > MT-1 || y+ v*2< 0 )continue ;
if(h ==-1) direction = 4;
else if(h == 1) direction = 2;
if(v ==-1) direction = 1;
else if(v == 1) direction = 3;
if( laby[x][y] == laby[x + h*2][y + v*2] ){printf(" %d %d\n",laby[x][y], laby[x + h*2][y + v*2] ); continue;}
if( laby[x][y] < laby[x + h*2][y + v*2] ){
printf("ENtre dans le test plsu petir\n\n" );
laby[x][y] = laby[x + h*2][y + v*2];
laby[x+h][y+v] = laby[x + h*2][y + v*2];
nb_point_laby--;
continue;
// return;
}
printf("Apres le Ir hor = %d , vert = %d \n\n" , h , v );
old_value =laby[x + h*2][y + v*2] ;
printf("oldvalue %d x = %d y = %d \n\n",old_value , x + h*2 ,y + v*2 );
laby[x + h][y + v] = laby[x][y] ;//laby[x][y];
laby[x + h*2][y + v*2] = laby[x][y];//laby[x][y];
nb_point_laby--;
printf("ENtre dans Propage \n\n" );
propage(x + h* 2,y + v*2 ,old_value , direction);
printf("Sort de Propage \n\n" );
}
// printf("",old_value , laby[x + h*2][y + v*2] );
}