void shortest(const Graph& g, int depart, Way way[][199] ){ for (int i = 0; i < 199; i++) { for (int j = 0; j < 199; j++) { way[i][j].front = -1;//初始化赋值 } } for (int v = 0; v < g.vexnum; ++v) { g.vertex[v].pass = false;//初始化 way[depart][v].time= g.arcs[depart][v].time;//权重的记录 if(way[depart][v].time!=1000000&&v!=depart){ way[depart][v].front = depart; //将与出发点相通路径的前驱全部记为出发点的序号 } } way[depart][depart].time = 0; g.vertex[depart].pass = true;//出发点设置为true for (int i = 0; i < g.vexnum; ++i) { int v = 0; float mintime = 1000000; for (int w = 0; w < g.vexnum; ++w) { if (g.vertex[w].pass == false && way[depart][w].time < mintime) { v = w; mintime = way[depart][w].time; } }//用v记录最小权重边对应的点，并用mintime来储存最小权重的值 g.vertex[v].pass = true;//选出的点置为true,表示已选中 for (int w = 0; w < g.vexnum; w++) { if (g.vertex[w].pass == false && (mintime + g.arcs[v][w].time < way[depart][w].time)) {//将目前最短路径进行更新 way[depart][w].time = mintime + g.arcs[v][w].time; way[depart][w].front = v; } } } }代码存在错误，请用递归来将代码改写

好的，我会将代码改写为使用递归的形式：

void shortest(const Graph& g, int depart, Way way[][199], int v, int w) {
    if (v == g.vexnum) {
        return;
    }
    if (w == g.vexnum) {
        shortest(g, depart, way, v + 1, 0);
        return;
    }
    way[v][w].front = -1;
    if (v == depart) {
        way[v][w].time = g.arcs[depart][w].time;
        if (way[v][w].time != 1000000 && w != depart) {
            way[v][w].front = depart;
        }
    }
    else {
        way[v][w].time = way[v][w - 1].time;
        if (way[v][w].time > way[v - 1][w].time + g.arcs[v - 1][w - 1].time) {
            way[v][w].time = way[v - 1][w].time + g.arcs[v - 1][w - 1].time;
            way[v][w].front = v - 1;
        }
    }
    shortest(g, depart, way, v, w + 1);
}

这个递归函数的实现方式与原来的迭代方式有所不同。我们使用两个参数 v 和 w 来代替原来的两个循环变量 i 和 j。在每次递归调用中，我们先判断 v 和 w 是否已经达到了数组的边界，如果已经达到了边界就直接返回。

然后我们根据当前的 v 和 w 的值来初始化 way[v][w] 的值。如果 v 等于出发点 depart，那么我们直接将 way[v][w] 的时间赋值为从 depart 到 w 的时间，同时更新前驱结点。

如果 v 不等于 depart，那么我们将 way[v][w] 的时间先赋值为 way[v][w-1] 的时间。然后我们判断从 v-1 到 w 的时间加上 way[v-1][w] 的时间是否比当前的 way[v][w] 时间更小，如果更小的话就更新 way[v][w] 的时间，并将前驱结点设置为 v-1。

最后，我们递归调用 shortest 函数，将 w 的值加一。

这个函数的时间复杂度和迭代方式的时间复杂度是一样的，都是 O(n^2)。但是这个递归函数的代码更加简洁，易于理解。