Proyecto # 1

NReinas
Introduccin.Este ingenioso juego consiste en colocar un nmero n de reinas en un tablero de n x n
( cuadrado ) de manera que ninguna reina este atacando a otra.
La habilidad y estrategia de cada jugador depender para llegar a una rpida solucin .

El problema ocurre cuando el tablero es demasiado grande, en si uno no sabra por donde
comenzar , pues al comienzo hay n x n posibles lugares por donde comenzar.
La computadora puede resolver estos problemas , la velocidad depende de las estrategias
que se le ensee al computador para resolver estos tipos de problemas.
Una tcnica es el backtrack que es una solucin muy lenta y que consume demasiados
recursos pero acompaado de la heurstica nos facilitara en la solucin del problema.
La heursticas nos ayuda a resolver estos problemas. La heurstica es la informacin
inmersa en el problema ,esta informacin se descubre siendo expertos en la resolucin del
problema.
Solucin .La lista de reglas aplicables son cada posicin del tablero (fila y columna)
La forma mas eficiente de resolver es colocando una reina en cada fila en el caso que no se
pudiera colocar una reina en una fila entonces volvera atrs para escoger un nuevo camino.
Existen diferentes casos que se pudieron descubrir para la resolucin del problema, cada
uno presenta caractersticas casi similares tratar de seguir el circuito del caballo, dependera
mucho entonces escoger bien la casilla inicial.
El primer caso ocurrira cuando la dimensin del tablero fuera par, entonces se
comenzara en la casilla nmero dos , luego se empezara a avanzar en forma del caballo
hasta que se llegue a un extremo del tablero, para luego comenzar en la posicin que no
este atacada en el siguiente nivel :

De esta manera se asegura que no se cometan errores en el momento de insertar un reina.

El segundo caso sera cuando la dimensin del tablero es impar , entonces se comenzar
desde la primera casilla , para luego como en el caso anterior continuar avanzando como el
caballo hasta el toparse con un lado del tablero

De esta manera se garantiza que no se cometan errores . Debido a que al llenar la mitad del
tablero con la trayectoria del caballo, todo queda acomodado para que continu el algoritmo
sin la necesidad de hacer backtrack ( vuelta atras) para corregir errores.
Todo andara bien con estos 2 casos bsicos pero tambin se presentan problemas mas
adelante con diferentes tipos de dimensiones que se le den al tablero.
El tercer caso se presenta cuando la dimensin del tablero es par y adems cumple con
esta condicin (n-14)%12==0 Ej. ( n = 14, 26, 38, 50)
Como en el caso primero, por ser par comienza desde la segunda casilla, y sigue la
trayectoria del caballo hasta que llegue al extremo derecho del tablero.
Luego se seguir el curso del backtrack realizando la trayectoria del caballo hasta la
penltima fila y la ultima se completara con el curso de backtrack, o sea con la que venga.

El cuarto caso se presenta cuando la dimensin del tablero es impar y adems cumple con
esta condicin ( (n-9)%4 == 0) Ej. ( n = 9, 15, 17, 21, 25 ...)
Una solucin momentnea se le pudo aplicar a este caso , que es que la casilla inicial sea
(e.getN()/2)+1 y luego se movera de fila en fila con el movimiento del caballo como en el
caso segundo hasta que llegue al lado derecho del tablero, luego seguiria el curso normal
del backtrack.

Esto para evitar que se den demasiadas vueltas, pero no nos garantiza un numera de vueltas
= 0, solamente reduce enormemente este valor.
Resultados :
4=0
5=0
6=0
7=0
8=0
9=0
10 = 0
11 = 0
12 = 0
13 = 0
14 = 0
15 = 64
16 = 0
17 = 0
18 = 0
19 = 0
20 = 0
21 = 73
22 = 0

23 = 0
24 = 0
25 = 0
26= 0
27 = 553
28 = 0
29 = 0
30 = 0
31 = 0
32 = 0
33 = 3631
34 = 0
35 = 0
36 = 0
37 = 0
38 = 0
39 = 18106
40 = 0
41 = 0

42 = 0
43 = 0
44 = 0
45 = X
46 = 0
47 = 0
48 = 0
49 = 0
50 = 0
51 = X
52 = 0
53 = 0
54 = 0
55= 0
56 = 0
57 = X
58 = 0
59 = 0
60 = 0

61 = 0
62 = 0
63 = X
64 = 0
65 = 0
66 = 0
67 = 0
68 = 0
69 = X
70 = 0
71 = 0
72 = 0
73 = 0

74 = 0
75 = X
76 = 0
77 = 0
78 = 0
79 = 0
80 = 0
81 = X
82 = 0
83 = 0
84 = 0
85 = 0
86 = 0
87 = X

88 = 0
89 = 0
90 = 0
91 = 0
92 = 0
93 = X
94 = 0
95 = 0
96 = 0
97 = 0
98 = 0
99 = X
100=0

Conclusin .No se pudo solucionar completamente el cuarto caso debido a su complejidad que se
presenta en las dimensiones mencionadas anteriormente.
El desarrollo al problema de las NReinas fue de ayuda para la comprensin de cmo
utilizar la heurstica en la solucin de este tipo de problemas que requieren Inteligencia.
Bibliografa .Deitel y Deitel , Como programar en Java.

Integrante :

Daniel Alberto Caballero Calle

Horas trabajadas individuales :

Das trabajados :
Fecha : 02/06/05
Nota : 4

6 das.

25 hrs.

200213288