Descripción explicativa del esquema algorítmico de vuelta atrás o backtracking

8. Búsqueda con retroceso: Introducción algoritmo BackTracking( ent k:entero; entsal X: vector [1..n] de valor) {Pre: X[1..k-1] es completable} variable v:valor para todo v en C i hacer X[k]:=v; si completable(X,k) entonces si Sol(X,k) entonces guardar(X,k) fsi ; si k<n entonces BackTracking(k+1,X) fsi ; fsi fpara La llamada inicial es: ... BackTracking(1,X); ...

17. El problema de la suma de subconjuntos algoritmo sumasub( ent s,k,r:entero; entsal X: vector[1..n]de nat) {k: siguiente variable a decidir Los w[j] están en orden creciente s= w[j]*x[j]; r= w[j] s+w[k]  M; s+ w[i]  M } X[k]:=1; si s+w[k]=M entonces escribir(X[1..k]) sino si s+w[k]+w[k+1]  M entonces sumasub(s+w[k],k+1,r-w[k],X) fsi fsi si (s+r-w[k]  M) y (s+w[k+1]  M) entonces X[k]:=0; sumasub(s,k+1,r-w[k],X) fsi fin

23. Coloreado de grafos algoritmo m_col( ent k:entero; entsal X:vector[1..n]de nat) {Se usa una variable global g de tipo grafo.} para v:=1..m hacer X[k]:=v si completable(X,k) entonces si k=n entonces escribir(X) sino m_col(k+1,X) fsi fsi fpara fin funcion Completable( entsal x:sol; ent k:entero) variables b:booleano; j:entero b:=verdad; j:=1; mientras (j<k)  b hacer si g[k,j] y (x[k]=x[j]) entonces b:=falso sino j:=j+1 fsi fmientras retorna (b)

31. Atravesar un laberinto funcion HayCamino( ent x,y:entero; entsal lab:laberinto) {devuelve cierto ssi existe camino} si (x<1)  (x>n)  (y<1)  (y>n)  lab[x,y]  libre entonces devuelve falso sino lab[x,y]:=camino; si (x=n)  (y=n) entonces escribir(lab); devuelve cierto; sino b:= HayCamino(x+1,y,lab)  HayCamino(x,y+1,lab)  HayCamino(x-1,y,lab)  HayCamino(x,y-1,lab); si  b entonces lab[x,y]:= imposible; fsi devuelve b; fsi fsi fin

36. El problema de la mochila 0-1 función cota(benef,peso:vectReal; cap,ben:real; k:entero) devuelve real {cap=capacidad aún libre de la mochila; ben=beneficio actual; k=índice del primer objeto a considerar} principio si k>n or cap=0.0 entonces devuelve ben sino si peso[k]>cap entonces dev ben+cap/peso[k]*benef[k] sino dev cota(benef,peso,cap-peso[k], ben+benef[k],k+1) fsi fsi fin tipo vectReal= vector [1..n] de real {Pre:  i  1..n:peso[i]>0, benef[i]>0,  i  1..n-1:benef[i]/peso[i]  benef[i+1]/peso[i+1]}

37. El problema de la mochila 0-1 tipo solución= vector [1..n] de 0..1 {variables globales: benef,peso:vectReal; cap:real} algoritmo búsqueda( ent solAct:solución; ent benAct,pesAct:real; ent k:entero; e/s sol:solución; e/s ben:real) para v:=1 hasta 0 hacer solAct[k]:=v; benAct:=benAct+v*benef[k]; pesAct:=pesAct+v*peso[k]; si pesAct  cap  ben<cota(benef,peso, cap-pesAct,benAct,k+1) entonces si k=n entonces si benAct>ben entonces sol:=solAct; ben:=benAct fsi sino búsqueda(solAct,benAct,pesAct, k+1,sol,ben) fsi fsi fpara fin

42. Backtracking genérico para problemas de optimización algoritmo BackTracking( ent k:entero; entsal X: vector [1..n] de valor) {Pre: X[1..k-1] es completable, c’(X,k-1)<MS} para todo v en C i hacer X[k]:=v; si (completable(X,k)  c’(X,k)<MS) entonces si Sol(X,k) entonces MejorSol:= X; MS:= Coste(X) fsi ; si k<n entonces BackTracking(k+1,X) fsi ; fsi fpara

45. N- reinas algoritmo n-reinas( ent k:entero; ent L:dominios; entsal X:vector[1..n]de nat) {k: numero de variables asignadas, X: asignación actual L: valores compatibles con la asignación actual} L2:=L i:=Seleccionar_Variable(X,L); {selección arbitraria} para v  L[i] hacer {orden arbitrario} X[i]:=v; si anticipación(X,i,v,L2) entonces si k=n entonces escribir(X) sino n-reinas(k+1,L2,X) fsi fsi L2:=L; fpara X[i]:=0; fin