lec 08_backt

Structures de donnéesLeçon n. 1 – Introduction et vue d’ensemble

Prof. A. EL FAKERENSIAS - UNIVERSITE MOHAMMED V SOUISSI

Leçon n° 8 – Conception de programmes : BackTracking

STRUCTURES DE

DONNÉES

STRUCTURES DE

DONNÉES




CONCEPTIONDE

PROGRAMMES:BACKTRACKING

CONCEPTIONDE

PROGRAMMES:BACKTRACKING




ObjectifsObjectifs

La recherche d’une réponseau problème nécessite la recherche d’un nombre important de solutions «plausibles»

La recherche d’une réponseau problème nécessite la recherche d’un nombre important de solutions «plausibles»

Problèmes visés Problèmes visés

Problèmes de type combinatoire

Problèmes de type combinatoire




SudokoSudoko

?4

79




Plan de la leçonPlan de la leçon

Problème du sac à dos Problème du sac à dos

Problème des n reines Problème des n reines

Permutation Permutation




Problèmesdu sac à dosProblèmes

du sac à dos




Problème du sac à dosProblème du sac à dos

Remplir un sac à dos avec un certain nombre d'objets de façon

à le remplir exactement

Remplir un sac à dos avec un certain nombre d'objets de façon

à le remplir exactement

Comment fait-on?Comment fait-on?





Le poids permis: S Le poids permis: S

Des poids: a0, a1, …, an Des poids: a0, a1, …, an

ModélisationModélisation





Existe-t-il des nombresxi {0,1} tels que


S = x0a0 + x1a1 + ... + xn-1an-1S = x0a0 + x1a1 + ... + xn-1an-1









Si xi=1 on doit prendre l'objet ai

Sinon on ne le prend pasSi xi=1 on doit prendre l'objet ai

Sinon on ne le prend pas





Algorithmede recherche des solutions

Algorithmede recherche des solutions

Doit être capable d'énumérer rapidement tous les n-uplets

de valeurs des xi

Doit être capable d'énumérer rapidement tous les n-uplets

de valeurs des xi





void sacADos3(int[] a, int S){ int S0, S1, S2; for(int x0 = 0; x0 < 2; x0++){ S0 = x0 * a[0]; for(int x1 = 0; x1 < 2; x1++){ S1 = S0 + x1 * a[1]; for(int x2 = 0; x2 < 2; x2++){ S2 = S1 + x2 * a[2]; if(S2 == S) printf("%d+%d+%d\n",x0,x1,x2); } } } }

Cas n=3Cas n=3





Traiter des cas particuliers fixes, exige de connaître n à la compilation

Traiter des cas particuliers fixes, exige de connaître n à la compilation

Le programme n'est pas évolutif Le programme n'est pas évolutif

Cas n=3Cas n=3





Deuxième approcheDeuxième approche

Toute solution peut s'écrire comme une suite de bits Toute solution peut s'écrire comme une suite de bits

x0 , x1 , ... , xn-1x0 , x1 , ... , xn-1

Correspond à un entier uniqueCorrespond à un entier unique

de l'intervalle I=[0, 2n[de l'intervalle I=[0, 2n[x = x020 + x121 + ... + xn-12n-1x = x020 + x121 + ... + xn-12n-1





Deuxième approcheDeuxième approche

Parcourir l'ensemble des solutionspossibles ou bien l’intervalle

Parcourir l'ensemble des solutionspossibles ou bien l’intervalle

I=[0, 2n[I=[0, 2n[

n=4 a={2,12,23,30} S=44n=4 a={2,12,23,30} S=44

x0, x1, x3 ou bien x=1101=13x0, x1, x3 ou bien x=1101=13





Enumération de I=[0,2n[Enumération de I=[0,2n[

Comment passer en revue tous les éléments de I? Comment passer en revue tous les éléments de I?

L’addition : +1 L’addition : +1






Programmer l'addition binaire sur un entier n représenté comme un tableau de bits x

Programmer l'addition binaire sur un entier n représenté comme un tableau de bits x






Gestion virtuelle de la retenue Gestion virtuelle de la retenue

Programmer l'addition binaire Programmer l'addition binaire

13 = 1+1+0+113 = 1+1+0+1

14 = 1+1+1+014 = 1+1+1+0






Gestion virtuelle de la retenue Gestion virtuelle de la retenue

// simulation de l'addition x[]=x[]+1 for(int j = 0; j < n; j++){ if(x[j] == 1) x[j] = 0; else{ x[j] = 1; break; } // on a fini }

Programmer l'addition binaire Programmer l'addition binaire





//a[0..n[:a-t-on somme(a[i]*x[i],i=0..n-1)=S?void sacADos(int [] a, int S){ int n=sizeof(a); int* x = (int *) malloc(n*sizeof(int)); for(int i = 0; i < (1 << n); i++){ // reconstruction de S1 = somme(a[j]*x[j]) int S1=0; for(int j = 0; j < n; j++){ if(x[j] == 1) S1 = S1+a[j]; if( S1 == S) // une solution trouvée for(int j = 0; j < n; j++) if(x[j] == 1) printf("+ %d ",a[j]); } // simulation de l'addition x[] = x[]+1

calcule 2n




Nombre d’additionsNombre d’additions

En moyenne n/2 additions pour chaque i En moyenne n/2 additions pour chaque i


O(n 2n)O(n 2n)

for(int j = 0; j < n; j++){ if(x[j] == 1) S1 = S1 + a[j];




BacktrackingBacktracking

PrincipePrincipe

Essayer toutes lescombinaisons pour trouver une

ou plusieurs solutions

Essayer toutes lescombinaisons pour trouver une

ou plusieurs solutions

Méthode consistant à fairedes essais et à rebrousser

chemin en cas d'échec

Méthode consistant à fairedes essais et à rebrousser

chemin en cas d'échec





PrincipePrincipe

En général, des algorithmes représentés de manière

arborescente. Chaque branche symbolisant un appel récursif

En général, des algorithmes représentés de manière

arborescente. Chaque branche symbolisant un appel récursif

Croissance exponentielleCroissance exponentielle






Supposons avoir déjà calculé Supposons avoir déjà calculé

Si = x0a0 + x1a1 + … + xi-1ai-1Si = x0a0 + x1a1 + … + xi-1ai-1

Si Si=S Alors on a trouvé une solutionSinon Si Si<S Alors Si Si=S Alors on a trouvé une solutionSinon Si Si<S Alors

On essaie de rajouter xi=0 et on teste au cran suivant On essaie de rajouter xi=0 et on teste au cran suivant






Supposons avoir déjà calculé Supposons avoir déjà calculé

Si = x0a0 + x1a1 + … + xi-1ai-1Si = x0a0 + x1a1 + … + xi-1ai-1

Si Si=S Alors on a trouvé une solutionSinon Si Si<S Alors Si Si=S Alors on a trouvé une solutionSinon Si Si<S Alors

On essaie avec xi=1 On essaie avec xi=1





Backtracking: exempleBacktracking: exemple

int[]a= {1,4,7,12,18,20,30}; S =13 X={1} Si=1x1 < 13 {1,0} {1,0,0} {1,0,0,0}

{1,0,0,1} OK{1,0,1} {1,0,1,0}

{1,0,1,1} {1,1} {1,1,0}…

{1,1,1}

int[]a= {1,4,7,12,18,20,30}; S =13 X={1} Si=1x1 < 13 {1,0} {1,0,0} {1,0,0,0}

{1,0,0,1} OK{1,0,1} {1,0,1,0}

{1,0,1,1} {1,1} {1,1,0}…

{1,1,1}





// Si=sum(a[j]*x[j],j=0..i-1) déjà calculée void sacADosrec(int a[],int S, int x[],int Si, int i, int n){ nbrec++; if(Si == S) afficherSolution(a, S, x, i); else if((i < n) && (Si < S)){ x[i] = 0; sacADosrec(a, S, x, Si, i+1,n); x[i] = 1; sacADosrec(a, S, x, Si+a[i], i+1,n);}} nbrec: nombre d’appels à la fonction nbrec: nombre d’appels à la fonction





void sacADos(int a[], int S,int n){ int *x = (int *) malloc( n*sizeof(int)); nbrec = 0; sacADosrec(a, S, x, 0, 0,n); printf("Nbre d’appels= %d\n" , nbrec);}

Appel Appel

Le programme principalLe programme principalvoid main(){int a[] = {10, 20, 25, 50, 55, 60, 62};sacADos(a, 85,7);

}L'exécution donne : 85 =+25+6085 =+10+25+5085 =+10+20+55 # appels=131 Sur 256=2n+1




PermutationsPermutations





(1,3,2)(1,3,2)

{1,2,3}, {1,3,2},…{1,2,3}, {1,3,2},…

Il y a n! permutationsde n éléments

Il y a n! permutationsde n éléments





Enumération des permutationsEnumération des permutations

On procède récursivement, en générant les permutations d'ordre n-1 et en rajoutant n à toutes les positions possibles

On procède récursivement, en générant les permutations d'ordre n-1 et en rajoutant n à toutes les positions possibles






Mettre dans t[i0] les n-i0+1 valeurs non utilisées auparavant, à tour de rôle

Mettre dans t[i0] les n-i0+1 valeurs non utilisées auparavant, à tour de rôle

Permutation t[1..i0-1] construite Permutation t[1..i0-1] construite






On va gérer un tableau auxiliaire de booléens choisi, tel que choisi[j] est vrai si le nombre j a déjà été choisi

On va gérer un tableau auxiliaire de booléens choisi, tel que choisi[j] est vrai si le nombre j a déjà été choisi





// approche en O(n!) void permRec(int[]t,int n,bool[]choisi,int i0){ if(i0 > n) afficher(t, n); else{ for(int v = 1; v <= n; v++){ if(! choisi[v]){ choisi[v] = true; t[i0] = v; permRec(t, n, choisi, i0+1); } } } }

Le programmeLe programme

el faker

choisi[v] = true; t[i0] = v; permRec(t, n, choisi, i0+1); choisi[v] = false;





// approche en O(n!) void permutations(int n){ int* t = (int *) malloc( (n+1)*sizeof(int)); bool*choisi=(bool*)malloc((n+1)*sizeof(bool)); permRec(t, n, choisi, 1); }






// approche en O(n!) void permutations(int n){ } Pour n=3, on génère les permutations dans l'ordre :1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1





Problèmedes n reines

Problèmedes n reines




n toursn tours

Une tour menacetoute pièce adverse

Une tour menacetoute pièce adverse

Se trouvant dans la même ligne Se trouvant dans la même ligne Ou la même colonne Ou la même colonne

Problème des n reinesProblème des n reines




On peut mettren tours sur

l'échiquier sans que les tours ne

s'attaquent

On peut mettren tours sur

l'échiquier sans que les tours ne

s'attaquent

n toursn tours





Une solution: Une solution:

Permutation de 1..n Permutation de 1..n

n toursn tours





T(n) = n!T(n) = n!

Le nombre de façonsde placer n tours non attaquantes est donc

Le nombre de façonsde placer n tours non attaquantes est donc

n toursn tours





n reinesn reines

La reine se déplace danstoutes les directions

La reine se déplace danstoutes les directions

C’est une tour avec unpeu plus de pouvoir

C’est une tour avec unpeu plus de pouvoir





Le nombre maximal de reines pouvant être sur l'échiquier sans s'attaquer est plus petit que n

Le nombre maximal de reines pouvant être sur l'échiquier sans s'attaquer est plus petit que n Egal à n pour n=1 ou n ≥ 4 Egal à n pour n=1 ou n ≥ 4 Le nombre de solutions possibles

est une tâche non résolue Le nombre de solutions possibles

est une tâche non résolue


n reinesn reines




2 solutions avec 4 reines2 solutions avec 4 reines

n = 4n = 4


n reinesn reines




Codage d'uneconfiguration

admissible

Codage d'uneconfiguration

admissible

Suite des positionsd'une reine dans chaque colonne

Suite des positionsd'une reine dans chaque colonne

22 44 11 33

Résolution du problèmeRésolution du problème





(i1, j1) et (i2, j2)sont en conflit ssi

i1=i2 j1=j2 i1+j1=i2+j2i1-j1=i2-j2

(i1, j1) et (i2, j2)sont en conflit ssi

i1=i2 j1=j2 i1+j1=i2+j2i1-j1=i2-j2


PropositionProposition





Avec 8 reinesAvec 8 reines

à distribuersur un échiquier

sans conflits

à distribuersur un échiquier

sans conflits





Les huit reinesLes huit reines


On suppose avoir construit une solution approchée dans t[1..i0[ et on cherche à placer une reine dans la colonne i0

On suppose avoir construit une solution approchée dans t[1..i0[ et on cherche à placer une reine dans la colonne i0






Il faut s'assurer que la nouvelle reine n'attaque personne sur sa ligne (c'est le rôle du tableau enLigne[] comme pour les permutations), ...

Il faut s'assurer que la nouvelle reine n'attaque personne sur sa ligne (c'est le rôle du tableau enLigne[] comme pour les permutations), ...






... et personne dans aucune de ses diagonales (fonction enDiagonale())

... et personne dans aucune de ses diagonales (fonction enDiagonale())




// t[1..i0[ est déjà rempli void reines(int[]t,int n,bool[]enLigne,int i0){ if(i0 > n) afficher(t); else{ for(int v = 1; v <= n; v++) if(!enLigne[v] && !enDiagonale(t, i0, v)){ enLigne[v] = true; t[i0] = v; reines(t, n, enLigne, i0+1); enLigne [v] = false; } } }


CodeCode




// t[1..i0[ est déjà rempli boolean enDiagonale(int[] t, int i0, int j){ int x1, y1, x2 = i0, y2 = j; for(int i = 1; i < i0; i++){ // on récupère les positions x1 = i; y1 = t[i]; if((x1 == x2) || (y1 == y2) || ((x1-y1)==(x2-y2)) || ((x1+y1)==(x2+y2))) return true; } return false; }


CodeCode





88

77

665544

nn RnRn

22

1010

44

4040

9292 2323

2222

212120201919nn RnRn

49680578484968057848

3902918888439029188884

314666222712314666222712

26910087016442691008701644

2423393768444024233937684440




ExerciceExercice

Problème des phrases cohérentesProblème des phrases cohérentes

Dans cette phrase il y a 2 fois le nombre 1, 3 fois le nombre 2, 2 fois le nombre 3, et 1 fois le nombre 4


Pas de solution avec les nombres allant jusqu'à 1,2 ou 3 Pas de solution avec les nombres allant jusqu'à 1,2 ou 3




ExerciceExercice




Deux solutions avec les nombres allant jusqu'à 4 (Pas évident) Deux solutions avec les nombres allant jusqu'à 4 (Pas évident)




ExerciceExercice




Pas de solution avec les nombres allant jusqu'à 6 Pas de solution avec les nombres allant jusqu'à 6




STRUCTURES DE

DONNÉES

STRUCTURES DE

DONNÉES

lec 08_backt

Documents