Algorithm Design——最短路径

本文主要讨论了最短路径的三个算法：Floyd，Dijkstra以及Bellman_Ford的实现方法以及他们之间的区别与联系

/**
Floyd算法流程：
      若edge[i][j]表示从结点i到结点j，中间只能经过编号小于k的点时的最短路径长度，
我们可以由这些值确定当中间允许经过编号小于等于k的结点时，它们之间的最短路径长
度。同样，与原情况相比，新情况中允许 出现在中间路径的结点新增了编号为 k 的结
点，同理我们确定 edge[i][k] + edge[k][j]的值与edge[i][j]的值，若前者较小则该值代
表了新情况中从结点i到结 点j的最短路径长度；否则，新情况中该路径长度依旧保持不变。

Floyd算法注意事项：
    （1）时间复杂度，O(N^3)，所以在节点个数大于200时，考虑超时问题；
    （2）用一个二维矩阵表示图形，如果原图并非由邻接矩阵给出时，设法转换，特别地，
当两个节点之间有多余一条边时，我们选择长度最小的边权值存入邻接矩阵；
    （3）放算法完成后，所有节点之间的最短路径都被确定，适合——全源最短路径问题。

样例输入： 
2 1
1 2 3 
3 3
1 2 5 
2 3 5 
3 1 2
0 0
样例输出：
3 
2
*/

#include<cstdio>
using namespace std;

int ans[101][101];//二维数组，其初始值即为该图的邻接矩阵

int main()
{
    int n, m;
    while(scanf_s("%d%d", &n, &m) != EOF)//输入节点个数以及边个数
    {
        if(n ==0 && m == 0)
            break;

        for(int i = 1 ; i < n ; i ++)
        {
            for(int j = 0 ; j <=n ; j ++)
            {
                ans[i][j] = -1;//对邻接矩阵初始化，-1表示无穷大
            }
            ans[i][i] = 0;//自己到自己的路径长度设置为0
        }

        //输入边信息
        while(m --)
        {
            int a, b, c;
            scanf_s("%d%d%d", &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 ++)
            {
                for(int j = 1 ; j <= n ; j ++)//遍历所有的ans[i][j]，判断气质保持原值，还是将要被更新
                {
                    if(ans[i][k] == -1 || ans[k][j] == -1)//若两值中有一个值为无穷，则ans[i][j]不能经过节点k而被更新，跳过循环，保持原值
                        continue;

                    if(ans[i][j] == -1 || ans[i][k] + ans[j][k] < ans[i][j])//当由于经过k可以获得更短的最短路径时，更新该值
                        ans[i][j] = ans[i][k] + ans[j][k];
                }
            }
        }

        printf_s("%d
", ans[1][n]);//循环输出最后答案
    }

    return 0;
}


 /**
Dijkstra算法流程：
    （1）初始化，集合K中加入节点1，节点1到节点1的最短路径为0，到其他节点为无穷（或不确定）；
    （2）遍历集合K中与集合K中节点直接相邻的边（U,V,C），其中U属于集合K，V不属于集合K，计算由节点1
出发按照已经得到的最短路到达U，再由U经过该边到达V时的路径长度。比较所有与集合K中节点直接相邻的
非集合K节点该路径长度，其中路径长度最小的节点被确定为下一个最短路径确定的节点，其最短路径长度即为
这个路径长度，最后将该节点加入集合K；
（3）若集合K中已经包含了所有的点，算法结束；否则重复步骤2；

Dijkstra算法注意事项
    （1）单源最短路径问题，即只能计算出某个特定节点到其他所有节点的最短路径长度；
    （2）支持邻接链表，在节点比较多时，可以使用这种方法

样例输入： 
2 1
1 2 3 
3 3
1 2 5 
2 3 5 
3 1 2
0 0
样例输出：
3 
2 
*/

#include<cstdio>
#include<vector>
using namespace std;

struct E//邻接表中链表原色结构体（由一个节点所持有）
{
    int next;//代表直接相邻的点
    int c;//代表该边的权重
};

vector<E> edge[101];//邻接表
bool mark[101];//标记，当mark[j]为true时，表示节点j的最短路径长度已经得到，该节点已经加入集合K
int Dis[101];//距离向量，当mark[k]为true时，表示已经得到最短路径；
                //否则表示所有从节点1出发，经过已知的最短路径达到集合K中的某点，在经过一条边到达节点i的路径中最短距离

int main()
{
    int n , m;

    while(scanf_s("%d%d", &n, &m) != EOF)//节点以及边个数
    {
        if(n == 0 && m ==0)
            break;

        for(int i = 1 ; i <= n ; i ++)
            edge[i].clear();//清空上一次数据

        while(m --)
        {
            int a, b, c;//节点a，节点b，权重c
            scanf_s("%d%d%d", &a, &b, &c);

            E tmp;
            tmp.c = c;
            tmp.next = b;
            edge[a].push_back(tmp);
            tmp.next = a;
            edge[b].push_back(tmp);//将邻接信息加入邻接表，由于是无向图，从而每条边信息都要添加到其链各个两个顶点的两条单链表中
        }

        for(int i = 1 ; i <= n ; i ++)//初始化
        {
            Dis[i] = -1;//所有距离为-1，即不可达
            mark[i] = false;//所有节点不属于集合K
        }

        Dis[1] = 0;//得到最近的点为节点1，长度为0
        mark[1] = true;//将节点1加入集合K
        int newP = 1;//集合K中新加入的点为节点1
        for(int i = 1 ; i < n ; i ++)//循环n - 1次，按照最短路径递增的顺序确定其他n - 1个点的最短路径长度
        {
            for(int j = 0 ; j < edge[newP].size() ; j++)//遍历与该新加入集合K中的节点直接相邻的边
            {
                int t = edge[newP][j].next;//该边的下一个节点
                int c = edge[newP][j].c;//该边的权重

                if(mark[t] == true)//若另一个节点也属于集合K，则跳过
                    continue ;

                if(Dis[t] == -1 || Dis[t] > Dis[newP] + c)//若该节点尚不可达或者该节点新加入的节点经过一条边到达时比以往距离更短
                    Dis[t] = Dis[newP] + c;//更新距离信息
            }

            int min = 123123123;//最小值初始化为一个大整数，为找最小值做准备
            for(int j = 1 ; j <= n ; j ++)//遍历所有节点
            {
                if(mark[j] == true)//若其属于集合K，则跳过
                    continue ;
                if(Dis[j] == -1)//若该节点仍不可达，则跳过
                    continue ;
                if(Dis[j] < min)//若该节点经由节点1到集合K的某点在经过一条边到达时距离小于当前最小值
                {
                    min = Dis[j];//更新其为最小值
                    newP = j;//新加入的点，暂定为该节点
                }
            }
            mark[newP] = true;//将新加入的点加入集合K，Dis[newP]虽然数值不变，但意义发生变化，由所有经过集合K中的节点在经过一条边到达时的距离中的最小值变为从节点1到节点newP的最短距离
        }

        printf_s("%d
", Dis[n]);//输出
    }

    return 0;
}

/**
Dijkstra算法流程：
（1）初始化，集合K中加入节点1，节点1到节点1的最短路径为0，到其他节点为无穷（或不确定）；
（2）遍历集合K中与集合K中节点直接相邻的边（U,V,C），其中U属于集合K，V不属于集合K，计算由节点1
出发按照已经得到的最短路到达U，再由U经过该边到达V时的路径长度。比较所有与集合K中节点直接相邻的
非集合K节点该路径长度，其中路径长度最小的节点被确定为下一个最短路径确定的节点，其最短路径长度即为
这个路径长度，最后将该节点加入集合K；
（3）若集合K中已经包含了所有的点，算法结束；否则重复步骤2；

Dijkstra算法注意事项
（1）单源最短路径问题，即只能计算出某个特定节点到其他所有节点的最短路径长度；
（2）支持邻接链表，在节点比较多时，可以使用这种方法

样例输入：
4 6 1
1 2 20
1 3 5
4 1 -200
2 4 4
4 2 4
3 4 2
4 6 1
1 2 2
1 3 5
4 1 10
2 4 4
4 2 4
3 4 2

样例输出：
have negative circles
0
2
5
6
*/


#include <iostream>
using namespace std;
const int maxnum = 100;
const int maxint = 99999;

// 边，
typedef struct Edge{
    int u, v;    // 起点，重点
    int weight;  // 边的权值
}Edge;

Edge edge[maxnum];     // 保存边的值
int  dist[maxnum];     // 结点到源点最小距离

int nodenum, edgenum, source;    // 结点数，边数，源点

// 初始化图
void init()
{
    // 输入结点数，边数，源点
    cin >> nodenum >> edgenum >> source;
    for(int i = 1 ; i <= nodenum ; ++i)
        dist[i] = maxint;
    dist[source] = 0;
    for(int i = 1 ; i <= edgenum ; ++i)
    {
        cin >> edge[i].u >> edge[i].v >> edge[i].weight;//输入边以及权重
        if(edge[i].u == source)          //注意这里设置初始情况
            dist[edge[i].v] = edge[i].weight;
    }
}

// 松弛计算
void relax(int u, int v, int weight)
{
    if(dist[v] > dist[u] + weight)
        dist[v] = dist[u] + weight;
}

bool Bellman_Ford()
{
    for(int i = 1; i <= nodenum - 1; ++i)
        for(int j = 1 ; j <= edgenum ; ++j)
            relax(edge[j].u, edge[j].v, edge[j].weight);
    bool flag = 1;
    // 判断是否有负环路
    for(int i = 1; i <= edgenum; ++i)
        if(dist[edge[i].v] > dist[edge[i].u] + edge[i].weight)
        {
            flag = 0;
            break;
        }
        return flag;
}

int main()
{
    init();

    if(Bellman_Ford())
    {
        for(int i = 1 ;i <= nodenum; i++)
            cout << dist[i] << endl;
    }
    else
        printf_s("have negative circles
");
    return 0;
}