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>
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;
	}
	system("pause");
	return 0;
}

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

int main()
{
  int n,m;
  for(;cin>>n>>m,n;)
    {
      m++;
      int time[m][m];
      int money[m][m];
      for(int i=0;i<m;i++)
	for(int j=0;j<m;j++)
	  {
	    if(i==j)
	      {
		time[i][j]=0;
		money[i][j]=0;
	      }
	    else
	      {
		time[i][j]=9999999;
		money[i][j]=9999999;
	      }
	  }
      for(int i=0;i<n;i++)
	{
	int a,b;
	cin>>a>>b;
	cin>>money[a][b]>>time[a][b];
	}
      for(int k=0;k<m;k++)
	for(int i=0;i<m;i++)
	  for(int j=0;j<m;j++)
	    {
	      time[i][j]=min(time[i][j],time[i][k]+time[k][j]);
	      money[i][j]=min(money[i][j],money[i][k]+money[k][j]);
	    }
      int k;
      cin>>k;
      for(int i=0;i<k;i++)
	{
	  int p,q,r;
	  cin>>p>>q>>r;
	  if(r==0)
	    cout<<money[p][q]<<endl;
	  else
	    cout<<time[p][q]<<endl;
	}
    }
}

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

using namespace std;

int const Inf = 10000000;
int const N = 100;

typedef array<int, 2> line;

struct tg { int c, v; };
bool operator>( tg const& lhs, tg const& rhs )
{
    return lhs.c > rhs.c;
}

int main()
{
    int n, m;
    priority_queue<tg, vector<tg>, greater<tg>> w;

    while( cin >> n >> m, n||m ) {
        line table[N][N] = {};

        for( int i=0; i<n; ++i ) {
            int a, b, cost, time;
            cin >> a >> b >> cost >> time;

            int const from = a-1, to = b-1;
            line const in = {{cost, time}};
            table[from][to] = ( table[to][from] = in );
        }

        int k;
        cin >> k;
        for( int i=0; i<k; ++i ) {
            int p, q, r;
            cin >> p >> q >> r;
            int const from = p-1, to = q-1;

            bool v[N] = {};
            int d[N];
            fill( d, d+N, Inf );

            tg const val = { 0, from };
            w.push( val );
            d[from] = 0;

            while( !w.empty() ) {
                int const cur = w.top().v;
                w.pop();

                if ( v[cur] )
                    continue;
                v[cur] = true;

                for( int ii=0; ii<m; ++ii ) {
                    if ( table[cur][ii][0] == 0 || v[ii] )
                        continue;

                    if ( d[cur] + table[cur][ii][r] < d[ii] ) {
                        d[ii] = d[cur] + table[cur][ii][r];
                        tg const val = { table[cur][ii][r], ii };
                        w.push( val );
                    }

                    //cout << cur+1 << " -> " << ii+1 << " c " << d[ii] << endl;
                }
                

            }

            cout << d[to] << endl;
        }
    }
}