Varios lenguaje algoritmo de Dijkstra (reproducido)

Explicar en detalle: dejar una posición inmediatamente a

implementación de Python

bloggers CSDN chenxing_ para reimprimir el " algoritmo de Dijkstra pitón lograr " en: https: //blog.csdn.net/chenxing_/article/details/80904016

MAX_value = 999999
 
 
def dijkstra(graph, s):
    # 判断图是否为空，如果为空直接退出
    if graph is None:
        return None
    dist = [MAX_value]*len(graph)
    dist[s] = 0
    S = []
    Q = [i for i in range(len(graph))]
    dist_init = [i for i in graph[s]]
    while Q:
        u_dist = min([d for v, d in enumerate(dist_init) if v in Q])
        u = dist_init.index(u_dist)
 
        S.append(u)
        Q.remove(u)
 
        for v, d in enumerate(graph[u]):
            if 0 < d < MAX_value:
                if dist[v] > dist[u]+d:
                    dist[v] = dist[u]+d
                    dist_init[v] = dist[v]
    return dist
 
 
if __name__ == '__main__':
    graph_list = [ [0, 9, MAX_value, MAX_value, MAX_value, 14,15,MAX_value],
                    [9, 0, 24, MAX_value, MAX_value, MAX_value,MAX_value,MAX_value],
                    [MAX_value, 24, 0, 6, 2, 18,MAX_value,19],
                    [MAX_value, MAX_value, 6, 0, 11,MAX_value,MAX_value, 6],
                    [MAX_value,MAX_value, 2, 11, 0, 30,20, 16],
                    [14,MAX_value,18,MAX_value,30,0,5,MAX_value],
                    [15,MAX_value,MAX_value,MAX_value,20,5,0,44],
                    [MAX_value,MAX_value,19,6,16,MAX_value,44,0]]
 
    distance = dijkstra(graph_list, 0)
    print(distance)

aplicación JAVA

CSDN a los bloggers de la reimpresión de charilin " el algoritmo Dijkstra de Java para lograr " en: https: //blog.csdn.net/weixin_43806015/article/details/84551023

package suanfa;

public class dijkstra {

	public static void main(String[] args) {
      
		char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
		final int INF = Integer.MAX_VALUE;
		int matrix[][] = {	
				/*A*//*B*//*C*//*D*//*E*//*F*//*G*/
		 /*A*/ {   0,  12, INF, INF, INF,  16,  14},
		 /*B*/ {  12,   0,  10, INF, INF,   7, INF},
		 /*C*/ { INF,  10,   0,   3,   5,   6, INF},
		 /*D*/ { INF, INF,   3,   0,   4, INF, INF},
		 /*E*/ { INF, INF,   5,   4,   0,   2,   8},
		 /*F*/ {  16,   7,   6, INF,   2,   0,   9},
		 /*G*/ {  14, INF, INF, INF,   8,   9,   0}};
		matrixUDG mu = new matrixUDG(vexs, matrix);
		mu.start(3);
		
	}
}

class matrixUDG {
	final int INF = Integer.MAX_VALUE; 
	int numNodes;
	int[][] matrix;
	int[] prev ; 
	int[] dist ; 
	char[] vexs;
	//初始化图参数
	public  matrixUDG (char[] vexs, int[][] matrix) {
		this.vexs = vexs;
		this.matrix = matrix;
		numNodes = vexs.length;
		prev = new int[numNodes];
		dist = new int[numNodes];
	}
	
	// 核心代码！！！！
	// 包括三个数组 1.prev（包含当前节点的上一个父类节点） 2.dist（当前节点与原始节点的距离） 
		//					   3.原始矩阵matrix[][],储存图           4.isVisited[]标记数组
	public void start(int vs) {
		
		
		//初始化类参数
		boolean[] isVisited = new boolean[numNodes ];
		for (int i = 0; i < isVisited.length; i++) {
			dist[i] = matrix[vs][i];
			prev[i] = -1;
			if(dist[i] != INF) {
				prev[i] = vs;
			}
		}
		isVisited[vs] = true;
		//两次循环
		for (int i = 0; i < isVisited.length; i++) {
			int min = INF;
			int k = 0;
			//找到最近的节点
			for (int j = 0; j < isVisited.length; j++) {
				if(!isVisited[j] && dist[j] < min ) {
					min = dist[j];
					k = j;
				}
			}
			
			isVisited[k] = true;
			//更新最近路径和父节点
			for (int j = 0; j < isVisited.length; j++) {
				
				if(!isVisited[j] && matrix[k][j] != INF) {
					if(dist[j] > matrix[k][j] + dist[k]) {
						dist[j] =  matrix[k][j] + dist[k] ;
						prev[j] = k;
					}
					
				}
			}

		
		
		}
		//打印节点、路径、距离
		for (int i = 0; i < isVisited.length; i++) {
			System.out.print( "节点" + i + "  " );
			int a = i;
			System.out.print("路径：");
			
			while (a != vs) {
				System.out.print(   prev[a] +"  ");
				a = prev[a];
			}

			System.out.println("距离" + dist[i]);
		}
		
	}
	
}

aplicación C ++

CSDN blogger Li indiferente " algoritmo de Dijkstra (c ++ versión) ", disponible en: https: //blog.csdn.net/qq_39630587/article/details/83240036

#include <iostream>
using namespace std;
void dijkstra();
int e[10][10];
int vis[10];
int dis[10];
int n, m;
int min1 = 99999999;
int u = 0;
int main()
{
    cin >> n >> m;
    // 初始化邻接表
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (i == j)
            {
                e[i][j] = 0;
            }
            else
            {
                e[i][j] = 99999999;
            }
        }
    }
    // 填充数据
    for (int i = 1; i <= m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        e[a][b] = c;
    }
    for (int i = 1; i <= n; i++)
    {
        dis[i] = e[1][i];
    }
    vis[1] = 1;

    dijkstra();

    for (int i = 1; i <= n; i++)
    {
        cout << dis[i];
    }

    system("pause");
    return 0;
}
void dijkstra()
{
    for (int i = 1; i <= n - 1; i++)
    {
        min1 = 99999999;
        // 寻找权值最小的点u
        for (int j = 1; j <= n; j++)
        {
            if (vis[j] == 0 && dis[j] < min1)
            {
                min1 = dis[j];
                u = j;
            }
        }

        vis[u] = 1;

        for (int v = 1; v <= n; v++)
        {
            // 对于每个u可达的v来说
            if (e[u][v] < 99999999)
            {
                // 如果当前的dis[v]不满足三角形不等式，那么进行松弛操作
                if (dis[v] > dis[u] + e[u][v])
                {
                    dis[v] = dis[u] + e[u][v];
                }
            }
        }
    }
}