【算法概论】贪心策略：Dijkstra算法

问题描述：

       迪杰斯特拉算法，用于计算一个顶点到其他结点的最短路径。

❗算法描述❗：

       主要特点是以起始点为中心向外层层扩展（广度优先搜索思想），直到扩展到终点为止。

       1、通过 Dijkstra 计算图 G 中的最短路径时，需要指定起点 s（即从顶点 s 开始计算）。

       2、此外，引进两个集合 S 和 U 。S 的作用是记录已求出最短路径的顶点（以及相应的最短路径长度），而 U 则是记录还未求出最短路径的顶点（以及该顶点到起点 s 的距离）。

      3、 初始时，S 中只有起点 s ，U 中是除 s 之外的顶点，并且 U 中顶点的路径是“起点 s 到该顶点的路径”。然后，从 U 中找出路径最短的顶点，并将其加入到 S 中；接着，更新 U 中的顶点和顶点对应的路径。 然后，再从 U 中找出路径最短的顶点，并将其加入到 S 中；接着，更新 U 中的顶点和顶点对应的路径。 … 重复该操作，直到遍历完所有顶点。

操作步骤：

       1、初始时，S 只包含起点 s ，U 包含除 s 外的其他顶点，且 U 中顶点的距离为“起点 s 到该顶点的距离”（例如，U 中顶点 v 的距离为(s,v)的长度，然后 s 和 v 不相邻，则 v 的距离为∞）。

       2、从 U 中选出“距离最短的顶点 k”，并将顶点 k 加入到 S 中，同时，从 U 中移除顶点 k。

       3、更新 U 中各个顶点到起点 s 的距离。之所以更新 U 中顶点的距离，是由于上一步中确定了 k 是求出最短路径的顶点，从而可以利用 k 来更新其它顶点的距离；例如，(s, v)的距离可能大于(s, k)+(k, v)的距离。

       4、重复步骤(2)和(3)，直到遍历完所有顶点。

以第4个顶点D为起点，对迪杰斯特拉进行算法演示

代码✍：

// 邻接矩阵
typedef struct _graph
{
    char vexs[MAX];       // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int matrix[MAX][MAX]; // 邻接矩阵
}Graph, *PGraph;

// 边的结构体
typedef struct _EdgeData
{
    char start; // 边的起点
    char end;   // 边的终点
    int weight; // 边的权重
}EData;

       Graph 是邻接矩阵对应的结构体。 
       vexs 用于保存顶点，vexnum 是顶点数，edgnum 是边数，matrix 则是用于保存矩阵信息的二维数组。 
       例如，matrix[i][j] = 1表示”顶点 i（即 vexs[i]）”和”顶点 j（即 vexs[j]）”是邻接点，matrix[i][j] = 0则表示它们不是邻接点。 
       EData 是邻接矩阵边对应的结构体。

/*
 * Dijkstra最短路径。
 * 即，统计图(G)中"顶点vs"到其它各个顶点的最短路径。
 *
 * 参数说明：
 *        G -- 图
 *       vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
 *     prev -- 前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
 *     dist -- 长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
 */
void dijkstra(Graph G, int vs, int prev[], int dist[])
{
    int i,j,k;
    int min;
    int tmp;
    int flag[MAX];      // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。

    // 初始化
    for (i = 0; i < G.vexnum; i++)
    {
        flag[i] = 0;              // 顶点i的最短路径还没获取到。
        prev[i] = 0;              // 顶点i的前驱顶点为0。
        dist[i] = G.matrix[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
    }

    // 对"顶点vs"自身进行初始化
    flag[vs] = 1;
    dist[vs] = 0;

    // 遍历G.vexnum-1次；每次找出一个顶点的最短路径。
    for (i = 1; i < G.vexnum; i++)
    {
        // 寻找当前最小的路径；
        // 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
        min = INF;
        for (j = 0; j < G.vexnum; j++)
        {
            if (flag[j]==0 && dist[j]<min)
            {
                min = dist[j];
                k = j;
            }
        }
        // 标记"顶点k"为已经获取到最短路径
        flag[k] = 1;

        // 修正当前最短路径和前驱顶点
        // 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
        for (j = 0; j < G.vexnum; j++)
        {
            tmp = (G.matrix[k][j]==INF ? INF : (min + G.matrix[k][j])); // 防止溢出
            if (flag[j] == 0 && (tmp  < dist[j]) )
            {
                dist[j] = tmp;
                prev[j] = k;
            }
        }
    }

    // 打印dijkstra最短路径的结果
    printf("dijkstra(%c): \n", G.vexs[vs]);
    for (i = 0; i < G.vexnum; i++)
        printf("  shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
}

转载自：https://blog.youkuaiyun.com/heroacool/article/details/51014824

---

 

/*
迪杰斯特拉求单节点到其余各节点的最短路径。
visited数组用于保存顶点是否已经求过最短路径，pre数组用于保存最短路径的下标
dist数组用于保存初始节点到其余节点的最短路径长度。
该算法求有向图G的某顶点到其余节点的最短路径pre以及长度dist
pre[v]的值是v0-->...->v的路径中的前驱节点。D[v]表示v0-->...-->v的最短路径长度和。

可以证明迪杰斯特拉算法每次循环可以确定一个顶点的最短路径，所以主程序循环n-1次。
主程序循环主要做两件事：首先找出dist数组中的最小值，并记录下标，说明找到初始点到该下标的最短路径。
然后要比价初始点到该点的最短路径加上这点到其他初始点需要到的点的距离是否比初始点直接到这些点的距离短
如果要短，那么就更新dist数组，并且这些点的前驱节点就会变为v而不是开始的v0点。下一次主循环再去从dist中找
最小的值并且未求过的点，就是该点的最短路径。
*/
#include<iostream>
using namespace std;
int matrix[100][100];//邻接矩阵
bool visited[100];//标记数组
int dist[100];//原点到i顶点的最短距离
int pre[100];//记录最短路径。pre[i]放的是i的前驱节点
int source;//源节点
int vertex_num;//顶点数
int edge_num;//边数

void Dijkstra(int source)
{
    //首先初始化
    memset(visited,0,sizeof(visited));
    visited[source] = true;
    for (int i = 0; i < vertex_num; i++)
    {
        dist[i] = matrix[source][i];
        pre[i] = source;
    }

    int min_cost;//最短距离
    int min_cost_index;//权值最小的那个顶点的下标。（求好了）
    //主循环
    for (int i = 1; i < vertex_num; i++)
    {
        min_cost = INT_MAX;
        for (int j = 0; j < vertex_num; j++)
        {
            //注意要确保这个点没有找过。
            if (visited[j]==false&&dist[j] < min_cost)
            {
                min_cost_index = j;
                min_cost = dist[j];
            }
        }

        visited[min_cost_index] = true;//找到某一个点的最短距离
        //利用该点进行dist的更新，并且调整前驱。
        for (int j = 0; j < vertex_num; j++)
        {
            //确保有连接
            if (visited[j] == false && matrix[min_cost_index][j] != INT_MAX&&min_cost+ matrix[min_cost_index][j] < dist[j])
            {
                dist[j] = min_cost + matrix[min_cost_index][j];
                pre[j] = min_cost_index;
            }
        }
    }
}

int main()
{
    cout << "请输入图的顶点数（<100）:";
    cin >> vertex_num;
    cout << "请输出图的边数: ";
    cin >> edge_num;
    for (int i = 0; i < vertex_num; i++)
    {
        for (int j = 0; j < vertex_num; j++)
        {
            matrix[i][j] = (i != j) ? INT_MAX : 0;
        }
    }
    cout << "请输入边的信息：\n";
    int u, v, w;
    for (int i = 0; i < edge_num; i++)
    {
        cin >> u >> v >> w;
        matrix[u][v] = matrix[v][u] = w;
    }

    cout << "请输入源点(<" << vertex_num << "): ";
    cin >> source;
    Dijkstra(source);
    for (int i = 0; i < vertex_num; i++)
    {
        if (i != source)
        {
            //路径是反的，从目标点向前不断找前驱的过程。
            cout << source << "到" << i << "最短距离： " << dist[i] << ",路径是：" << i;
            int t = pre[i];
            while (t != source)
            {
                cout << "--" << t;
                t = pre[t];
            }
            cout << "--" << source << endl;
        }
    }
    return 0;
}