| Ver tema anterior :: Ver siguiente tema | | Autor | Mensaje |
|---|
towhi
Registrado: 27 Abr 2011
Mensajes: 3
Ubicación: Campeche, Mexico
|  Publicado: 27/04/2011 9:06 pm | | | Título: Juego de Gato o Tres en Raya (Algoritmo MiniMax) |
| Hola estimados camaradas del foro, tengo un promeblema con mi algoritmo MiniMax, mas especificamente a la hora de inicialisar los nodos hijos que van a representar todos los posibles movimientos que se puden hacer en el metodo "movComputadora":
| Código: | void ComputadoraIA::movComputadora(NodoG &arbol){
movimientos = movDisponibles(arbol.tablero);
int *indices = posVacias(arbol.tablero);
arbol.nodo->nodo = new NodoG[movimientos];
int ganador = terminado(arbol.tablero);
if(ganador==1)ganador=-1;
else if ( ganador == 2 ) ganador = 1;
if (ganador!=0||movimientos==0) {
arbol.ganador = ganador;
}else{
for (int i = 0; i < movimientos; i++) {
for (int j = 0; j < 9; j++){
arbol.nodo->nodo[i].tablero[j] = arbol.tablero[j];
}
if (arbol.miTurno) {
arbol.nodo->nodo[i].tablero[indices[i]] = 1;
}else{
arbol.nodo->nodo[i].tablero[indices[i]] = 2;
}
imprime(arbol.nodo->nodo[i].tablero);
arbol.nodo->nodo[i].miTurno = !arbol.miTurno;
arbol.nodo->nodo[i].indice = indices[i];
movComputadora(arbol.nodo->nodo[i]);
}
if (!arbol.miTurno)
arbol.ganador = Max(arbol);
else
arbol.ganador = Min(arbol);
}
} |
este metodo es recursivo, a la hora de ejecutar mi programa se me queda conjelado, lo estuve revisando paso a paso con el IDE c++ Builder 2010 y se me queda atorado en la linea | Código: | arbol.nodo->nodo = new NodoG[movimientos]; |
pienso que estoy construyendo mal el objeto o estoy asignando mal los recursos de memoria, acontinuacion les dejo el codigo de las dos clases que uso:
| Código: |
class ComputadoraIA{
public:
int tiradas;
int movimientos;
int indices[];
NodoG arbol;
int tablero[];
int miFicha;
ComputadoraIA();
int movDisponibles(int *tablero);
int* posVacias(int *tabla);
int movimiento(int *tablero);
void movComputadora(NodoG &arbol);
int Max(NodoG &raiz);
int Min(NodoG &raiz);
int terminado(int tablero[]);
bool puedoGanar(int tablero[]);
bool puedoPerder(int tablero[]);
void imprime(int *gato);
};
ComputadoraIA::ComputadoraIA(){
this->miFicha = 2;
}
int ComputadoraIA::movDisponibles(int *tablero){
int mov = 0;
for ( int i = 0; i < 9; i ++ ){
if ( tablero[i] == 0 ) mov++;
}
return mov;
}
int* ComputadoraIA::posVacias(int *tabla){
int mov = movDisponibles(tabla);
int *indicess = new int[mov];
int indice = 0;
for ( int i = 0; i < 9; i ++ ){
if ( tabla[i] == 0 ){
indicess[indice] = i;
indice++;
}
}
return indicess;
}
ComputadoraIA::movimiento(int *tablero){
this->tablero[9];
for (int i = 0; i < 9; i++) {
this->tablero[i] = tablero[i];
}
this->tiradas++;
for (int i = 0; i < 9; i++) {
this->arbol.tablero[i] = this->tablero[i];
}
movComputadora(this->arbol);
return this->arbol.mejorMovimiento;
}
void ComputadoraIA::movComputadora(NodoG &arbol){
movimientos = movDisponibles(arbol.tablero);
int *indices = posVacias(arbol.tablero);
arbol.nodo->nodo = new NodoG[movimientos];
int ganador = terminado(arbol.tablero);
if(ganador==1)ganador=-1;
else if ( ganador == 2 ) ganador = 1;
if (ganador!=0||movimientos==0) {
arbol.ganador = ganador;
}else{
for (int i = 0; i < movimientos; i++) {
for (int j = 0; j < 9; j++){
arbol.nodo->nodo[i].tablero[j] = arbol.tablero[j];
}
if (arbol.miTurno) {
arbol.nodo->nodo[i].tablero[indices[i]] = 1;
}else{
arbol.nodo->nodo[i].tablero[indices[i]] = 2;
}
imprime(arbol.nodo->nodo[i].tablero);
arbol.nodo->nodo[i].miTurno = !arbol.miTurno;
arbol.nodo->nodo[i].indice = indices[i];
movComputadora(arbol.nodo->nodo[i]);
}
if (!arbol.miTurno)
arbol.ganador = Max(arbol);
else
arbol.ganador = Min(arbol);
}
}
ComputadoraIA::Max(NodoG &raiz){
int Max = -111;
for (int i = 0; i < 9; i++) {
if (raiz.nodo[i].ganador > Max) {
Max = raiz.nodo[i].ganador;
raiz.mejorMovimiento = raiz.nodo[i].indice;
if(Max==1)break;
}
}
raiz.~NodoG();
return Max;
}
ComputadoraIA::Min(NodoG &raiz){
int Min = 111;
for (int i = 0; i < 9; i++) {
if (raiz.nodo[i].ganador < Min) {
Min = raiz.nodo[i].ganador;
raiz.mejorMovimiento = raiz.nodo[i].indice;
if(Min==-1)break;
}
}
raiz.~NodoG();
return Min;
}
ComputadoraIA::terminado(int tablero[]){
if ( tablero[0] == tablero[1] && tablero[0] == tablero[2] && tablero[0] != 0 )
return tablero[0];
else if ( tablero[3] == tablero[4] && tablero[3] == tablero[5] && tablero[3] != 0 )
return tablero[3];
else if ( tablero[6] == tablero[7] && tablero[6]== tablero[8] && tablero[6] != 0 )
return tablero[6];
else if( tablero[0] == tablero[3] && tablero[0] == tablero[6] && tablero[0] != 0 )
return tablero[0];
else if ( tablero[1] == tablero[4] && tablero[1] == tablero[7] && tablero[1] != 0 )
return tablero[1];
else if ( tablero[2] == tablero[5] && tablero[2] == tablero[8] && tablero[2] != 0 )
return tablero[2];
else if ( tablero[0] == tablero[4] && tablero[0] == tablero[8] && tablero[0] !=0 )
return tablero[0];
else if ( tablero[2] == tablero[4] && tablero[2] == tablero[6] && tablero[2] != 0 )
return tablero[2];
return 0;
}
bool ComputadoraIA::puedoGanar(int tablero[]){
return terminado(tablero)== 2;
}
bool ComputadoraIA::puedoPerder(int tablero[]){
return terminado(tablero)==1;
}
void ComputadoraIA::imprime(int *gato){
for ( int i = 0; i < 9; i ++ ){
cout<<gato[i]<<" ";
if ( i == 2 || i == 5 )cout<<" ";
}
cout<<"\r\n";
}
|
| Código: |
class NodoG{
public:
int mejorMovimiento;
struct NodoG *nodo;
int tablero[];
bool miTurno;
int indice;
int ganador;
NodoG();
NodoG(int mov);
~NodoG();
};
NodoG::NodoG(){
this->tablero[9];
}
NodoG::~NodoG(){
delete[] nodo;
}
|
por favor ayuda para corregir el codigo, cualquier ayuda, comentario, correción o sugerencia es bien recibida con agredecimiento.  [/b]
_________________
Alejandro |
| | Volver arriba | |  | towhi
Registrado: 27 Abr 2011
Mensajes: 3
Ubicación: Campeche, Mexico
| | Publicado: 30/04/2011 10:54 am | | | Título: Juego de Gato o Tres en Raya (Algoritmo MiniMax) Mejorado |
| Hola, eh corregido la mayoria de los errores del codigio fuente que publique, pero sique teniendo un error a la ahora de destruir los nodos generados, alguien me podria ayudar con esto, le djo el nuevo codigo fuente, les pondre solo las modificaciones de los metodos que han sigo modificados y de la clase NodoG:
| Código: |
ComputadoraIA::movimiento(int *tablero){
this->tiradas++;
for (int i = 0; i < 9; i++) {
this->arbol.tablero[i] = tablero[i];
}
movComputadora(this->arbol);
return this->arbol.get_MejorMovimiento();
}
|
| Código: |
void ComputadoraIA::movComputadora(NodoG &arbol){
int movimientos = movDisponibles(arbol.tablero);
int *indices = posVacias(arbol.tablero);
arbol.nodo = new NodoG[movimientos];
int ganador = terminado(arbol.tablero);
if(ganador==1)ganador=-1;
else if ( ganador == 2 ) ganador = 1;
if (ganador!=0||movimientos==0) {
arbol.set_Ganador(ganador);
}else{
for (int i = 0; i < movimientos; i++) {
for (int j = 0; j < 9; j++){
arbol.nodo[i].tablero[j] = arbol.tablero[j];
}
if(arbol.get_Turno()){
arbol.nodo[i].tablero[indices[i]] = 1;
}else{
arbol.nodo[i].tablero[indices[i]] = 2;
}
arbol.nodo[i].set_Turno(!arbol.get_Turno());
arbol.nodo[i].set_Indice(indices[i]);
movComputadora(arbol.nodo[i]);
}
if(!arbol.get_Turno())
arbol.set_Ganador(Max(arbol,movimientos));
else
arbol.set_Ganador(Min(arbol,movimientos));
}
}
ComputadoraIA::Max(NodoG &raiz,int mov){
int Max = -111;
for (int i = 0; i < mov; i++) {
if (raiz.nodo[i].get_Ganador() > Max) {
Max = raiz.nodo[i].get_Ganador();
raiz.set_MejorMovimiento(raiz.nodo[i].get_Indice());
if(Max == 1)break;
}
}
raiz.~NodoG();
return Max;
}
ComputadoraIA::Min(NodoG &raiz,int mov){
int Min = 111;
for (int i = 0; i < mov; i++) {
if (raiz.nodo[i].get_Ganador() < Min) {
Min = raiz.nodo[i].get_Ganador();
raiz.set_MejorMovimiento(raiz.nodo[i].get_Indice());
if(Min==-1)break;
}
}
raiz.~NodoG();
return Min;
}
|
| Código: |
class NodoG{
private:
bool miTurno;
int indice;
int mejorMovimiento;
int ganador;
public:
struct NodoG *nodo;
int tablero[];
NodoG();
void set_Turno(bool turno);
bool get_Turno();
void set_Indice(int indice);
int get_Indice();
void set_MejorMovimiento(int movimiento);
int get_MejorMovimiento();
void set_Ganador(int Ganador);
int get_Ganador();
~NodoG();
};
NodoG::NodoG(){
this->tablero[9];
set_Turno(false);
}
void NodoG::set_Turno(bool turno){
this->miTurno = turno;
}
bool NodoG::get_Turno(){
return this->miTurno;
}
void NodoG::set_Indice(int indice){
this->indice = indice;
}
int NodoG::get_Indice(){
return this->indice;
}
void NodoG::set_MejorMovimiento(int movimiento){
this->mejorMovimiento = movimiento;
}
int NodoG::get_MejorMovimiento(){
return this->mejorMovimiento;
}
void NodoG::set_Ganador(int ganador){
this->ganador = ganador;
}
int NodoG::get_Ganador(){
return this->ganador;
}
NodoG::~NodoG(){
delete[] nodo;
delete[] this->tablero;
}
|
¿el destructor ~NodoG esta bien implementado o lo tengo que hacer de otra forma para destruir correctamente los nodos?
_________________
Alejandro |
| | Volver arriba | | | | |
| No puede crear mensajes
No puede responder temas
No puede editar sus mensajes
No puede borrar sus mensajes
No puede votar en encuestas
|
|
| |
F.A.Q.
Conéctese para revisar sus mensajes