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
			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
					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 <limits.h>

using namespace std;

int m;

int dijkstra( int data[101][101], int start, int end )
{
	int i,j,next,min;
	static bool visited[101];
	static int distance[101];

	for( i = 1;i <= 100;i++ ){
		visited[i] = false;
		distance[i] = INT_MAX;
	}

	distance[start] = 0; next = start;

	do{
		i = next; visited[i] = true; min = INT_MAX;
		for(j = i;j <= m;j++){
			if(visited[j]) continue;
			if(data[i][j] < INT_MAX && distance[i] + data[i][j] < distance[j]) {
				distance[j] = distance[i] + data[i][j];
			}
			if( distance[j] < min ){
				min = distance[j]; next = j;
			}
		}
	} while( min < INT_MAX );

	return distance[end];
}


int main(int argc, char const* argv[])
{
	int n,weight[101][101][2];

	while( cin >> n >> m && n != 0 && m != 0 ){
		int a,b,c,d;
		for( int i = 1;i < 101;i++ ){
			for( int j = 1;j < 101;j++ ){
				weight[i][j][0] = INT_MAX;
				weight[i][j][1] = INT_MAX;
			}
		}

		for( int i = 0;i < n;i++ ){
			cin >> a >> b >> c >> d;
			weight[a][b][0] = c;
			weight[a][b][1] = d;
		}

		cin >> n;

		for( int i = 0;i < n;i++ ){
			int data[101][101];
			int p,q,r;
			cin >> p >> q >> r;
			for( int j = 1;j < 101;j++ ){
				for( int k = 1;k <101;k++ ) data[j][k] = weight[j][k][r];
			}
			cout << dijkstra( data, p, q ) << endl;
		}
	}


	return 0;

		
}

C++: #include "bits/stdc++.h"
using namespace std;

#define INF 1e9+7

int main(){
	int n,m;
	while(1){
		cin>>n>>m;
		if(n==0&&m==0)break;
		vector<vector<int> > cost(m+1,vector<int>(m+1,INF));
		vector<vector<int> > timea(m+1,vector<int>(m+1,INF));
		
		for(int i=0;i<n;i++){
			int a,b;
			cin>>a>>b;
			cin>>cost[a][b]>>timea[a][b];
		}
		
		for(int k=1;k<m+1;k++){
			for(int i=1;i<m+1;i++){
				for(int j=1;j<m+1;j++){
					cost[i][j]=min(cost[i][j],cost[i][k]+cost[k][j]);
					timea[i][j]=min(timea[i][j],timea[i][k]+timea[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<<cost[p][q]<<endl;
			if(r==1)cout<<timea[p][q]<<endl;
		}
	}
	return 0;
}

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

#define INF (1000000000)
int main() {

	
	int n,m;
	while( cin >> n >> m && n){
		int twf[110][110],cwf[110][110];
		for ( int i = 0; i < 110; i++ ) {
			for ( int j = 0; j < 110; j++ ) {
				if ( i == j )
					twf[i][j] = cwf[i][j] = 0;
				else
					twf[i][j] = cwf[i][j] = INF;
			}
		}
		for ( int i = 0; i < n; i++ ) {
			int a,b,cost,time;
			cin >> a >> b >> cost >> time;
			a--;b--;
			twf[a][b] = time;
			twf[b][a] = time;
			cwf[a][b] = cost;
			cwf[b][a] = cost;
		}
		for ( int a = 0; a < m; a++ ) {
			for ( int b = 0; b < m; b++ ) {
				for ( int c = 0; c < m; c++ ) {
					twf[b][c] = min ( twf[b][c], twf[b][a] + twf[a][c] );
					cwf[b][c] = min ( cwf[b][c], cwf[b][a] + cwf[a][c] );
				}
			}
		}

		int k;
		cin >> k;
		for ( int i = 0; i < k; i++ ) {
			int p,q,r;
			cin >> p >> q >> r;
			p--,q--;
			if ( !r ) {
				cout << cwf[p][q] << endl;
			} else {
				cout << twf[p][q] << endl;
			}
		}
	}
}

C++: #include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <functional>
#include <utility>
using namespace std;

typedef pair<int,int> P;

#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define mp make_pair
#define pb push_back

struct edge {
  int to, cost, time;
  edge(int a, int b, int c): to(a), cost(b), time(c) {}
};

const int MAX_M = 100, INF = 10000000;
int n, m;

void solve() {
  vector<edge> E[MAX_M+1];
  rep(i,n) {
    int a, b, cost, time; cin>>a>>b>>cost>>time;
    E[a].push_back(edge(b, cost, time));
    E[b].push_back(edge(a, cost, time));
  }
  int kkk; cin>>kkk;
  rep(i,kkk) {
    int p, q, r; cin>>p>>q>>r;
    // dijkstra
    int d[MAX_M+1];
    fill(d, d+MAX_M, INF);
    priority_queue<P, vector<P>, greater<P> > que;
    que.push(P(0, p));
    d[p] = 0;
    while (!que.empty()) {
      P p = que.top(); que.pop();
      int td = p.first, ti = p.second;
      //cout<<td<<"|"<<ti<<endl;
      if (d[ti] < td) continue;
      //
      rep(i,E[ti].size()) {
        edge e = E[ti][i];
        if (r == 0) {
          if (d[e.to] > d[ti] + e.cost) {
            d[e.to] = d[ti] + e.cost;
            que.push(P(d[e.to], e.to));
          }
        } else {
          if (d[e.to] > d[ti] + e.time) {
            d[e.to] = d[ti] + e.time;
            que.push(P(d[e.to], e.to));
          }
        }
      }
    }
    
    cout<<d[q]<<endl;
  }
}

int main (int argc, char const* argv[]) {
  while (cin>>n>>m, n||m) {
    solve();
  }
  return 0;
}