[C/C++]Encontrar el camino más corto por matriz

Bien, tengo en mente un proyecto, pero necesito ayuda con algo.
Supongamos que tengo una mascara de una imagen/mapa determinada/o. Lo que no se puede pisar, lo "solido" es de color azul . El espacio que esta disponible para moverse es el de color blanco .

Imagen

Supongamos ahora que transormo la imagen en una matriz de tamaño el de la misma imagen y que donde hay un bit de color azul pongo un 1 y donde hay un bit de color blanco(espacio de movimiento) pongo un 0. Por ejemplo:
bool mascara[10][10] =
{{1,1,1,1,1,1,1,1,1,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}};


Tengo un sprite en la posicion (x,y), y me quiero mover a la posicion (s,t). Lo primero comprobaria que el espacio se puede "andar", de segundas debería buscar algo asi como el camino mas corto.
Para mover al personaje voy recorriendo por unidades, como un rey en ajedrez si me permitiis la comparacion.
A donde quiero llegar es a la pregunta, como hallo el camino minimo de 0 para ir de la posición x,y a la posicion s,t. Y si no existe tal camino, me lo indique de alguna forma.

PD: Quizas sea una pregunta muy basica, pero mis conocimientos actuales no me permiten sacar la forma de obtener este algoritmo/problema. Gracias a los que contesten
Busca información sobre el algoritmo A o sobre el algoritmo A*, también puedes usar Anchura o Profundidad. Si la complejidad es poca, usa anchura. Este algoritmo lo que hace es generar el camino más corto que necesitas. La idea es:

-Anchura, realizar una exploración en modo radar. Desde la casilla inicial exploras todas las de alrededor, con las de alrededor de las de alrededor haces lo mismo, etc.. si necesitas más ayuda, mensaje privado. Por aqui es bastante dificil explicarlo.
el algoritmo A está muy bien, yo ahora asi en 5 minutos que no te dará el camino más corto pero te dará una buena aproximación y además será más rápido si lo quieres para un juego.

la idea en cada estado tienes un conjunto de posibles valores, entonces los ponderas, suponiendo que en un momento dado estas (x) en
1 0 0
0 x 0
0 0 0 0 0 0 y

suponemos que quierees ir a y pues lo que haces es ponderar los pesos( en este caso he usado la distancia de manhatan par ponderarlos pero podría haber sido cualquier otra) se quedaría una cosa así más o menos:

n 7 6
7 x 5
6 5 4 0 0 0 y

una vez ponderados vas cogiendo el de menor peso y bueno vuelves a ejecutar recursivamente el algoritmo hasta que llegues a donde querías o te encuentres con que el nodo al que querias acceder no es alcanzable, si no es alcanzable se ace el algoritmo par el camino anterior, si no es alcanzable se hace par el anterior... y así sucesivamente.

espero que te haya servido de algo igual así a simple vista m doy cuenta de que lo cuento super mal, pero el principio de encontrar caminos buenos es por ahí ;)
Gracias por la ayuda, he encontrado algo en esta pagina:

http://www.policyalmanac.org/games/aStarTutorial_es.htm

Por lo que veo, os referiais a eso, ahora lo dificil será ponerlo en practica en una Nintendo DS.
Pongo el enlace por si alguien se quiere enterar del tema.

Saludos
utiiza el A* ya q es un algortimo q asegura encontrar solucion si esa existe y si tu heuristica es aceptable asegura optimalidad en el encuentro del camino.

saludos
Manejas STL's ?? yo emplearia una clase tipo Matrix, si necesitas la implementación te la puedo pasar, es mucho más cómodo todo, teniendo en cuenta que puedes usar los algoritmos genéricos de las STL's, en vez de usar un array como haces... y bueno seguro que encuentras via krugle o algún similar algo de código que puedas reutilizar.
Quizá te pueda iteresar tb la página algoritmia. saludos!
Bueno...
si la Nintendo DS tiene la STL implementada pos perfecto, pero creo que no la tenia implementada.
Seria posible usar el mismo codigo de la STL en la nintendo DS? De donde saco las clases?
Saludos
uff yo es que no tengo ni idea de programar para consolas... el caso es que te puedes pillar todas las implementaciones de la stl de la primera página que te salen en Mr. Google al buscar STL

http://www.sgi.com/tech/stl/download.html
Para matrices pequeñas usa A* (pronunciado A Star). Es el mas facil de implementar y si la matriz no es muy grande es relativamente rápido, ademas de soportar diferentes tipos tipos de terrenos con un factor de movimiento diferente sin mucho cambio del algoritmo original.
8 respuestas