Go: // Warshall–Floyd Algorithm

package main

import (
	"bufio"
	"os"
	"strings"
	"strconv"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

const INF = 0x7FFFFFFF

func main() {
	for scanner.Scan() {
		buf := strings.Split(scanner.Text(), " ")
		n, _ := strconv.Atoi(buf[0])
		m, _ := strconv.Atoi(buf[1])
		if n == 0 && m == 0 {
			break
		}
		c_matrix := make([][]int, m)
		for i := range c_matrix {
			c_matrix[i] = make([]int, m)
		}
		t_matrix := make([][]int, m)
		for i := range t_matrix {
			t_matrix[i] = make([]int, m)
		}
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf_ := strings.Split(scanner.Text(), " ")
			a, _ := strconv.Atoi(buf_[0])
			b, _ := strconv.Atoi(buf_[1])
			c, _ := strconv.Atoi(buf_[2])
			t, _ := strconv.Atoi(buf_[3])
			c_matrix[a-1][b-1] = c
			t_matrix[a-1][b-1] = t
		}
		c_dist := make([][]int, m)
		c_prev := make([][]int, m)
		t_dist := make([][]int, m)
		t_prev := make([][]int, m)
		for i := 0; i < m; i++ {
			c_dist[i] = make([]int, m)
			c_prev[i] = make([]int, m)
			t_dist[i] = make([]int, m)
			t_prev[i] = make([]int, m)
		}
		for i := 0; i < m; i++ {
			for j := 0; j < m; j++ {
				if c_matrix[i][j] == 0{
					c_dist[i][j] = INF
				} else {
					c_dist[i][j] = c_matrix[i][j]
				}
				if c_matrix[i][j] == 0{
					c_prev[i][j] = -1
				} else {
					c_prev[i][j] = i
				}
				if t_matrix[i][j] == 0{
					t_dist[i][j] = INF
				} else {
					t_dist[i][j] = t_matrix[i][j]
				}
				if t_matrix[i][j] == 0{
					t_prev[i][j] = -1
				} else {
					t_prev[i][j] = i
				}
			}
			c_dist[i][i] = 0
			t_dist[i][i] = 0
		}
		for k := 0; k < m; k++ {
			for i := 0; i < m; i++ {
				for j := 0; j < m; j++ {
					c_newlen := c_dist[i][k] + c_dist[k][j]
					t_newlen := t_dist[i][k] + t_dist[k][j]
					if c_newlen < c_dist[i][j] {
						c_dist[i][j] = c_newlen
						c_prev[i][j] = c_prev[k][j]
					}
					if t_newlen < t_dist[i][j] {
						t_dist[i][j] = t_newlen
						t_prev[i][j] = t_prev[k][j]
					}
				}
			}
		}
		scanner.Scan()
		k, _ := strconv.Atoi(scanner.Text())
		for i := 0; i < k; i++ {
			scanner.Scan()
			buf_ := strings.Split(scanner.Text(), " ")
			p, _ := strconv.Atoi(buf_[0])
			q, _ := strconv.Atoi(buf_[1])
			r, _ := strconv.Atoi(buf_[2])
			switch r {
			case 0: fmt.Println(c_dist[p-1][q-1])
			case 1: fmt.Println(t_dist[p-1][q-1])
			}
		}
	}
}

C++: #include <array>
#include <iostream>
using namespace std;
 
array<array<int, 210>, 210> costs;
array<array<int, 210>, 210> times;
 
int main() {
    int n, m;
    while (cin >> n >> m, n || m) {
        for (auto& ar : costs) ar.fill(1000000);
        for (auto& ar : times) ar.fill(1000000);
        for (int i = 0; i < n; i++) {
            int a, b, c, t;
            cin >> a >> b >> c >> t;
            a--; b--;
            costs[a][b] = costs[b][a] = c;
            times[a][b] = times[b][a] = t;
        }
        for (int i = 0; i < m; i++) {
            costs[i][i] = 0;
            times[i][i] = 0;
        }
 
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                for (int k = 0; k < m; k++) {
                    costs[j][k] = min(costs[j][k], costs[j][i] + costs[i][k]);
                    times[j][k] = min(times[j][k], times[j][i] + times[i][k]);
                }
            }
        }
        int k;
        cin >> k;
        for (int i = 0; i < k; i++) {
            int p, q, r;
            cin >> p >> q >> r;
            p--; q--;
            if (r == 0) {
                cout << costs[p][q] << endl;
            }
            else {
                cout << times[p][q] << endl;
            }
        }
    }
    return 0;
}

C++: #include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 100
#define MAX_M 3000
#define NUMBER_OF_NODES 10000

#define SWAP(type, a, b) do {type _tmp; _tmp = a; a = b; b = _tmp;} while(0)

typedef struct {
	int v;
	int dist;
} state;

bool greater(state a, state b) {
	return a.dist > b.dist;
}

// priority_queue
typedef state value_type;

typedef struct skew_heap{
	struct skew_heap *left, *right;
	value_type value;
} skew_heap;

skew_heap *meld(skew_heap *a, skew_heap *b) {
	if(a == NULL) return b;
	if(b == NULL) return a;
	if(greater(a->value, b->value)) SWAP(skew_heap *, a, b);
	a->right = meld(a->right, b);
	SWAP(skew_heap *, a->left, a->right);
}

int next_index = 0;
skew_heap nodes[NUMBER_OF_NODES];
skew_heap *root = NULL;

bool empty() {
	return root == NULL;
}

void enqueue(value_type value) {
	skew_heap *new_node = (nodes + next_index);
	next_index = (next_index + 1) % NUMBER_OF_NODES;
	new_node->left = NULL;
	new_node->right = NULL;
	new_node->value = value;
	root = meld(root, new_node);
}

value_type dequeue() {
	if(root == NULL) return (value_type){-1, -1};
	value_type res = root->value;
	root = meld(root->left, root->right);
	return res;
}

void clear() {
	root = NULL;
}

// graph
int n, m;
int num;
int head[MAX_N], next[MAX_M * 2], to[MAX_M * 2];
int costs[MAX_M * 2], times[MAX_M * 2];
int dist[MAX_N];

void init() {
	num = 0;
	memset(head, -1, sizeof(head));
}

void add_edge(int u, int v, int c, int t) {
	next[num] = head[u];
	head[u] = num;
	to[num] = v;
	costs[num] = c;
	times[num] = t;
	++num;
}

// calc dist
int dijkstra(int start, int goal, int r) {
	int i, e;
	const int *weight = (r ? times : costs);

	for(i = 0; i < n; ++i) dist[i] = INT_MAX;
	dist[start] = 0;
	clear();
	enqueue((state){start, 0});

	while(!empty()) {
		state current = dequeue();
		if(dist[current.v] < current.dist)
			continue;

		if(current.v == goal)
			return dist[goal];

		for(e = head[current.v]; e != -1; e = next[e]) {
			int next_dist = current.dist + weight[e];
			if(dist[to[e]] > next_dist) {
				dist[to[e]] = next_dist;
				enqueue((state){to[e], next_dist});
			}
		}
	}
	assert(false);
}

int main(void) {
	int i;
	while(scanf("%d%d", &m, &n) == 2 && n) {
		init();
		for(i = 0; i < m; ++i) {
			int u, v, c, t;
			scanf("%d%d%d%d", &u, &v, &c, &t);
			--u; --v;
			add_edge(u, v, c, t);
			add_edge(v, u, c, t);
		}

		int query;
		scanf("%d", &query);

		while(query--) {
			int start, goal, r;
			scanf("%d%d%d", &start, &goal, &r);
			printf("%d\n", dijkstra(start - 1, goal - 1, r));
		}
	}
	return EXIT_SUCCESS;
}

C++: #include<iostream>

int n, m, a, b, k, p, q, r, *ans;
int **w[2],**d[2],**pre_vertex[2];

void solve(){
	for(int z=0; z<2; z++){
		for(int i=0; i<m; i++){
			for(int j=0; j<m; j++){
				d[z][i][j] = w[z][i][j];
				pre_vertex[z][i][j] = i;
			}
		}
		for(int i=0; i<m; i++){
			for(int j=0; j<m; j++){
				for(int l=0; l<m; l++){
					int dis = d[z][i][l]+d[z][l][j];
					if(dis<d[z][i][j]){
						d[z][i][j] = dis;
						pre_vertex[z][i][j] = pre_vertex[z][l][j];
					}
				}
			}
		}
	}
}

int main(){
	while(true){
		std::cin >> n >> m;
		if(!n && !m)
			return 0;
		for(int l=0; l<2; l++){
			w[l] = new int*[m];
			d[l] = new int*[m];
			pre_vertex[l] = new int*[m];
			for(int i=0; i<m; i++){
				w[l][i] = new int[m];
				d[l][i] = new int[m];
				pre_vertex[l][i] = new int[m];
				for(int j=0; j<m; j++)
					w[l][i][j] = 1000000000;
			}
		}
		for(int i=0; i<n; i++){
			std::cin >> a >> b;
			std::cin >> w[0][a-1][b-1] >> w[1][a-1][b-1];
			w[0][b-1][a-1] = w[0][a-1][b-1];
			w[1][b-1][a-1] = w[1][a-1][b-1];
		}
		solve();
		std::cin >> k;
		ans = new int[k];
		for(int i=0; i<k; i++){
			std::cin >> p >> q >> r;
			ans[i] = d[r][p-1][q-1];
		}
		for(int i=0; i<k; i++)
			std::cout << ans[i] << std::endl;
		for(int i=0; i<2; i++){
			for(int j=0; j<m; j++){
				delete[] w[i][j];
				delete[] d[i][j];
				delete[] pre_vertex[i][j];
			}
			delete[] w[i];
			delete[] d[i];
			delete[] pre_vertex[i];
		}
		delete[] ans;
	}
}