// 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;
}