algorytm wychodzenia z Labiryntu C

Witam serdecznie,
(na wstępie dodam ze nie chce od Państwa żadnego kodu tylko pomysł jak napisać algorytm)
mam przez święta do napisania program który ma znaleźć wyjście z labiryntu. Ma wyglądać to tak:
wczytuje mapę do tablicy z pliku np:

0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 1 1 1 1 1 0 0 0
0 0 1 0 0 0 1 0 0 0
0 0 1 0 0 0 1 0 0 0
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 0

ustalam start i koniec (zakładam lewy dolny róg mapy i prawy górny). Zasada jest taka ze można poruszać się tylko po 1.
mam napisany program który jak ma jedna drogę to dojdzie do celu lecz gdy dodam "ślepe zaułki" to program już głupieje. Napisałem wiec ze tam gdzie był ma zostawiać po sobie 2 lecz teraz program staje w takim miejscu:

0000001111
0000001000
0122001000
0020001000
0020001000
0021111000
0020001000
0020001000
2221111111
1000000000 

Trochę się gubię i nie wiem jak dalej napisać to tak żeby wracał po dwójce aż do momentu rozwidlenia.

macie jakiś pomysł jak taki problem rozwiązać?

Najprościej - http://en.wikipedia.org/wiki/Breadth-first_search

Klasyczne podejścia:

• BFS wspomniany wyżej
• DFS
• A* jeśli wiesz jaki jest "cel" wędrówki
• Algorytm Dijkstry jeśli tak jak wyżej znasz "cel" wędrówki
  Dijkstra da ci najkrótszą drogę do wyjścia, A* trochę szybciej da ci prawie że najkrótszą, ale oba wymagają znajomości wierzchołka do którego chcesz dojść.
  BFS i DFS pesymistycznie przelecą cały graf, średnio przelecą pół grafu, ale potrafią znaleźć "wyjście" nawet jeśli nie wiesz gdzie ono jest. Poza tym są trywialne w implementacji :)

Najprościej do zrozumienia:
Pierwszą 1 przy wejściu zamieniasz na 2.
Każdą 1 sąsiadującą z 2 zamieniasz na 3.
Każdą 1 sąsiadującą z 3 zamieniasz na 4.
...
Dopóki w kolejnym kroku nie okaże się że NIE MA żadnych zamian, lub nie okaże się że przy wyjściu jest już nie jedynka.
Dodatkowo bardzo przyspieszy wykonanie kolejka zmienionych (z jedynki na coś) komórek.