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 <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
	int a, b, time, cost, querys;
	int i, j, k, l, p, q, r, n, m;
	int times[100][100], costs[100][100], temp[100][100];

	while (true) {
		cin >> n >> m;
		if (!n && !m)
			break;

		for (i = 0; i < m; i++) {
			for (j = 0; j < m; j++) {
				times[i][j] = (i == j) ? 0 : 1e9;
				costs[i][j] = (i == j) ? 0 : 1e9;
			}
		}

		for (i = 0; i < n; i++) {
			cin >> a >> b >> cost >> time;
			times[a - 1][b - 1] = time;
			costs[a - 1][b - 1] = cost;
		}

		cin >> querys;
		for (l = 0; l < querys; l++) {
			cin >> p >> q >> r;

			for (i = 0; i < m; i++)
				for (j = 0; j < m; j++)
					temp[i][j] = r ? times[i][j] : costs[i][j];

			for (k = 0; k < m; k++)
				for (i = 0; i < m; i++)
					for (j = 0; j < m; j++)
						temp[i][j] = min(temp[i][j], temp[i][k] + temp[k][j]);

			cout << temp[p - 1][q - 1] << endl;
		}
	}
}

C++: #include <iostream>
using namespace std;

#define STAT_MAX 100
#define LINE_MAX 3000

struct LINE {
	int to;
	int cost[2];	//0:money 1:time
};
struct STAT {
	int lineNum;
	LINE line[LINE_MAX];
};

struct YET {
	int id,depth,cost;
};
struct SEARCHED {
	int id,total;
};

int main(){
	int n,m;	//?????°
	int a,b,cost,time;	//??????
	int start,goal,flg;	//???????????????
	int i,j;
	
	int statNum;
	STAT stat[STAT_MAX];

	int result;
	int yetNum;
	YET yet[STAT_MAX],now;
	int searchedNum;
	SEARCHED searched[STAT_MAX];

	while(1){
		//?????°??\???
		cin>>n>>m;if(!n && !m) break;
		//???????????????
		statNum=m;
		for(i=0;i<statNum;i++) stat[i].lineNum=0;
		while(n--){
			cin>>a>>b>>cost>>time;
			a--;b--;
			stat[a].line[stat[a].lineNum].to=b;
			stat[a].line[stat[a].lineNum].cost[0]=cost;
			stat[a].line[stat[a].lineNum].cost[1]=time;
			stat[a].lineNum++;
			stat[b].line[stat[b].lineNum].to=b;
			stat[b].line[stat[b].lineNum].cost[0]=cost;
			stat[b].line[stat[b].lineNum].cost[1]=time;
			stat[b].lineNum++;
		}
		//????????????????????????
		cin>>n;
		while(n--){
			cin>>start>>goal>>flg;
			start--;goal--;
			result=-1;searchedNum=0;
			yetNum=1;yet[0].id=start;yet[0].depth=0;yet[0].cost=0;
			while(yetNum){
				now=yet[--yetNum];
				searched[searchedNum].id=now.id;
				searched[searchedNum].total=(searchedNum!=0)?searched[searchedNum-1].total+now.cost:now.cost;
				searchedNum++;
				if(now.id==goal){
					if(result!=-1 || searched[searchedNum].total<result) result=searched[searchedNum].total;
					if(yetNum!=0) searchedNum=yet[yetNum-1].depth;
				}else{
					m=yetNum;	//?????????????????¢?´¢?§??????°?????????
					for(i=0;i<stat[now.id].lineNum;i++){
						//??¢?´¢???????????????????????§??????
						for(j=0;j<searchedNum;j++){
							if(stat[now.id].line[i].to==searched[j].id) break;
						}
						if(j!=searchedNum) continue;
						//?§??????±???yet??????????????\
						yet[yetNum].id=stat[now.id].line[i].to;
						yet[yetNum].depth=now.depth+1;
						yet[yetNum].cost=stat[now.id].line[i].cost[flg];
						yetNum++;
					}
					//????´¢??????????????????????????????????????????
					if(m==yetNum && yetNum!=0) searchedNum=yet[yetNum-1].depth;
				}
			}
		}
		cout<<result<<endl;
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>

#define INF = INT_MAX / 2
#define REP(i, m, n) for(int i = m; i < static_cast<int>(n); ++i)
int main()
{
    int line_num, station_num;
    
    while (std::cin >> line_num >> station_num) {
        
        if (line_num == 0 && station_num == 0) break;

        int map[2][101][101];
        
        REP(i, 0, 2) REP(j, 0, 101) REP(k, 0, 101) map[i][j][k] = 999999;
        
        REP(i, 0, line_num) {
            int a, b, cost, time;
            std::cin >> a >> b >> cost >> time;
            map[0][a][b] = map[0][b][a] = cost;
            map[1][a][b] = map[1][b][a] = time;
        }
        
        REP(l, 0, 2) {
            REP(i, 1, station_num + 1) {
                REP(j, 1, station_num + 1) {
                    REP(k, 1, station_num + 1) {
                        map[l][i][j] = std::min(map[l][i][j], map[l][i][k] +
                                                map[l][k][j]);
                    }
                }
            }
        }

        int input_num;

        std::cin >> input_num;

        REP(i, 0, input_num) {
            int p, q, r;

            std::cin >> p >> q >> r;
            std::cout << map[r][p][q] << std::endl;
        }
    
    }
    return 0;
}