问题描述 给定无向图的数据类型如下 #define MAXVEX 100 typedef char VertexType; typedef int EdgeType; typedef struct { VertexType vexs[MAXVEX]; //顶点表 EdgeType edge[MAXVEX][MAXVEX]; //邻接矩阵,即边表 int visited[MAXVEX];//遍历标记. 1:已遍历 0:未遍历 int vertexNum,edgeNum; }MGraph,*Graph; 请设计int distance(Graph g,VertexType v, VertexType u)函数。 该函数返回图中两个顶点v和w之间的距离(最短连通路上边的数目)。提示：连通返回距离，不连通返回0。 . 请注意，本题有预置代码，只需提交所要求的函数定义代码即可。 预置代码 #include<bits/stdc++.h> using namespace std; #define MAXVEX 100 typedef char VertexType; typedef int EdgeType; typedef struct { VertexType vexs[MAXVEX]; //顶点表 EdgeType edge[MAXVEX][MAXVEX]; //邻接矩阵,即边表 int visited[MAXVEX];//遍历标记. 1:已遍历 0:未遍历 int vertexNum,edgeNum; }MGraph,*Graph; int distance(Graph g,VertexType v, VertexType u); int main() { /*此处代码由测试程序自动添加，主要为了向顺序表中插入数据 并输出数据,你无需关心此处代码的具体实现细节。 如果有必要，请自己添加代码以测试你的函数是否正确。 */ return 0; } /*你的提交的代码将被添加在此处，请完成题目所要求的函数的定义*/c语言代码

) {
dir = parent->u.subdir;
break;
} else if (parent->type == 1 && strcmp(parent以下是实现题目要求的 C 语言代码：

int distance(Graph g, VertexType v, VertexType->name, token) == 0) {
                inode* node = parent->u.file;
                for (i = 0; i < 256; i++) {
                    if (node->index[i] != -1) {
                        free_block(node->index[i]);
                    u) {
    // 先判断两个顶点是否连通
    int vIndex = -1, uIndex = -1;
    for (int i = 0; i < g->vertexNum; i++) {
        if (g->vexs[i] }
                }
                free_inode(node);
                if (parent == root->u.subdir) {
                    root->u.subdir = parent == v) {
            vIndex = i;
        } else if (g->vexs[i] == u) {
            uIndex->next;
                } else {
                    parent->parent->next = parent->next;
                }
                free(parent);
                pthread_mutex_unlock(&mutex);
                return 0;
            }
            parent = parent->next;
        }
        if (dir == NULL) {
            = i;
        }
    }
    if (vIndex == -1 || uIndex == -1) {
        return 0; // pthread_mutex_unlock(&mutex);
            return -1;
        }
        token = strtok(NULL, "/");
    }
    pthread_mutex_unlock(&mutex 两个顶点中至少有一个不在图中
    }

    // 初始化 dp 数组
    int dp[MAXVEX][MAXVEX];
    for (int i = 0; i < g->vertexNum; i++) {
        for (int);
    return -1;
}

// 文件读操作
int read(char* path, char* data, int size, int offset) {
 j = 0; j < g->vertexNum; j++) {
            dp[i][j] = g->edge[i][j];
    pthread_mutex_lock(&mutex);
    int i, j, k;
    directory* dir = root;
    char* token = strtok(path, "/");
    while (token != NULL) {
        directory* sub = NULL;
        while (dir != NULL) {
            if (        }
    }

    // Floyd 算法求最短路径
    for (int k = 0; k < g->vertexNumdir->type == 0 && strcmp(dir->name, token) == 0) {
                sub = dir->u.subdir;
               ; k++) {
        for (int i = 0; i < g->vertexNum; i++) {
            for (int j = break;
            } else if (dir->type == 1 && strcmp(dir->name, token) == 0) {
                inode* 0; j < g->vertexNum; j++) {
                if (dp[i][j] > dp[i][k] + dp[k][j]) {
                    dp[i][j] = dp[i][k] + dp[k][j];
                }
            }
        }
 node = dir->u.file;
                if (offset >= node->size) {
                    pthread_mutex_unlock(&mutex);
                    return 0    }

    return dp[vIndex][uIndex] == INT_MAX ? 0 : dp[vIndex][uIndex];
}

在;
}
int block_num = (size - 1) / BLOCK_SIZE + 1;
int block_offset = offset /该代码中，我们首先根据顶点 v 和顶点 u 的值找到它们在顶点表中的下 BLOCK_SIZE;
int block_remain = size;
int data_offset = 0;
for (i = block_offset; i <标，判断它们是否都在图中。

然后我们使用 Floyd 算法求出任意两个顶点之间的 256 && node->index[i] != -1 && block_remain > 0; i++) {
int block_size = block_remain >最短路径，即计算出 dp 数组。最后，如果 v 和 u 不连通，即它们之间没有 BLOCK_SIZE ? BLOCK_SIZE : block_remain;
memcpy(data + data_offset, disk[node->index[i]].data + offset % BLOCK_SIZE路径，则返回 0，否则返回 dp[vIndex][uIndex]，即顶点 v 到顶点 u 的最短路径长度。