迪杰斯特拉算法求最短路径

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include<algorithm>

using namespace std;



#define MAX_NODES 10

#define INFINITY 1000000

int q[MAX_NODES];



struct Graph {

    int numNodes;

    int edges[MAX_NODES][MAX_NODES];

};



void initializeGraph(struct Graph* graph, int numNodes)

{

    // 初始化图节点数量和边权重为无穷大

    graph->numNodes = numNodes;

    for (int i = 1; i <=numNodes; ++i) {

        for (int j = 1; j <=numNodes; ++j) {

            graph->edges[i][j] = INFINITY;

        }

    }

}



void addEdge(struct Graph* graph, int fromNode, int toNode, int weight)

{

    // 添加一条边，注意要处理重复添加和自环的情况

    if (fromNode != toNode && weight < INFINITY) {

        graph->edges[fromNode][toNode] = weight;

        graph->edges[toNode][fromNode] = weight;

    }

}



void findShortestPath(struct Graph* graph, int startNode, int endNode)

{

    // 初始化距离数组和访问标记数组

    int distance[MAX_NODES];

    bool visited[MAX_NODES];



    for (int i = 1; i <= graph->numNodes; ++i) {

        distance[i] = INFINITY; // 距离初始化为无穷大

        visited[i] = false; // 访问标记初始化为未访问

    }



    distance[startNode] = 0;



    // 进行图的遍历

    for (int i = 1; i < graph->numNodes; ++i) {

        // 找到未访问节点中距离最小的节点

        int minDistance = INFINITY, minNode;

        for (int j = 1; j <= graph->numNodes; ++j) {

            if (!visited[j] && distance[j] < minDistance) {

                minDistance = distance[j];

                minNode = j;

            }

        }



        // 标记该节点已经访问过

        visited[minNode] = true;



        // 更新所有以该节点为起点的边的距离

        for (int j = 1; j <=graph->numNodes; ++j) {

            int weight = graph->edges[minNode][j];

            // if (weight < INFINITY) {

            // int newDistance = distance[minNode] + weight;

            // if (newDistance < distance[j]) {

            // distance[j] = newDistance;

            // }

            // }

            distance[j]=min(distance[j],distance[minNode]+weight);

            if(distance[j]==INFINITY) continue;

            else printf("distance[%d]=%d\n",j,distance[j]);

        }

        printf("-------------------------------------------\n");

    }



    // 输出结果

    if(distance[endNode]==INFINITY) printf("从点%d到点%d无路径可以到达\n",startNode,endNode);

    else printf("从点%d到点%d的最短路径长度为%d\n", startNode, endNode, distance[endNode]);

}

int find(int a)

{

    int l=1,r=MAX_NODES;

    for(int i=1;i<=MAX_NODES;i++)

    {

        if(q[i]==0) continue;

        else 

        {

            l=i;

            break;

        }

    }

    while(l<r)

    {

        int mid=l+r>>1;

        if(q[mid]>=a) r=mid;

        else l=mid+1;

    }

    if(q[l]!=a) return 0;

    else return l;

}



int main()

{

    struct Graph graph;

    initializeGraph(&graph, MAX_NODES);



    // 添加边

    int n;//最多n条边

    scanf("%d",&n);

    int a,b,c;

    int i=1;//设置数组从下标为1开始

    printf("请输入任意两个地点以及两点间路线长度");

    while(n--)

    {

       

        scanf("%d %d %d",&a,&b,&c);

        q[i]=a;

        q[i+1]=b;

        printf("q[%d]=%d,q[%d]=%d\n",i,q[i],i+1,q[i+1]);

        i+=2;

        addEdge(&graph,a,b,c);

    }

    //将数组中重复的元素删除

    for(int j=1;j<=MAX_NODES;j++)

    {

        for(int k=j+1;k<MAX_NODES-1;k++)

        {

            if(q[j]!=q[k]) continue;

            else q[k]=q[k+1];

        }

    }

    //将地点所代表的数字在数组中进行排序

    sort(q,q+MAX_NODES);

    

    // 计算最短路径

    int x,y;

    printf("请输入任意两个地点\n");

    scanf("%d %d",&x,&y);

    if(find(x) && find(y)) findShortestPath(&graph, x, y);

    else printf("两地点有地点不存在，因此路径不可达\n");

    return 0;

}

输入节点和距离，求两节点间最短路径