Dijkstra 算法的实现（算法笔记）

算法笔记：

 1) Dijkstra 算法的伪代码：

/**
    1) Dijkstra 算法的伪代码：
    void Dijkstra(G,d[],s)
    {
        初始化：
        for(循环 n 次)
        {
            u=使d[u] 最小的还未被访问的顶点的标号；
            记u为已被访问；
            for(从u 出发能达到的所有顶点)
            {
                if(v未被访问 && 以u为中介点使s到达v能使d[v]更优)
                    优化d[v];
            }
        }
    }

*/

2) Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

/**
    2) Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

    const int maxn = 1010;
    const int INF = 0x3fffffff;

    int Nv,G[maxn][maxn]; //Nv 是顶点数 ，G是邻接矩阵；
    int d[maxn]; //起点到达终点的最短路径长度
    bool hs[maxn] = {false};

    void Dijkstra(int s)
    {
        fill(d,d+maxn,INF); //初始化数组d；
        d[s] = 0; // 起点到达终点的距离；
        for(int i=0;i

3) Dijkstra 算法的邻接表实现：
        时间复杂度：O(V^2 + E);

/**
    3) Dijkstra 算法的邻接表实现：
        时间复杂度：O(V^2 + E);

    struct GNode
    {
        int v, dis; //v 为边的目标顶点，dis为边权
    }
    const int maxn = 1010;
    const int INF = 0x3fffffff;

    int Nv; //Nv 是顶点数 ，G是邻接矩阵；
    vector Adj[maxn];  //邻接表
    int d[maxn]; //起点到达终点的最短路径长度
    bool hs[maxn] = {false}; //标记数组

    void Dijkstra(int s)
    {
        fill(d,d+maxn,INF); //初始化数组d；
        d[s] = 0; // 起点到达终点的距离；
        for(int i=0;i

4) Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

       如果要找出一条最短路径，并打印出这条路径该走的顶点编号，那么可以用一个 pre[maxn] 数组来存储；
       只需要在（2） 的基础上添加两个语句便可；

/**
    4) Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

       如果要找出一条最短路径，并打印出这条路径该走的顶点编号，那么可以用一个 pre[maxn] 数组来存储；
       只需要在（2） 的基础上添加两个语句便可；

    const int maxn = 1010;
    const int INF = 0x3fffffff;

    int Nv,G[maxn][maxn]; //Nv 是顶点数 ，G是邻接矩阵；
    int d[maxn]; //起点到达终点的最短路径长度
    int pre[maxn]; //pre[v]表示从起点到v的路径上前驱顶点的编号； （新添加）
    bool hs[maxn] = {false};

    void Dijkstra(int s)
    {
        fill(d,d+maxn,INF); //初始化数组d；
        memset(pre,-1,sizeof(pre) ); // 初始化pre数组；（新添加）
        d[s] = 0; // 起点到达终点的距离；
        for(int i=0;i

5) 在找出起点到终点的距离最近的同时，也要使得起点到终点的边的权值之和最小，
       假定新增了边的权值（不只是距离）；

        Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

/**
    5) 在找出起点到终点的距离最近的同时，也要使得起点到终点的边的权值之和最小，
       假定新增了边的权值（不只是距离）；

        Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

    const int maxn = 1010;
    const int INF = 0x3fffffff;

    int Nv,G[maxn][maxn]; //Nv 是顶点数 ，G是邻接矩阵；
    int d[maxn]; //起点到达终点的最短路径长度
    int c[maxn]; // 起点到终点的最小消耗（花费）；
    bool hs[maxn] = {false}; //顶点是否被选择；

    void Dijkstra(int s)
    {
        fill(d,d+maxn,INF); //初始化数组d；
        d[s] = 0; // 起点到达终点的距离；
        fill(c,c+maxn,INF); //求最小花费的时候，还是最好把花费数组初始化为INF;
        c[st] = 0; // 起点的花费为0

        for(int i=0;i

6) 在找出起点到终点的距离最近的同时，也要使得起点到终点的点的权值之和最大，
       假定新增了顶点的权值；

        Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

/**
    6) 在找出起点到终点的距离最近的同时，也要使得起点到终点的点的权值之和最大，
       假定新增了顶点的权值；

        Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

    const int maxn = 1010;
    const int INF = 0x3fffffff;

    int Nv,G[maxn][maxn]; //Nv 是顶点数 ，G是邻接矩阵；
    int weight[maxn]; //顶点的权值；
    int d[maxn]; //起点到达终点的最短路径长度
    int w[maxn]; // 起点到终点的最大筹集物资；
    bool hs[maxn] = {false}; //顶点是否被选择；

    void Dijkstra(int s)
    {
        fill(d,d+maxn,INF); //初始化数组d；
        d[s] = 0; // 起点到达终点的距离；
        w[s] = weight[s];

        for(int i=0;i w[v]) //最短距离相同时看是否能使w[v]更优
                        w[v] = w[u] + weight[v];
                }
            }
        }
    }

*/

7) 在找出起点到终点的距离最近的同时，要求出最短路径条数；

        Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

/**
    7) 在找出起点到终点的距离最近的同时，要求出最短路径条数；

        Dijkstra 算法的邻接矩阵实现：
        时间复杂度：O(V*(V+V) = O(V^2);

    const int maxn = 1010;
    const int INF = 0x3fffffff;

    int Nv,G[maxn][maxn]; //Nv 是顶点数 ，G是邻接矩阵；
    int d[maxn]; //起点到达终点的最短路径长度
    int num[maxn]; // 最短路径条数
    bool hs[maxn] = {false}; //顶点是否被选择；

    void Dijkstra(int s)
    {
        fill(d,d+maxn,INF); //初始化数组d；
        d[s] = 0; // 起点到达终点的距离；
        num[s] = 1;

        for(int i=0;i