Programmazione dinamica: percorso più breve con esattamente k spigoli in un grafico orientato e ponderato

Mi sono imbattuto in questo problema di trovare il percorso più breve con esattamente k bordi. Dopo alcune ricerche, ho trovato il codice qui sotto. Usa un DP 3D. Gli stati sono lì per il numero di spigoli usati, il vertice della sorgente e il vertice della destinazione. Sembra che abbiano usato qualcosa come un algoritmo di Floyd Warshall qui. In tal caso, non dovremmo usare l'ordine del ciclo: e {a {i {j {} } } } ? Dove a è il ciclo per il vertice intermedio.

Dynamic Programming based C++ program to find shortest path with exactly k edges
#include <iostream>
#include <climits>
using namespace std;

// Define number of vertices in the graph and inifinite value
#define V 4
#define INF INT_MAX

// A Dynamic programming based function to find the shortest path from
// u to v with exactly k edges.
int shortestPath(int graph[][V], int u, int v, int k)
{
    // Table to be filled up using DP. The value sp[i][j][e] will store
    // weight of the shortest path from i to j with exactly k edges
    int sp[V][V][k+1];

    // Loop for number of edges from 0 to k
    for (int e = 0; e <= k; e++)
    {
        for (int i = 0; i < V; i++)  // for source
        {
            for (int j = 0; j < V; j++) // for destination
            {
                // initialize value
                sp[i][j][e] = INF;

                // from base cases
                if (e == 0 && i == j)
                    sp[i][j][e] = 0;
                if (e == 1 && graph[i][j] != INF)
                    sp[i][j][e] = graph[i][j];

                //go to adjacent only when number of edges is more than 1
                if (e > 1)
                {
                    for (int a = 0; a < V; a++)
                    {
                        // There should be an edge from i to a and a 
                        // should not be same as either i or j
                        if (graph[i][a] != INF && i != a &&
                            j!= a && sp[a][j][e-1] != INF)
                          sp[i][j][e] = min(sp[i][j][e], graph[i][a] +
                                                   sp[a][j][e-1]);
                }
            }
       }
    }
}
return sp[u][v][k];
}