algoritmos

1

11

Diseño de AlgoritmosDiseño de Algoritmos

TTéécnicas de Programacicnicas de ProgramacióónnGabriel HuecasGabriel Huecas

22

ÍndiceÍndice

Algoritmos ávidosAlgoritmos ávidos

Dividir y vencerDividir y vencer

Programación dinámicaProgramación dinámica

Retroceso (Retroceso (backtrackingbacktracking))

33

Algoritmos ÁvidosAlgoritmos Ávidos

Algoritmos ávidosAlgoritmos ávidosProblema del cambio mínimo:Problema del cambio mínimo:monedas de 25, 10, 5, 1.monedas de 25, 10, 5, 1.Devolver 63 con nº mínimo de monedas:Devolver 63 con nº mínimo de monedas:

63 63 -- 25 = 38 25 = 38 -- 25 = 13 25 = 13 -- 10 = 3 10 = 3 -- 1 = 2 1 = 2 -- 1 = 1 = 1 1 -- 1 = 01 = 0Varias fasesVarias fases

En cada fase se toma una decisión óptima, sin En cada fase se toma una decisión óptima, sin pensar en el futuropensar en el futuro

44

Algoritmos ÁvidosAlgoritmos Ávidos

La solución puede no ser óptima (la mejor) La solución puede no ser óptima (la mejor) pero es “óptimo local”.pero es “óptimo local”.

monedas de 11, 5 y 1.monedas de 11, 5 y 1.cambio de 15 =>cambio de 15 =>15 15 -- 11 = 4 11 = 4 -- 1 = 3 1 = 3 -- 1 = 2 1 = 2 -- 1 = 1 1 = 1 -- 1 = 01 = 0Solución: 1 de 11 y 4 de 1.Solución: 1 de 11 y 4 de 1.Óptimo: 3 de 5.Óptimo: 3 de 5.

2

55

Problema del Agente ViajeroProblema del Agente Viajero“Recorrer una serie de ciudades con coste mínimo”“Recorrer una serie de ciudades con coste mínimo”

Recorrido: ciclo simple que incluya todos los Recorrido: ciclo simple que incluya todos los vértices una sola vezvértices una sola vez

CICLO DE HAMILTONCICLO DE HAMILTONGrafo: Grafo:

Vértices = ciudadesVértices = ciudadesArístasArístas = viaje entre ciudades= viaje entre ciudadesPeso = coste de viajar de una ciudad a otra (peso de Peso = coste de viajar de una ciudad a otra (peso de una arista)una arista)

Grafo no dirigido:Grafo no dirigido:Coste (A Coste (A →→ B) = Coste (B B) = Coste (B →→ A)A)

66

EjemploEjemplo

(0,0)A

(4,3)B

(1,7)C (15,7)D

(15,4)E

(18,0)F

77

Posible solucionesPosible soluciones

88

Variante del Algoritmo de Variante del Algoritmo de KruskalKruskal::Def.Def.-- Grado de un vértice: nº de aristas conectadas Grado de un vértice: nº de aristas conectadas a dicho vérticea dicho vérticeSe van seleccionando las aristas más cortas, Se van seleccionando las aristas más cortas, siempre quesiempre que

no haga que un vértice tenga grado 3no haga que un vértice tenga grado 3no forme ciclo, excepto que el nº de aristas seleccionadas no forme ciclo, excepto que el nº de aristas seleccionadas sea igual al nº de vértices sea igual al nº de vértices ⇒⇒ EXCEPTO QUE SEA LA EXCEPTO QUE SEA LA ÚLTIMAÚLTIMA

3

99

Matriz de conectividadMatriz de conectividad

LongitudesLongitudes

--FF55--EE

7,627,6233--DD18,4018,4014,314,31414--CC14,3014,30111111,711,755--BB

181815,515,516,616,67,087,0855--AAFFEEDDCCBBAA

1010

Posible solucionesPosible soluciones

5050

4949’’7878

4949’’7070

4848’’3838

1111

Dividir y VencerDividir y Vencer

Dividir: en problemas más pequeños, resueltos Dividir: en problemas más pequeños, resueltos recursivamenterecursivamente

Excepto los caso baseExcepto los caso base

Vencer: la solución al problema original se Vencer: la solución al problema original se forma en base a las soluciones de los forma en base a las soluciones de los subproblemassubproblemas

1212

MergeSortMergeSort

Ordenación por IntercalaciónOrdenación por Intercalación

intercalarintercalar

==

++

ordenarordenar

1113132424 2626

ordenarordenar

221515 27273838

1113132424 2626 221515 27273838

ordenarordenar

4

1313

MergeSortMergeSort: intercalación (I): intercalación (I)

1113132424 2626 221515 27273838

1113132424 2626 221515 27273838

2424131311 2626 151522 38382727posIposI posDposD posTmpposTmp

2424131311 2626 151522 38382727 11posIposI posDposD posTmpposTmp


1414

MergeSortMergeSort: intercalación (II): intercalación (II)


2424131311 2626 151522 38382727 13132211 1515posIposI posDposD posTmpposTmp

2424131311 2626 151522 38382727 13132211 1515 2424posIposI posDposD posTmpposTmp

2424131311 2626 151522 38382727 13132211 1515 26262424posIposI posDposD posTmpposTmp

1515

MergeSortMergeSort: intercalación (III): intercalación (III)

Se copia el resto del segundo Se copia el resto del segundo arrayarray en destinoen destino

2424131311 2626 151522 38382727 13132211 1515 26262424 38382727posIposI posDposD posTmpposTmp

1616

ImplementaciónImplementación (I)(I)class class mergeSortmergeSort {{

public static void main (String public static void main (String argsargs[]) {[]) {

Random r= new Random();Random r= new Random();

intint pruebaprueba[]= new int[20];[]= new int[20];

for (for (intint i= 0; i < i= 0; i < prueba.lengthprueba.length; i++); i++)

prueba[iprueba[i]= ]= r.nextIntr.nextInt() % 100;() % 100;

System.out.println("ElSystem.out.println("El array array inicialinicial eses:");:");


System.out.println(prueba[iSystem.out.println(prueba[i] + " ");] + " ");

mergeSort(pruebamergeSort(prueba););

System.out.println("ElSystem.out.println("El array array despuésdespués de de ordenarordenar eses:");:");


System.out.println(prueba[iSystem.out.println(prueba[i] + " ");] + " ");

}}

}}

5

1717

ImplementaciónImplementación (II)(II)public static void public static void mergeSortmergeSort ((intint A[]) {A[]) {mergeSortmergeSort (A, 0, A.length(A, 0, A.length--1);1);

}}

private static void private static void mergeSortmergeSort((intint A[], A[], intint izqizq, , intint derder) {) {

if (if (izqizq < < derder) {) {intint centrocentro= (= (izqizq + + derder) / 2;) / 2;mergeSort(AmergeSort(A, , izqizq, , centrocentro););mergeSort(AmergeSort(A, centro+1, , centro+1, derder););merge(Amerge(A, , izqizq, centro+1, , centro+1, derder););

}}}}

1818

ImplementaciónImplementación (III)(III)private static void mergeprivate static void merge

((intint A[], A[], intint posIposI, , intint posDposD, , intint derder) {) {intint AtmpAtmp[]= new []= new int[derint[der -- posI+1];posI+1];intint beginIbeginI= = posIposI;;intint izqizq= = posDposD -- 1;1;intint posTmpposTmp= 0;= 0;

while ( (while ( (posIposI <= <= izqizq) && () && (posDposD <= <= derder) ) {) ) {if (if (A[posIA[posI] < ] < A[posDA[posD]) {]) {

Atmp[posTmpAtmp[posTmp] = A [] = A [posIposI];];posIposI++;++;

} else {} else {Atmp[posTmpAtmp[posTmp] = A [] = A [posDposD];];posDposD++;++;

}}posTmpposTmp++;++;

}}

1919

ImplementaciónImplementación (IV)(IV)// // copiamoscopiamos el el restoresto del array del array queque quedequedefor (for (intint i= 0; i <= i= 0; i <= izqizq--posIposI; i++); i++)

Atmp[posTmp+iAtmp[posTmp+i]= ]= A[posI+iA[posI+i];];for (for (intint i= 0; i <= i= 0; i <= derder--posDposD; i++); i++)

Atmp[posTmp+iAtmp[posTmp+i]= ]= A[posD+iA[posD+i];];

// // pasamospasamos al array originalal array originalfor (for (intint i= 0; i < i= 0; i < Atmp.lengthAtmp.length; i++); i++)

A[beginIA[beginI + i]= + i]= Atmp[iAtmp[i];];}}

2020

Torres de HanoiTorres de Hanoi

Problema: pasar n disco de A a CProblema: pasar n disco de A a CSolución:Solución:

Pasar nPasar n--1 discos de A a B1 discos de A a BPasar 1 disco de A a CPasar 1 disco de A a CPasar nPasar n--1 discos de B a C1 discos de B a C

B CA

6

2121

Multiplicar 2 enteros X e Y de n bits (o dígitos)Multiplicar 2 enteros X e Y de n bits (o dígitos)Algoritmo enseñado en básica requiere n productos Algoritmo enseñado en básica requiere n productos parciales de tamaño n parciales de tamaño n --> > O(nO(n22))Simplificación: n potencia de 2Simplificación: n potencia de 2Separamos X e Y en n/2 bits:Separamos X e Y en n/2 bits:X = X = A·2A·2nn/2/2 + B Y = + B Y = C·2C·2nn/2/2 + D+ DX·Y=X·Y= A·C·2A·C·2nn + (+ (AA··D+BD+B··CC))·2·2nn/2/2+ + BB··DD

4 multiplicaciones de n/2 bits4 multiplicaciones de n/2 bits3 sumas3 sumas2 desplazamientos de 22 desplazamientos de 2nn y 2y 2n/2n/2

2222

EjemploEjemploX = 61438521 Y = 94736407 X = 61438521 Y = 94736407 X·Y=X·Y= 58204647309340475820464730934047A = 6143 B = 8521 C = 9473 D = 6407A = 6143 B = 8521 C = 9473 D = 6407X = A·10X = A·1044 + B Y = C·10+ B Y = C·1044 + D+ DX·Y= A·C·10X·Y= A·C·1088 + (A·D + B·C)·10+ (A·D + B·C)·1044 + B·D+ B·DX = 6143 Y = 9473X = 6143 Y = 9473A = 61 B = 43 C = 94 D = 73A = 61 B = 43 C = 94 D = 73A·C = 5734 A·D = 4453 A·C = 5734 A·D = 4453 B·CB·C = 4042 B·D = 3139= 4042 B·D = 3139A·D+B·CA·D+B·C = 8495= 8495

A·B·10A·B·1044 57 350 00057 350 000(A·D+B·C)·10(A·D+B·C)·1022 849 500849 500B·DB·D 3 1393 139

------------------

58 192 63958 192 639

2323

ImplementaciónImplementaciónintint multmult ((intint X, X, intint Y, Y, intint n) { // n: número de bitsn) { // n: número de bitsifif (n == 1) {(n == 1) {

returnreturn ((X == 1) & (Y == 1));((X == 1) & (Y == 1));} } elseelse {{

intint A = n/2 bits izq. X;A = n/2 bits izq. X;intint B = n/2 bits der. X;B = n/2 bits der. X;intint C = n/2 bits izq. Y;C = n/2 bits izq. Y;intint D = n/2 bits der. Y;D = n/2 bits der. Y;

intint m1 = m1 = multmult (A, C, n / 2);(A, C, n / 2);intint m2 = m2 = multmult (A, D, n / 2);(A, D, n / 2);intint m3 = m3 = multmult (B, C, n / 2);(B, C, n / 2);intint m4 = m4 = multmult (B, D, n / 2);(B, D, n / 2);

returnreturn m1 * 2m1 * 2^n^n + (m2+ (m2+m3+m3)*2^(n/2) + m4;)*2^(n/2) + m4;}}

2424

Programación DinámicaProgramación Dinámica

Algoritmos recursivos con cálculos repetitivosAlgoritmos recursivos con cálculos repetitivos

Almacenar valores intermedios en una tablaAlmacenar valores intermedios en una tablavariable globalvariable globalinicializacióninicializaciónregistro de valor la primera vezregistro de valor la primera vez

7

2525

FibonacciFibonacci recursivorecursivo

public long fib (int n) throws Exception {

if (n < 0) throw new Exception (“Pues si que...”);

if ( (n = 0) || (n = 1) )

return 1;

else

return fib (n-1) + fib (n-2);

}

⎩⎨⎧

>−+−=

=1)2()1(1,01

)(nnfnf

nnf

2626

Complejidad Complejidad FibonacciFibonacci

F6F5

F4F3

F2F1 F0

F1F2

F1 F0

F3F2

F1 F0F1

F4F3

F2F1 F0

F1F2

F1 F0

2727

FibonacciFibonacci iterativoiterativopublic long fib (int n) throws Exception {

long ult, penult, res;if (n < 0) throw new Exception (“Pues si que...”);

if ( (n = 0) || (n = 1) )return 1;

ult = penult = 1;for (int i = 2; i <= n; i++) {

res = ult + penult;penult = ult;ult = res;

}return res;

}

2828

Problema de la TriangulaciónProblema de la Triangulación

Dados los vértices de un polígono y las Dados los vértices de un polígono y las distancias entre vértices, hallar la triangulación distancias entre vértices, hallar la triangulación mínima.mínima.Triangulación:Triangulación:

Conjunto de cuerdas que no se cruzan entre si, Conjunto de cuerdas que no se cruzan entre si, entre vértices no adyacentes, de forma que el entre vértices no adyacentes, de forma que el polígono queda dividido en triángulospolígono queda dividido en triángulos

Mínimo:Mínimo:La suma de la longitud de dichas cuerdas debe ser La suma de la longitud de dichas cuerdas debe ser mínima.mínima.

8

2929

RepresentaciónRepresentación

Polígono de n vérticesPolígono de n vérticesvv00,...,,...,vvnn--11 en sentido horarioen sentido horario

(8,26)(8,26) vv22

(10,0)(10,0)vv66

(15,26)(15,26)vv33

(22,12)(22,12)vv55

(27,21)(27,21)vv44

(0,20(0,20)) vv11

(0,10)(0,10)vv00

aristaarista

cuerdacuerda

3030

Sabemos que…Sabemos que…

Hecho 1: el par vHecho 1: el par vii y vy vi+1i+1 es tocado, al menos, es tocado, al menos, por una cuerda.por una cuerda.Hecho 2: sea (vHecho 2: sea (vii, , vvjj) una cuerda de cualquier ) una cuerda de cualquier triangulación. Entonces existe triangulación. Entonces existe vvkk tal que (tal que (vvii,v,vkk), ), ((vvkk, , vvjj) son aristas o cuerdas.) son aristas o cuerdas.

Demostración: De otra forma, vDemostración: De otra forma, vii y vy vi+1i+1 podría podría limitar una región no triangular.limitar una región no triangular.

3131

SoluciónSolución

Para empezar la búsqueda, se cogen dos vértices Para empezar la búsqueda, se cogen dos vértices adyacentes (vadyacentes (v00, v, v11).).Debe existir Debe existir vvkk tal que (vtal que (v11, , vvkk) y () y (vvkk,v,v00) sean cuerdas o ) sean cuerdas o aristas en la triangulación.aristas en la triangulación.

Se prueban todos los Se prueban todos los vvkk (k # 0, #1)(k # 0, #1)Con n vértices, tendremos nCon n vértices, tendremos n--2 selecciones.2 selecciones.Se examina cada selección.Se examina cada selección.

3232

Solución recursivaSolución recursiva

Quedan dos Quedan dos subproblemassubproblemas, por ejemplo , por ejemplo eligiendo v3eligiendo v3

vv22vv33

vv11

vv00

vv66

vv33

vv55

vv44

vv00

9

3333

SSisis subproblemasubproblema de tamaño s a partir del vértice vde tamaño s a partir del vértice vii

vvii , v, vi+1i+1,..., v,..., vi+si+s--11 => s vértices=> s vértices(v(vii ,v,vi+si+s--11) >= cuerda) >= cuerda

Opciones para solución de Opciones para solución de SSisis1. coger v1. coger vi+si+s--11, formar el triángulo (v, formar el triángulo (vii, v, vi+si+s--11), (v), (vii, v, vi+si+s--22) y ) y

(v(vi+si+s--22,v,vi+si+s--11) y resolver S) y resolver Si,si,s--112. coger v2. coger vi+1i+1, formar el triángulo (v, formar el triángulo (vii, v, vi+si+s--11), (v), (vi+1i+1, v, vi+si+s--11) y ) y

((vvii,v,vi+1i+1) y resolver S) y resolver Si+1,si+1,s--113. k entre 2 y s3. k entre 2 y s--3,coger v3,coger vi+ki+k, formar el triángulo (v, formar el triángulo (vii, v, vi+ki+k), ),

(v(vi+ki+k, v, vi+si+s--11) y (v) y (vii,v,vi+si+s--11) y resolver S) y resolver Si,k+1i,k+1 y Sy Si+k,si+k,s--kk

3434

Los problemas SLos problemas Si3i3 no hay que “resolverlos”no hay que “resolverlos”

Problemas repetidosProblemas repetidos33ss--44 llamadas recursivas (sin “resolver” Sllamadas recursivas (sin “resolver” Si3i3))

vv66

vv33

vv55

vv44

vv00

vv66

vv33

vv55

vv44

vv00

3535

Solución eficiente: calcular coste Solución eficiente: calcular coste CCisis de la de la triangulación triangulación SSisis

CCisis = C (= C (SSisis))CCisis = = minmin [C[Ci,k+1i,k+1 + Ci+k,s+ Ci+k,s--k + k +

D(vD(vii,v,vi+ki+k) + D(v) + D(vi+ki+k,v,vi+si+s--11)] 1 )] 1 ≤≤ k k ≤≤ ss--22

•• para s para s ≥≥ 4 en orden (S=4,5,...,n4 en orden (S=4,5,...,n--1)1)•• SSisis = 0= 0 para s < 4para s < 4

( ) ( )Dlong

v , vv , v si v , v no son adyacentes

si v , v son adyacentesp qp q p q

p q=⎧⎨⎩0

3636

EjemploEjemplo

EjemploEjemploCC6565 = = minmin [C[C6,2 6,2 + C+ C0,4 0,4 +D(v+D(v66,v,v00) + D(v) + D(v00,v,v33),),

1 1 ≤≤ k k ≤≤ ss--22 CC6,3 6,3 + C+ C1,3 1,3 +D(v+D(v66,v,v11) + D(v) + D(v11,v,v33),),CC6,4 6,4 + C+ C2,2 2,2 +D(v+D(v66,v,v22) + ) + D(vD(v22,v,v33)])]

665544332211i=0i=0ss

CC6464=17.89=17.89CC5454=22.69=22.69CC4444=22.69=22.69CC3434=15.65=15.65CC2424=15.65=15.65CC1414=16.16=16.16CC0404=16.16=16.1644

CC6565=38.09=38.09CC5555=39.98=39.98CC4545=45.50=45.50CC3535=37.74=37.74CC2525=35.49=35.49CC1515=31.81=31.81CC0505=37.54=37.5455

CC6666=63.62=63.62CC5656=59.78=59.78CC4646=59.78=59.78CC3636=64.69=64.69CC2626=57.58=57.58CC1616=55.22=55.22CC0606=53.54=53.5466

CC0707=75.43=75.4377

10

3737

D(vD(v66,v,v00) = 0 (arista)) = 0 (arista)D(vD(v00,v,v33) = 21.93) = 21.93D(vD(v66,v,v11) = 22.36) = 22.36D(vD(v11,v,v33) = 16.16) = 16.16D(vD(v66,v,v22) = 26.08) = 26.08D(vD(v22,v,v33) = 0 (arista)) = 0 (arista)CC6565 = = minmin [0 + 16.16[0 + 16.16 + 0 + 21.93,+ 0 + 21.93,

00 + 0+ 0 + 22.36 + 16.16,+ 22.36 + 16.16,17.8917.89 + 0 + 26.08 + 0] =+ 0 + 26.08 + 0] =

minmin [38.19, 38.52, 43.97] = 38.19[38.19, 38.52, 43.97] = 38.19Al incluir este valor en la tabla, es conveniente indicar las Al incluir este valor en la tabla, es conveniente indicar las cuerdas que produjeron esta triangulación mínima.cuerdas que produjeron esta triangulación mínima. 3838

Retroceso (Retroceso (BacktrackingBacktracking))Problemas sin una solución analítica o algorítmica:Problemas sin una solución analítica o algorítmica:

Hay que hacer una búsqueda exhaustiva del espacio de Hay que hacer una búsqueda exhaustiva del espacio de posibilidadesposibilidades

Y elegimos la buenaY elegimos la buena

Complejidad computacional alta: producto cartesiano Complejidad computacional alta: producto cartesiano de posibilidades para construir cada candidato a de posibilidades para construir cada candidato a solución solución

PERO se puede aprovechar parte de la solución anterior para PERO se puede aprovechar parte de la solución anterior para construir la nuevaconstruir la nueva

Decisiones parcialesDecisiones parciales

3939

AplicacionesAplicaciones

Problemas NPProblemas NP--completoscompletosSin solución analíticaSin solución analítica

Pintar un mapa con cuatro colores sin que dos Pintar un mapa con cuatro colores sin que dos países fronterizos tengan el mismo colorpaíses fronterizos tengan el mismo colorObtención de mejor jugadaObtención de mejor jugada

Tres en raya, damas, ajedrez (Tres en raya, damas, ajedrez (+poda+poda alfaalfa--beta)beta)

Etc.Etc.

4040

Ejemplo: 8 reinas en tableroEjemplo: 8 reinas en tablero

Poner 8 reinas en un tablero de ajedrez (8x8) Poner 8 reinas en un tablero de ajedrez (8x8) sin que se den jaque.sin que se den jaque.Debemos probar todas las posibilidadesDebemos probar todas las posibilidades

Cada reina puede estar en cualquiera de las Cada reina puede estar en cualquiera de las casillas: 64casillas: 6488 posibles combinacionesposibles combinaciones

Algo menos, las reinas no puedes estar en la misma Algo menos, las reinas no puedes estar en la misma casillacasilla

11

4141

Modelado de CasillaModelado de Casillapublicpublic enumenum Casilla {Casilla {

VACIA, Reina, Rey, Torre, Alfil, Caballo, VACIA, Reina, Rey, Torre, Alfil, Caballo, PeonPeon;;

publicpublic StringString toStringtoString() {() {

switch(thisswitch(this) {) {

case VACIA : case VACIA : returnreturn " ";" ";

case Reina : case Reina : returnreturn "r";"r";

case Rey : case Rey : returnreturn "R";"R";

case Torre : case Torre : returnreturn "t";"t";

case Caballo: case Caballo: returnreturn "c";"c";

case Alfil : case Alfil : returnreturn "a";"a";

case case PeonPeon : : returnreturn "p";"p";

}}

throwthrow newnew AssertionErrorAssertionError("Casilla desconocida " + ("Casilla desconocida " + thisthis););

}}

}} 4242

Modelado de Tablero (I)Modelado de Tablero (I)publicpublic classclass Tablero {Tablero {

intint widthwidth, , heightheight;;

Casilla tablero[][];Casilla tablero[][];

Tablero (Tablero (intint w, w, intint h) {h) {

width=width= w;w;

height=height= h;h;

tablero=tablero= newnew Casilla[wCasilla[w][h];][h];

forfor ((intint i=i= 0; i < 0; i < widthwidth; ; i++i++))

forfor ((intint j=j= 0; j < 0; j < heightheight; ; j++j++))

tablero[itablero[i][j]= ][j]= Casilla.VACIACasilla.VACIA;;

}}

4343

Modelado de Tablero (II)Modelado de Tablero (II)voidvoid imprime() {imprime() {

forfor ((intint i=i= 0; i < 0; i < widthwidth; ; i++i++) {) {

System.out.printlnSystem.out.println("("----------------------------------");");

System.out.printSystem.out.print("|");("|");

forfor ((intint j=j= 0; j < 0; j < heightheight; ; j++j++) {) {

System.out.print(tablero[iSystem.out.print(tablero[i][j] + "|");][j] + "|");

}}

System.out.printlnSystem.out.println();();

}}

System.out.printlnSystem.out.println("("----------------------------------");");

}}

publicpublic voidvoid pon(intpon(int i, i, intint j, Casilla pieza) {j, Casilla pieza) {

tablero[itablero[i][j]= pieza;][j]= pieza;

}}

publicpublic Casilla Casilla dame(intdame(int i, i, intint j) {j) {

returnreturn tablero[itablero[i][j];][j];

}}

4444

Cada reina en una columnaCada reina en una columnapublicpublic staticstatic booleanboolean ponReinasponReinas (Tablero t, (Tablero t, intint SizeSize, , intint n) {n) {

forfor ((intint j0= 0; j0 < j0= 0; j0 < SizeSize; j0++) {; j0++) {

t.pont.pon (0, j0, (0, j0, Figura.ReinaFigura.Reina););



......



ifif ( ! ( ! estanTodasEnJaqueestanTodasEnJaque (t, (t, SizeSize) )) )

returnreturn truetrue;;

t.pont.pon (7, j7, (7, j7, Figura.VACIAFigura.VACIA););

}}

......

}}


}}


}}

returnreturn falsefalse;;

}}

12

4545

No insistir en los erroresNo insistir en los errores

Poner N reinas es colocar una en una posición Poner N reinas es colocar una en una posición libre de jaque e intentar poner Nlibre de jaque e intentar poner N--1 reinas1 reinas

Cada vez que ponemos una reina, comprobamos Cada vez que ponemos una reina, comprobamos que no está en jaque con las demásque no está en jaque con las demásSi lo está, pasamos a la siguiente posiciónSi lo está, pasamos a la siguiente posiciónSi se agotan las posiciones, devolvemos Si se agotan las posiciones, devolvemos falsefalse (no (no pudimos colocar la reina)pudimos colocar la reina)

4646

estanEnJaqueestanEnJaquepublicpublic staticstatic booleanboolean estanEnJaqueestanEnJaque

(Tablero t, (Tablero t, intint SizeSize, , intint x, x, intint y) {y) {// compruebo fila// compruebo filaforfor ((intint i=i= 0; i < 0; i < SizeSize; ; i++i++) {) {

ifif (i == x) (i == x) continuecontinue; // la misma pieza; // la misma piezaifif ((t.dame(it.dame(i, y) != , y) != Casilla.VACIACasilla.VACIA))

returnreturn truetrue;;}}

// compruebo columna// compruebo columnaforfor ((intint j=j= 0; j < 0; j < SizeSize; ; j++j++) {) {

ifif (j == y) (j == y) continuecontinue; // la misma pieza; // la misma piezaifif ((t.dame(xt.dame(x, j) != , j) != Casilla.VACIACasilla.VACIA))

returnreturn truetrue;;}}

4747

estanEnJaqueestanEnJaque// comprueba diagonal// comprueba diagonalforfor ((intint i=i= x+1x+1, j = , j = y+1y+1; (i < ; (i < SizeSize) && (j < ) && (j < SizeSize); ); i++i++, , j++j++) {) {

ifif ( ( t.dame(it.dame(i, j) != , j) != Casilla.VACIACasilla.VACIA ))returnreturn truetrue;;

}}// comprueba diagonal// comprueba diagonalforfor ((intint i=i= x+1x+1, j = y, j = y--1; (i < 1; (i < SizeSize) && (j >= 0); ) && (j >= 0); i++i++, j, j----) {) {


}}// comprueba diagonal// comprueba diagonalforfor ((intint i=i= xx--1, j = 1, j = y+1y+1; (i >= 0) && (j < ; (i >= 0) && (j < SizeSize); i); i----, , j++j++) {) {


}}// comprueba diagonal// comprueba diagonalforfor ((intint i=i= xx--1, j = y1, j = y--1; (i >= 0) && (j >= 0); i1; (i >= 0) && (j >= 0); i----, j, j----) {) {


}}returnreturn falsefalse;;

4848

ponReinasponReinaspublic public booleanboolean ponReinasponReinas ((TableroTablero t, t, intint Size, Size, intint n) {n) {

if (n==0)if (n==0)return true;return true;

intint x, y; // x, y; // posiciónposición de de estaesta reinareinax= nx= n--1; // 1; // cadacada reinareina en en unauna filafilafor (y= 0; y < Size; y++) {for (y= 0; y < Size; y++) {

t.pon(xt.pon(x, y, , y, Casilla.ReinaCasilla.Reina););if (! if (! estanEnJaque(testanEnJaque(t, Size, x, y) ), Size, x, y) )

if ( if ( ponReinas(tponReinas(t, Size, n, Size, n--1) )1) )return true;return true;

t.pon(xt.pon(x, y, , y, Casilla.VACIACasilla.VACIA););}}return false;return false;

}}

13

4949

pruebapruebapublic static void main (String public static void main (String argsargs[]) {[]) {

intint Size= 8;Size= 8;

TableroTablero t = new t = new Tablero(SizeTablero(Size, Size);, Size);

t.imprimet.imprime();();

if (if (ponReinas(tponReinas(t, Size, Size)) {, Size, Size)) {

System.out.println("ConseguíSystem.out.println("Conseguí ponerponer " + Size + " " + Size + " reinasreinas en el en el tablerotablero");");

} else {} else {

System.out.println("NOSystem.out.println("NO ConseguíConseguí ponerponer " + Size + " " + Size + " reinasreinas en el en el tablerotablero");");

}}

t.imprimet.imprime();();

}} 5050

EjercicioEjercicio

Para el próximo díaPara el próximo díaSe recogerá en claseSe recogerá en clase

Dado un tablero de ajedrez, nos preguntamos Dado un tablero de ajedrez, nos preguntamos si un caballo, desde una posición determinada, si un caballo, desde una posición determinada, podría recorrer todo el tablero sin pisar dos podría recorrer todo el tablero sin pisar dos veces la misma casilla.veces la misma casilla.Escribir un programa que lo compruebeEscribir un programa que lo compruebe

PlusPlus: imprimir el recorrido si existe: imprimir el recorrido si existe

algoritmos

Documents