单源最短路径算法

Bellman-Ford算法

struct Node
{
    int distance;
    int prev;
};

void PrintPath(Node* node, int source, int index)
{
    if (node[index].index == source)
    {
        printf("%4d", source);
        return;
    }
    PrintPath(node, source, node[index].prev);
    printf("%4d", index);
}

int BellmanFord(int** matrix, int node_num, int source, int dest)
{
    Node* node = new Node[node_num];
    for (int i = 0; i < node_num; i++)
    {
        node[i].distance=100;
        node[i].prev = -1;
    }
    node[source].distance = 0;
    for (int t = 0; t < node_num; t++)
    {
        for (int i = 0; i < node_num; i++)
        {
            for (int k = 0; k < node_num; k++)
            {
                if (matrix[i][k] > -5 && matrix[i][k] + node[i].distance < node[k].distance)
                {
                    node[k].distance = matrix[i][k] + node[i].distance;
                    node[k].prev = i;
                }
            }
        }
    }

    for (int i = 0; i < node_num; i++)
    {
        for (int k = 0; k < node_num; k++)
        {
            if (matrix[i][k] > 0 && matrix[i][k] + node[i].distance < node[k].distance)
            {
                return false;
            }
        }
    }


    for (int i = 0; i < node_num; i++)
    {
        printf("distance from %d to %d is %d\n", source, i, node[i].distance);
    }
    PrintPath(node, source, dest);
    return true;

}

int main()
{
    int num_node, num_vert;
    int binary_vertex;
    FILE* fp = fopen("input.txt", "r");
    char buf[1024];
    if (fscanf(fp, "%d %d %d\n", &num_node, &num_vert, &binary_vertex) != 3)
    {
        fprintf(stderr, "\nfscanf error: %s: %d\n", strerror(errno), errno);
        exit(1);
    }

    int** matrix = new int*[num_node];
    for (int i = 0; i < num_node; i++)
    {
        matrix[i] = new int[num_node];
    }
    for (int i = 0; i < num_node; i++)
    {
        for (int j = 0; j < num_node; j++)
        {
            matrix[i][j] = -100;
        }
    }

    while (fgets(buf, 1024, fp) != NULL)
    {
        int begin, end;
        int weight;
        if (sscanf(buf, "%d %d %d\n", &begin, &end,&weight) != 3)
        {
            fprintf(stderr, "\nsscanf error: %s: %d\n", strerror(errno), errno);
            exit(1);
        }
        if (binary_vertex == 1)
        {
            matrix[end][begin] = weight;
        }
        matrix[begin][end] = weight;
    }

    for (int i = 0; i < num_node; i++)
    {
        for (int j = 0; j < num_node; j++)
        {
            printf("%8d", matrix[i][j]);
        }
        printf("\n");
    }
    int source = 0;
    int dest = 1;
    int dis = BellmanFord(matrix, num_node, source, dest);

    return 0;
}

---

---

Dijkstra算法

---

struct Node
{
    int index;
    int distance;
    int prev;
};
struct Compare 
{
    bool operator() (Node a, Node b) 
    {
        if (a.distance > b.distance)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

void PrintPath(Node* node, int source, int index)
{
    if (node[index].index == source)
    {
        printf("%4d", source);
        return;
    }
    PrintPath(node, source, node[index].prev);
    printf("%4d", index);
}

int Dijkstra(int** matrix, int node_num, int source, int dest)
{
    Node* node = new Node[node_num];
    for (int i = 0; i < node_num; i++)
    {
        node[i].index = i;
        node[i].distance = 100;
        node[i].prev = -1;
    }
    node[source].distance = 0;

    priority_queue<Node,vector<Node>,Compare > que;

    que.push(node[source]);
    while (!que.empty())
    {
        Node cur = que.top();
        que.pop();

        for (int i = 0; i < node_num; i++)
        {
            if (matrix[cur.index][i] >= 0 && matrix[cur.index][i] + cur.distance < node[i].distance)
            {
                node[i].distance = matrix[cur.index][i] + cur.distance;
                node[i].prev = cur.index;
                que.push(node[i]);
            }
        }
    }

    for (int i = 0; i < node_num; i++)
    {
        printf("distance from %d to %d is %d\n", source, i, node[i].distance);
    }
    PrintPath(node,source,dest);
    return node[dest].distance;
}
int main()
{
    int num_node, num_vert;
    int binary_vertex;
    FILE* fp = fopen("input.txt", "r");
    char buf[1024];
    if (fscanf(fp, "%d %d %d\n", &num_node, &num_vert, &binary_vertex) != 3)
    {
        fprintf(stderr, "\nfscanf error: %s: %d\n", strerror(errno), errno);
        exit(1);
    }

    int** matrix = new int*[num_node];
    for (int i = 0; i < num_node; i++)
    {
        matrix[i] = new int[num_node];
    }
    for (int i = 0; i < num_node; i++)
    {
        for (int j = 0; j < num_node; j++)
        {
            matrix[i][j] = -1;
        }
    }

    while (fgets(buf, 1024, fp) != NULL)
    {
        int begin, end;
        int weight;
        if (sscanf(buf, "%d %d %d\n", &begin, &end,&weight) != 3)
        {
            fprintf(stderr, "\nsscanf error: %s: %d\n", strerror(errno), errno);
            exit(1);
        }
        if (binary_vertex == 1)
        {
            matrix[end][begin] = weight;
        }
        matrix[begin][end] = weight;
    }

    for (int i = 0; i < num_node; i++)
    {
        for (int j = 0; j < num_node; j++)
        {
            printf("%8d", matrix[i][j]);
        }
        printf("\n");
    }
    int source = 0;
    int dest = 2;
    int dis = Dijkstra(matrix, num_node, source, dest);

    return 0;
}