使用 DFS 计算与源节点的距离

Question

我正在尝试使用 DFS 算法来计算每个节点与源节点的距离。目前，它为源顶点输出距离 0，但为所有其他顶点输出 1，即使应该有一对距离为 2。DFS 中的 printf 确实打印出正确的顺序，首先是源，然后是距离为 1，然后距离为 2 的顶点。所以我需要在算法中的哪个位置增加距离。

void dfs(int vertex1) {
    graph[vertex1-1].visited = 1;
    printf("%d \n",vertex1);
    struct edge *e;
    e = graph[vertex1-1].edgePtr;

    while (e) {
        if (!(graph[e->vertexIndex - 1].visited)){
            graph[e->vertexIndex - 1].distance++;  
            dfs(e->vertexIndex);
        }     
        e = e->edgePtr;
    }
}

Answer 1

我想我已经找到了一种让 DFS 计算距离的方法，它是正确的，除了最后一个顶点发现它说距离是 3 而不是 2。

5
(2,3)
(1,4)
(1,3)
(3,4)
(4,5)

#include <stdio.h>
#include <stdlib.h>
#include "../HW3/input_error.h"
#define VertexToSearch 1

typedef struct edge {
    int vertexIndex;
    struct edge *edgePtr;
} edge;

typedef struct vertex {
    int vertexKey;
    struct edge *edgePtr;
    int visited;
    int distance;
} vertex;

int vertexCount = 0;
struct vertex graph[];
void load_file(char*);
void insertEdge(int, int, struct vertex[]);
void InsertVertex(int, struct vertex[]);
void printGraph();
void dfs();
void print_distances();
enum error program_error;
int count;

int main(int argc, char** argv) {
    load_file(argv[1]);
    printGraph();
    dfs(VertexToSearch);
    print_distances();
    return 0;
}

void load_file(char* filename) {

    int vertex1;
    int vertex2;
    FILE* file = fopen(filename, "r");

    if (file == NULL) {
        printf("%s did not open\n", filename);
        program_error = FILE_FAILED_TO_OPEN;
        exit(program_error);
    }

    fscanf(file, "%d", &count);
    graph[count];
    for (int i = 0; i < count; i++) {
        InsertVertex(i+1, graph);
    }
    for (int i = 0; i < count; i++) {
        fscanf(file, "\n(%d,%d)", &vertex1, &vertex2);
        insertEdge(vertex1, vertex2, graph);
    }
    fclose(file);
}

void InsertVertex(int vertexKey, struct vertex graph[]) {
    graph[vertexCount].vertexKey = vertexKey;
    graph[vertexCount].edgePtr = NULL;
    graph[vertexCount].visited = 0;
    graph[vertexCount].distance = 0;
    vertexCount++;
}

void insertEdge(int vertex1, int vertex2, struct vertex graph[]) {
    struct edge *e, *e1, *e2;
    e = graph[vertex1 - 1].edgePtr;
    while (e && e->edgePtr) {
        e = e->edgePtr;
    }
    e1 = (struct edge *) malloc(sizeof (*e1));
    e1->vertexIndex = vertex2;
    e1->edgePtr = NULL;
    if (e)
        e->edgePtr = e1;
    else
        graph[vertex1 - 1].edgePtr = e1;

    e = graph[vertex2 - 1].edgePtr;
    while (e && e->edgePtr) {
        e = e->edgePtr;
    }
    e2 = (struct edge *) malloc(sizeof (*e2));
    e2->vertexIndex = vertex1;
    e2->edgePtr = NULL;
    if (e)
        e->edgePtr = e2;
    else
        graph[vertex2 - 1].edgePtr = e2;
}

void printGraph() {
    int i;
    struct edge *e;
    for (i = 0; i < vertexCount; i++) {
        printf("%d(%d)", i+1, graph[i].vertexKey);
        e = graph[i].edgePtr;
        while (e) {
            printf("->%d", e->vertexIndex);
            e = e->edgePtr;
        }
        printf("\n");
    }
}

void dfs(int vertex1) {
    graph[vertex1 - 1].visited = 1;

    printf("%d \n", vertex1);
    struct edge *e;
    e = graph[vertex1 - 1].edgePtr;
    for (int i = 0; i < count; i++) {
        if (graph[i].visited == 0 && e->vertexIndex != VertexToSearch) {
            graph[i].distance++;
        }
    }
    while (e) {
        if (!(graph[e->vertexIndex - 1].visited)) {
            dfs(e->vertexIndex);
        }
        e = e->edgePtr;
    }
}
void print_distances(){
    for(int i = 0;i < count; i++){
           printf("%d %d\n", i+ 1,graph[i].distance);
    }
}