图的最短路径算法

Dijstra：

求单源最短路径，也就是某个点到其他所有点的最短路径

#include <iostream>
#include <vector>

using namespace std;

struct Node                //邻接链表中用来存放链表元素的结构体
{
    int next;
    int cost;
};

vector<Node> edge[101];      //二维数组，用邻接链表来存放边的信息
bool mark[101];             //相当于一个集合k，用来标注以求得最短路径的结点
int dis[101];               //距离向量，如果mark[i]为true时，表示最短路径长度；
                             //否则表示从1经过已知的最短路径到达k中某点，再从该点经过一条边到达i的最短距离

int main()
{
    int n,m;
    while (cin >> n >> m)
    {
        if (n == 0 && m == 0) break;
        for (int i = 1;i <= n;i++) edge[i].clear();
        for (int i = 0;i < m;i++)
        {
            int a,b,c;
            cin >> a >> b >> c;
            Node temp;
            temp.next = b;
            temp.cost = c;
            edge[a].push_back(temp);
            temp.next = a;
            edge[b].push_back(temp);     //无向图每条边的信息都要添加到两个顶点的但链表中
        }
        for (int i = 1;i <= n;i++)     //此处进行初始化
        {
            mark[i] = false;           //所有的结点刚开始都不属于集合k
            dis[i] = -1;               //所有结点刚开始都不可达
        }
        dis[1] = 0;                 //将初始结点的信息添加进去
        mark[1] = true;
        int newP = 1;                //newP来表示集合中新加入的点
        for (int i = 1;i < n;i++)      //完成对所有结点的处理需循环n-1次
        {
            for (int j = 0;j < edge[newP].size();j++) //遍历与新加入结点相邻的所有边
            {
                int t = edge[newP][j].next;
                int c = edge[newP][j].cost;
                if (mark[t] == true) continue;  //若与它相邻的这个结点已在集合k中，则跳过
                if (dis[t] == -1 || dis[t] > dis[newP]+c)
                {
                    dis[t] = dis[newP]+c;   //如果该点在新加入newP之前不可达，
                }       //或者说通过先由最短路径到newP，再由newP经一条边到该点的距离比之前求得的距离短，那么更新它的距离信息
            }
            int min = 999999;
            for (int j = 1;j <= n;j++) //遍历所有节点，到处下一个newP；
            {
                if (mark[j] == true) continue;
                if (dis[j] == -1) continue;  //如果此结点已经在集合k中，或者根本不可达那么就跳过
                if (dis[j] < min)  //找出此时不在k中且距起点最短的点
                {
                    min = dis[j];
                    newP = j;
                }
            }
            mark[newP] = true;   //将该点加入集合k
        }
        cout << dis[n] << endl;
    }
    return 0;
}

Floyd：
求全源最短路径，该算法完成之后，图中所有节点之间的最短路径都被确定

#include <iostream>

using namespace std;

int ans[101][101];    //以邻接矩阵的形式存储该图

int main()
{
    int n,m;
    while (cin >> n >> m)
    {
        if (n == 0 && m == 0) break;
        
        for (int i = 1;i <= n;i++)
        {
            for (int j = 1;j <= n;j++)
            {
                ans[i][j] = -1;         //各结点间的初始距离都设为无穷大
            }
            ans[i][i] = 0;              //每个结点到自身的具体设为0
        }

        for (int i = 0;i < m;i++)
        {
            int a,b,c;
            cin >> a >> b >> c;
            ans[a][b] = ans[b][a] = c;     //无向图赋值操作要进行两次
        }
        for (int k = 1;k <= n;k++)       //k从1到n循环，表示允许经过的中间结点的编号小于等于k
        {
            for (int i = 1;i <= n;i++)    //遍历所有ans[i][j],判断其值要不要更新
            {
                for (int j = 1;j <= n;j++)
                {
                    if (ans[i][k] == -1 || ans[k][j] == -1) continue;  //如果两值之间有一个为无穷，则说明不能更新，跳过
                    if (ans[i][j] == -1 || ans[i][k]+ans[k][j] < ans[i][j])
                    {
                        ans[i][j] = ans[i][k]+ans[k][j];    //当由于经过k可以获得更短的路径时，更新该值
                    }
                }
            }
        }
        cout << ans[1][n] << endl;    //循环结束后输出答案
    }
    return 0;
}