Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 82 vistas

    Ranas Saltarinas

    Cargado por

    Aurelio Antonio
    Este documento presenta el algoritmo de búsqueda en anchura para resolver el problema de las ranas saltarinas. Implementa una estructura de datos para representar los estados y transformaciones, y usa una cola para almacenar los nodos por explorar. Comienza con el estado inicial en la cola, y en cada iteración extrae un nodo, genera sus hijos aplicando reglas de salto, y los encola para su posterior exploración. Devuelve verdadero si encuentra un nodo con el estado objetivo.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd

    Ranas Saltarinas

    Cargado por

    Aurelio Antonio
    82 vistas3 páginas
    Este documento presenta el algoritmo de búsqueda en anchura para resolver el problema de las ranas saltarinas. Implementa una estructura de datos para representar los estados y transformaciones, y usa una cola para almacenar los nodos por explorar. Comienza con el estado inicial en la cola, y en cada iteración extrae un nodo, genera sus hijos aplicando reglas de salto, y los encola para su posterior exploración. Devuelve verdadero si encuentra un nodo con el estado objetivo.

    Descripción original:

    codigo ranasSaltarinas IA

    Título original

    RanasSaltarinas

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    TXT, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Este documento presenta el algoritmo de búsqueda en anchura para resolver el problema de las ranas saltarinas. Implementa una estructura de datos para representar los estados y transformaciones, y usa una cola para almacenar los nodos por explorar. Comienza con el estado inicial en la cola, y en cada iteración extrae un nodo, genera sus hijos aplicando reglas de salto, y los encola para su posterior exploración. Devuelve verdadero si encuentra un nodo con el estado objetivo.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd
    Descargar como txt, pdf o txt
    82 vistas3 páginas

    Ranas Saltarinas

    Cargado por

    Aurelio Antonio
    Este documento presenta el algoritmo de búsqueda en anchura para resolver el problema de las ranas saltarinas. Implementa una estructura de datos para representar los estados y transformaciones, y usa una cola para almacenar los nodos por explorar. Comienza con el estado inicial en la cola, y en cada iteración extrae un nodo, genera sus hijos aplicando reglas de salto, y los encola para su posterior exploración. Devuelve verdadero si encuentra un nodo con el estado objetivo.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd
    Descargar como txt, pdf o txt
    Está en la página 1de 3

    // File: RanasSaltarinas.

    cpp
    // Busqueda en Anchura para el problema de las RanasSaltarinas
    #include <iostream>
    #include <queue>
    #include <stack>
    #include <vector>
    using namespace std;
    // Prototipo de Funciones.
    struct Transformacion;
    struct origen_destino;
    bool busqueda();
    bool esSolucion(vector<int>&);
    void _swap(int i, int j, vector<int> &);
    void encolarNuevaTransformacion( queue<Transformacion>&, stack<origen_destino>,
    vector<int>,int, int);
    void pintarPila(stack<origen_destino>);

    // Constantes
    int rana_izq = 1, rana_der = 2, vacio = -1;

    // Structs
    struct origen_destino{
    int origen;
    int destino;
    };

    // Transformacion, Estado, Nodo, son sinonimos. Para efectos practicos, encontré


    mas apropiado de recordad
    // transformacion.
    // Agrupa un {@member estado}, y sus movimientos {@member movimientos}, donde el
    estado es el resultado de aplicar
    // los movimientos de la pila de movimientos.
    struct Transformacion{
    vector<int> estado;
    stack<origen_destino> movimientos;
    };

    // Variables globales para la busqueda en anchura.


    vector <int> estado_final; // El inverso del inicial
    vector <int> estado_inicial;
    queue<Transformacion> lista; // La lista de estados a procesars

    bool busqueda(){
    // centinela para encontrar la solución
    bool solucion_encontrada = false;
    // Variable de dimension para evitar sobrecarga en el procesador
    int array_size = estado_inicial.size();

    /// ----------------------------------------- Only 1 time


    -----------------------------------------
    // TODO: Refactorizar.
    // Declaracion de Variables de intercambio. ranas representa al Nodo padre.
    vector<int> ranas = estado_inicial; // Es como está el vector transformado
    stack<origen_destino> movimientos; // Las transformaciones apiladas /// Solo
    se usa una vez
    // Struct Initialization
    Transformacion nuevo ;
    nuevo.estado = ranas;
    nuevo.movimientos = movimientos;
    // Añadir a la lista. se agrega el padre a la lista
    lista.push(nuevo);
    /// ----------------------------------------- < / >
    -----------------------------------------

    // aux fungirá como un nodo de intercambio.


    Transformacion aux;

    /* lista
    * ranas
    * movimientos
    * origen-destino son palabras para recordar xDxDxDxD*/

    while (!solucion_encontrada && !lista.empty()){

    aux = lista.front();
    ranas = aux.estado; // Tablero Ranas del padre

    if ( esSolucion(aux.estado) ){
    solucion_encontrada = true;
    // No eliminas porque el padre es el chido y despues debes mostrarlo
    }else {
    // Encolar los hijos
    for (int i = 0; i < array_size; i++ ){
    if ( ranas[i] == rana_izq && ranas[i+1]==-1){
    // guardar transformacion
    encolarNuevaTransformacion(lista, aux.movimientos, aux.estado,
    i, i+1);
    }else if ( ranas[i] == rana_izq && ranas[i+2]==-1){
    // guardar transformacion
    encolarNuevaTransformacion(lista, aux.movimientos, aux.estado,
    i, i+2);
    }else if ( ranas[i] == rana_der && ranas[i-1]==-1){
    // guardar transformacion
    encolarNuevaTransformacion(lista, aux.movimientos, aux.estado,
    i, i-1);
    }else if ( ranas[i] == rana_der && ranas[i-2]==-1){
    // guardar transformacion
    encolarNuevaTransformacion(lista, aux.movimientos, aux.estado,
    i, i-2);
    }
    }// Fin de encolar hijos

    // Eliminas al padre.
    lista.pop();
    }// Fin ELSE // Fin IF

    // Continuar con el que sigue @-@


    }

    return solucion_encontrada;
    }

    bool esSolucion(vector<int> &estado){


    return estado == estado_final;
    }
    void _swap(int i, int j, vector<int> &estado){
    int aux = estado[i]; estado[i] = estado[j]; estado[j] = aux;
    }
    // REal // Copy
    void encolarNuevaTransformacion(queue<Transformacion> &l,
    stack<origen_destino> pila,
    vector<int> ranas,
    int i, int j){
    // Estado de las ranas
    // Pila
    stack<origen_destino> misMovimientos;
    vector<int> miTableroRanas ;
    misMovimientos = pila;
    miTableroRanas = ranas;

    // guardar transformacion
    origen_destino od = {i, j};
    misMovimientos.push(od); // Nuevos cambios a Movimientos
    _swap(i, j, miTableroRanas); // Nuevos cambios a Estado

    Transformacion miTransformacion = {miTableroRanas, misMovimientos}; //


    Instanciar transformacion

    l.push(miTransformacion);

    void pintarPila(stack<origen_destino> pilaMove){


    if (!pilaMove.empty()){
    origen_destino mov = pilaMove.top();
    pilaMove.pop();
    pintarPila(pilaMove);
    cout << "Saltar de [" << (mov.origen+1) << "] a [" << (mov.destino+1)
    <<"]"<<endl;
    }
    }

    int main(){
    estado_inicial = {1,1,1,1,1,1,-1,2,2,2,2,2,2};
    estado_final = {2,2,2,2,2,2,-1,1,1,1,1,1,1};

    bool si = busqueda();

    if (si){
    Transformacion t = lista.front();
    stack<origen_destino> result = t.movimientos;
    pintarPila(result);
    }

    return 0;
    }

    También podría gustarte