Go: // Warshall–Floyd Algorithm

package main

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

var scanner = bufio.NewScanner(os.Stdin)

const INF = 2000000000

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
			c_matrix[b-1][a-1] = c
			t_matrix[a-1][b-1] = t
			t_matrix[b-1][a-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
					c_prev[i][j] = -1
				} else {
					c_dist[i][j] = c_matrix[i][j]
					c_prev[i][j] = i
				}
				if t_matrix[i][j] == 0 {
					t_dist[i][j] = INF
					t_prev[i][j] = -1
				} else {
					t_dist[i][j] = t_matrix[i][j]
					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]
					if c_newlen < c_dist[i][j] {
						c_dist[i][j] = c_newlen
						c_prev[i][j] = c_prev[k][j]
					}
				}
			}
		}
		for k := 0; k < m; k++ {
			for i := 0; i < m; i++ {
				for j := 0; j < m; j++ {
					t_newlen := t_dist[i][k] + t_dist[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 <utility>
#include <queue>
#define INF 1000000
using namespace std;
typedef pair<int, int> P;
struct line {
  int to,time,cost;
};

vector<line> L[100];
int costv[100];
int timev[100];

void mincost(int from,int to) {
  priority_queue<P, vector<P>, greater<P> > que;
  for(int i=0;i<100;i++) {
    costv[i] = INF;
  }
  costv[from] = 0;
  que.push(P(0,from));
  while(!que.empty()) {
    P p = que.top(); que.pop();
    int v = p.second;
    if(costv[v] < p.first) continue;
    for(int i=0;i < L[v].size();i++) {
      line l = L[v][i];
      if(costv[l.to] > costv[v] + l.cost) {
	costv[l.to] = costv[v] + l.cost;
	que.push(P(costv[l.to], l.to));
      }
    }
  }
  cout << costv[to] << endl;
}

void mintime(int from,int to) {
  priority_queue<P, vector<P>, greater<P> > que;
  for(int i=0;i<100;i++) {
    timev[i] = INF;
  }
  timev[from] = 0;
  que.push(P(0,from));
  while(!que.empty()) {
    P p = que.top(); que.pop();
    int v = p.second;
    if(timev[v] < p.first) continue;
    for(int i=0;i < L[v].size();i++) {
      line l = L[v][i];
      if(timev[l.to] > timev[v] + l.time) {
	timev[l.to] = timev[v] + l.time;
	que.push(P(timev[l.to], l.to));
      }
    }
  }
  cout << timev[to] << endl;
}

int main() {
  int n,m,k;
  while(cin >> n >> m) {
    if(n==0&&m==0)break;
    for(int i=0;i<100;i++) {
      L[i].clear();
    }
    for(int i=0;i<n;i++) { //input line
      line temp;
      int f,t,ti,co;
      cin >> f >> t >> co >> ti;
      temp.to = t;
      temp.time = ti;
      temp.cost = co;
      L[f].push_back(temp);
      temp.to = f;
      L[t].push_back(temp);
    }

    cin >> k;
    for(int i=0;i<k;i++) {
      int p,q,r;
      cin >> p >> q >> r;
      if(r == 0)
	mincost(p,q);
      else
	mintime(p,q);
    }
  }
}

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;
	}
    }
}