Ciao a tutti!
Sono in possesso di queste due versioni dell'algoritmo di Bellman Ford (utile per determinare il cammino di costo minimo in un grafo orientato), che restituiscono entrambe -correttamente- il costo minimo del cammino dal nodo sorgente a tutti gli altri.
Vi chiedo un aiuto per sapere se è possibile, da uno o da entrambi questi programmi, effettuare qualche piccola modifica al codice per ottenere non solo il costo, ma anche i nodi "intermedi".
In particolare mi basta sapere il percorso per giungere dal nodo 0 (sorgente) al nodo n (terminazione), in quanto per me i nodi rappresentano dei periodi temporali.

Nel ringraziarvi, faccio presente che sono ben disposto ad un dialogo costruttivo che mi porti alla soluzione desiderata

VERSIONE 1
codice:
#include <stdio.h>
 
typedef struct {
  int u, v, w;
} Edge;
 
int n; /* the number of nodes */
int e; /* the number of edges */
Edge edges[1024]; /* large enough for n <= 2^5=32 */
int d[32]; /* d[i] is the minimum distance from node s to node i */
 
#define INFINITY 10000
 
void printDist() {
  int i;
  
  printf("Distances:\n");
  
  for (i = 0; i < n; ++i)
    printf("to %d\t", i + 1);
  printf("\n");
  
  for (i = 0; i < n; ++i)
    printf("%d\t", d[i]);
  
  printf("\n\n");
}

void bellman_ford(int s) {
  int i, j;
  
  for (i = 0; i < n; ++i)
    d[i] = INFINITY;
  
  d[s] = 0;
  
  for (i = 0; i < n - 1; ++i)
    for (j = 0; j < e; ++j)
      if (d[edges[j].u] + edges[j].w < d[edges[j].v])
    d[edges[j].v] = d[edges[j].u] + edges[j].w;
}

int main(int argc, char *argv[]) {
  int i, j;
  int w;
  
  FILE *fin = fopen("dist1.txt", "r");
  fscanf(fin, "%d", &n);
  e = 0;
  
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j) {
      fscanf(fin, "%d", &w);
      if (w != 0) {
    edges[e].u = i;
    edges[e].v = j;
    edges[e].w = w;
    ++e;
      }
    }
  fclose(fin);
  
  /* printDist(); */
  
  bellman_ford(0);
  
  printDist();
  
  return 0;
}
VERSIONE 2
codice:
#include<stdio.h>

#define maxVertices 100
#define INF 999999999

void BellmanFord (int graph[][maxVertices],int cost[][maxVertices], int size[], int source, int vertices) {
  int distance[vertices];
  int iter,jter,from,to;
  for (iter=0;iter<vertices;iter++) {
    distance[iter]=INF;
  }
  distance[source]=0;
  for (iter=0;iter<vertices;iter++) {
    for (from=0;from<vertices;from++) {
      for (jter=0;jter<size[from];jter++) {
          to = graph[from][jter];
          if (distance[from] + cost[from][jter] < distance[to]) {
            distance[to] = distance[from] + cost[from][jter];
          }
      }
    }
  }
  //  for (iter=0;iter<vertices;iter++) {
  printf("Il costo minimo da %d a %d è %d\n", source, /*iter*/vertices-1,distance[/*iter*/vertices-1]);
  //
}

int main() {
  int graph[maxVertices][maxVertices],size[maxVertices]={0};
  int cost[maxVertices][maxVertices];

  int vertices,edges,iter,jter;
  printf("Numero vertici: ");
  scanf("%d",&vertices);
  edges=vertices*(vertices-1)/2; //questo va bene nel mio caso, altrimenti richiedo il numero di archi con le righe sotto
  //  printf("Numero archi: ");
  //  scanf("%d",&edges);

  //ciclo omissibile se passo i dati da un file di testo
  int node1,node2,weight;
  for (iter=0;iter<edges;iter++) {
    printf("Inserire Nodo iniziale, Nodo finale e Costo dell'arco separati da spazio: ");
    scanf("%d%d%d", &node1,&node2,&weight);
    //    scanf("%d",&node1);
    //    printf("Nodo finale: ");
    //    scanf("%d",&node2);
    //    printf("Costo: ");
    //    scanf("%d",&weight);
    graph[node1][size[node1]] = node2;
    cost[node1][size[node1]] = weight;
    size[node1]++;
  }

  int source;
  printf("Sorgente: ");
  scanf("%d",&source);
  BellmanFord(graph,cost,size,source,vertices);
  return 0;
}