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 <cstdio>
#include <vector>
#include <utility>
#include <queue>
#include <functional>
#define N 101
#define INF 2000000000
using namespace std;
 
int dist[N];
typedef pair<int,int> pii;
 
std::vector<pii> e1[N];
std::vector<pii> e2[N];
 
int dijk1(int a,int b){
    dist[a]=0;
    std::priority_queue<pii> pq;
    for(int i=0;i<e2[a].size();i++){
        pq.push(e2[a][i]);
    }
    while(!pq.empty()){
        pii temp=pq.top();
        int now=temp.second;
        int c=temp.first;
        pq.pop();
        if(dist[now]!=INF)continue;
        dist[now]=-c;
        if(now==b)break;
        for(int i=0;i<e2[now].size();i++){
            pq.push(make_pair(c+e2[now][i].first,e2[now][i].second));
        }
    }
    return dist[b];
}
 
int dijk(int a,int b){
    dist[a]=0;
    std::priority_queue<pii> pq;
    for(int i=0;i<e1[a].size();i++){
        pq.push(e1[a][i]);
    }
    while(!pq.empty()){
        pii temp=pq.top();
        int now=temp.second;
        int c=temp.first;
        pq.pop();
        if(dist[now]!=INF)continue;
        dist[now]=-c;
        if(now==b)break;
        for(int i=0;i<e1[now].size();i++){
            pq.push(make_pair(c+e1[now][i].first,e1[now][i].second));
        }
    }
    return dist[b];
}
 
int main(void){
    int a,b,c,d;
    int n,m;
    while(cin>>n>>m,n||m){
        for(int i=0;i<n;i++){
            cin>>a>>b>>c>>d;
e1[b].push_back(make_pair(-c,a);
            e1[a].push_back(make_pair(-c,b));
            e2[a].push_back(make_pair(-d,b));
e2[b].push_back(make_pair(-d,a);
        }
        int k;
        cin>>k;
        while(k--){
            for(int i=1;i<=m;i++)dist[i]=INF;
            cin>>a>>b>>c;
            if(c) cout<<dijk1(a,b)<<endl;
            else cout<<dijk(a,b)<<endl;
            // for(int i=1;i<=m;i++)printf("dist[%d]:%d\n",i,dist[i]);
        }
    }
    return 0;
}

C++: #include<cstdio>
#include<algorithm>
#include<queue>

#define INF 1<<29

using namespace std;

int main(){
	while(1){
		int n,m;
		scanf("%d%d",&m,&n);
		if(m==0 && n==0){
			break;
		}
		int cost[101][101];
		int time[101][101];
		
		for(int i=0;i<101;i++)
		for(int j=0;j<101;j++)
		cost[i][j]=time[i][j]=INF;
		
		for(int i=0;i<m;i++){
			int a,b,c,d;
			scanf("%d%d%d%d",&a,&b,&c,&d);
			cost[a][b]=cost[b][a]=c;
			time[a][b]=time[b][a]=d;
		}
		
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				for(int k=1;k<=n;k++){
					cost[i][j]=min(cost[i][j],cost[i][k]+cost[k][j]);
					time[i][j]=min(time[i][j],time[i][k]+time[k][j]);
				}
			}
		}
		
		scanf("%d",&m);
		for(int i=0;i<m;i++){
			int a,b,c;
			scanf("%d%d%d",&a,&b,&c);
			if(c==0){
				printf("%d\n",cost[a][b]);
			}else{
				printf("%d\n",time[a][b]);
			}
		}
	}
}

C++: #include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
#define INF 1<<28
using namespace std;

struct edge{
  int to,cost;
  edge(int _to, int _cost){ to = _to; cost = _cost;}
};

typedef pair <int, int> P;

int n,m;
vector <edge> G[500][2];
int d[500][2];

void dijkstra(int s,int k){
  
  priority_queue <P, vector<P>, greater<P> > que;
  for(int i=0;i<m;i++) d[i][0] = d[i][1] = INF;
  
  d[s][k] = 0;
  que.push( P(0, s) );

  while( !que.empty() ){
    P p = que.top(); que.pop();
    int v = p.second;
    
    if(d[v][k] < p.first) continue;

    for(int i=0;i<G[v][k].size();i++){
      edge e = G[v][k][i];
      
      if(d[e.to][k] > e.cost + d[v][k]){
	d[e.to][k] = e.cost + d[v][k];
	que.push( P(d[e.to][k],e.to) );
      }
    }
  }
}

int main(){
  
  int a,b,cost,time,l,k;
  
  while(true){
    cin >> n >> m;
    if(!n && !m) break;
    
    for(int i=0;i<n;i++){
      cin >> a >> b >> cost >> time;
      
      G[a][0].push_back(edge(b,cost));
      G[a][1].push_back(edge(b,time));
      G[b][0].push_back(edge(a,cost));
      G[b][1].push_back(edge(a,time));

    }
    
    cin >> l;
    for(;l>0;l--){
      cin >> a >> b >> k;
      dijkstra(a,k);
      cout << d[b][k] << endl;
    }
    
  }  
}