Вычислить таблицу маршрутизации следующего перехода из матрицы смежности, используя алгоритм Дейкстры — alg. не останавливаясь

Я пытаюсь определить таблицу маршрутизации следующего прыжка, используя матрица смежности. Каждый узел знает полную матрицу смежности для этой топологии. Я нашел предыдущие посты, объясняющие, как это сделать, однако, я не понимаю, почему мое неправильно. У меня есть несколько вспомогательных функций, но их имена интуитивно понятны, так что вы можете перейти к «запуску вычислений маршрутизации».

Я использую матрицу смежности в качестве матрицы затрат, у нее только 0 и 1. Алгоритм не останавливается по какой-то причине. Очередь застревает на размере 1,3 или 5 в зависимости от узла.

Переменная rank содержит индекс текущего узла, он запускается в OpenMPI, поэтому каждый процесс (rank / node) выполняет этот фрагмент кода независимо. Переменная матрица содержит матрицу смежности.
Вот топология, которую я использую:

               0
/    \
1       2
/ /  | \   /  \
3  4  5  6 7    8
/ \           |
9  10          11

Матрица смежности:
(Как видно из Узла 3, один из тех, что не останавливается);

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

Мой код до сих пор:

int isFull(int *d, int size) {
int i;

for(i = 0; i < size; i++) {
if(d[i] == INF) {
return -1;
}
}
return 1;
}
int vecSize(int *d, int size) {
int counter = 0;
int i;
for(i = 0; i < size; i++) {
if(d[i] != INF) {
counter++;
}
}
return counter;
}
bool List_contains(std::list<int > l, int val) {
for (std::list<int>::const_iterator iterator = l.begin(), end = l.end(); iterator != end; ++iterator) {
if (*iterator == val) {
return true;
}
}
return false;
}
int minimum (int a, int b) {
if (a < b) {
return a;
}
return b;
}
/* matrix is the complete adjacency matrix *//* starting routing calculations
*
*/
std::list <int > visited;
int *dist;
dist = (int*) calloc(size, sizeof(int));
visited.push_back(rank);

//debug
//printf("debug not empty %d\n", isFull(dist, size));
for(i = 0; i < size; i++) {
if(matrix[rank][i] == 1) {
dist[i] = 1;
} else {
dist[i] = INF;
}
}
dist[rank] = 0;
int min;
while(isFull(dist,size) < 0) {
if(rank == 3)
printf("node - %d -debug -- list size %d\n",rank, vecSize(dist, size));
//get the first node that isn't contained
for(i = 0; i < size; i++) {
if (!List_contains(visited, i) && min != rank) {
min = i;
break;
}
}

for(i = 0; i < size; i++) {
if((min >= dist[i]) && (!List_contains(visited, i)) && min != rank) {
min = i;
}
}
if(rank == 3)
printf("min = %d\n", min);
visited.push_back(min);

for(i = 0; i < size; i++) {
if((matrix[min][i] == 1) && (!List_contains(visited, i))) {
dist[i] = minimum (dist[i], dist[min] + matrix[min][i]);
}
}
if(rank == 3)
//printf("rank %d dist = \n", rank);
for(i = 0; i < size; i++) {
if(rank == 3)
printf("%d ", dist[i]);
}
if(rank == 3)
printf("\n");
}
/*
* finished routing calculations.
*/

Это будет вывод: http://pastebin.com/x5wjKkyn

Может кто-то указать, что я делаю не так? Спасибо !
Позднее редактирование: Технически алгоритм предоставляет правильные расстояния, он просто не останавливается. (Вывод исключительно из узла 0)

Позже редактирование: кажется, что программа не останавливается, потому что для некоторых узлов алгоритм не заканчивается.