C :

#include <stdio.h>
#include <string.h>
int edge[51][51],isvisited[51],n,m,s,lowcost[51];
void dijkstra(int vo){
	int i,j,min,pre;
	isvisited[vo]=1;
	for (i=0;i<n;i++)
	{
		lowcost[i]=edge[vo][i];

	}
	lowcost[vo]=0;
	pre=vo;
	for (i=1;i<n;i++)
	{
		min=100000000;
		for (j=0;j<n;j++)
		{
			if (isvisited[j]==0&&min>lowcost[j])
			{
				min=lowcost[j];
				pre=j;
			}
		}
		isvisited[pre]=1;
		for (j=0;j<n;j++)
		{
			if (isvisited[j]==0&&lowcost[j]>edge[pre][j]+lowcost[pre])
			{
				lowcost[j]=edge[pre][j]+lowcost[pre];
			}
		}
	}
}
int main(){
	int i,j;
//	freopen("1.txt","r",stdin);
	while (scanf("%d %d",&n,&s)!=EOF)
	{
		memset(isvisited,0,sizeof(isvisited));
		for (i=0;i<n;i++)
		{
			for (j=0;j<n;j++)
			{
				scanf("%d",&edge[i][j]);
				if (edge[i][j]==0)
				{
					edge[i][j]=100000000;
				}
			}
		}
		dijkstra(s);
		for (i=0;i<n;i++)
		{
			if (i!=s)
			{
				if (lowcost[i]==100000000)
				{
					printf("-1 ");
				}else{
					printf("%d ",lowcost[i]);
				}
			}
		}
		printf("\n");
	}
//	fclose(stdin);
	return 0;
}

C++ :

#include <cstdio>
#include <cstdlib>
#include <stack>
#include <algorithm>
using namespace std;
const int MAXN = 50;
const int INF = 1000000000;
int mat[MAXN][MAXN], min_distance[MAXN], v[MAXN];
int n, s;

void dijkstra() {
	int i, j, k;
	for (i = 0; i < n; i++) {
		min_distance[i] = INF;
		v[i] = 0;
	}
	for (min_distance[s] = 0, j = 0; j < n; j++) {
		for (k = -1, i = 0; i < n; i++) {
			if (!v[i] && (k == -1 || min_distance[i] < min_distance[k])) {
				k = i;
			} 
		}
		for (v[k] = 1, i = 0; i < n; i++) {
			if (!v[i] && min_distance[k] + mat[k][i] < min_distance[i]) {
				min_distance[i] = min_distance[k] + mat[k][i];
			} 
		}
	}
}
int main() {
	scanf("%d%d", &n, &s);
	for (int i = 0;i < n;i++) {
		for (int j = 0;j < n;j++) {
			scanf("%d", &mat[i][j]);
			if (mat[i][j] == 0)
				mat[i][j] = INF;
		}
	}
	dijkstra();
	for (int i = 0;i < n;i++) {
		if (i != s) {
			if (min_distance[i] < INF)
				printf("%d ", min_distance[i]);
			else
				printf("%d ", -1);
		}
	}
	puts("");
	return 0;
}

Pascal :

const MAXDATA=1000;
var
 a:array[0..100,0..100] of integer;
 dis:array[0..100] of integer;
 fg:array[0..100] of boolean;
 n,s,i,j,min:integer;

function remin(a,b:integer):integer;
begin
 if a<b then exit(a) else exit(b);
end;

procedure dijkstra(s:integer);
var
 i,j,k:integer;
begin
 for i:=0 to n do
  begin
   fg[s]:=true;
   for j:=0 to n do
    begin
     if (a[s,j]<>0) and (fg[j]=false) then
      dis[j]:=remin(dis[j],dis[s]+a[s,j]);
    end;

   //writeln('xxxx');
   min:=MAXDATA;
  for k:=0 to n do
   for j:=0 to n do
    if(a[k,j]<>0) and (fg[j]=false) then
     if min>dis[j] then
      begin
       min:=dis[j];
       s:=j;
      end;
  end;

end;

procedure output;
var
 i:integer;
begin
 for i:=0 to n do
  if i<>s then
   if dis[i]=MAXDATA then write('-1 ') else write(dis[i],' ');
end;

begin
 readln(n,s);
 dec(n);
 for i:=0 to n do
  for j:=0 to n do
   read(a[i,j]);

 fillchar(fg,sizeof(fg),false);
 for i:=0 to n do dis[i]:=MAXDATA;
 dis[s]:=0;
 dijkstra(s);
 output;
 //writeln('wwwwww');
end.

Java :

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
 
public class Main {
    static class Node{
        public Node(int v,int w) {
            this.v=v;
            this.w=w;
        }
        int v;
        int w;
    }
    static class R{
        public R(int vertex) {
            this.vertex=vertex;
            this.distance=Integer.MAX_VALUE;
        }
        int vertex;
        int distance;
        int number;
        int people;
    }
    static Comparator<R> com=new Comparator<R>() {
 
        @Override
        public int compare(R o1, R o2) {
            return o1.distance-o2.distance;
        }
         
    };
    static Scanner scn=new Scanner(System.in);
    static int vertex=scn.nextInt(),start=scn.nextInt();
    static List<List<Node>> G=new ArrayList<>();
    static boolean[] visit=new boolean[vertex];
    static R[] form=new R[vertex];
    static Queue<R> pri=new PriorityQueue<>(com);
    public static void main(String[] args) {
//      初始化
        for(int i=0;i<vertex;i++) {
            G.add(new ArrayList<>());
            form[i]=new R(i);
        }
//      创建图
        for(int i=0;i<vertex;i++) {
            for(int j=0;j<vertex;j++) {
                int w=scn.nextInt();
                G.get(i).add(new Node(j, w));
            }
        }
        dijstra(start);
        for(int i=0;i<vertex;i++) {
            if(i!=start) {
                if(form[i].distance!=Integer.MAX_VALUE) {
                    System.out.print(form[i].distance+" ");
                }else {
                    System.out.print("-1 ");
                }
            }
        }
        System.out.println();
    }
    static void dijstra(int start) {
        form[start].distance=0;
        pri.offer(form[start]);
        for(int i=0;i<vertex;i++) {
            int u=pri.poll().vertex;
            visit[u]=true;
            for(int j=0;j<G.get(u).size();j++) {
                int v=G.get(u).get(j).v;
                int w=G.get(u).get(j).w;
                if(G.get(u).get(j).w!=0 &&!visit[v] && form[u].distance+w<form[v].distance) {
                    form[v].distance=form[u].distance+w;
                    form[v].number=form[u].number;
                    pri.offer(form[v]);
                }
            }
        }
    }
}