Problem:
青春の片道切符

太郎君は夏休みに電車で長旅をする計画を立てています。しかし高校生の身である太郎君が一ヵ月しかない夏休みで可能な限り遠くに旅をするには、出来るだけ安い行き方と出来るだけ早い行き方をそれぞれ見つけなければうまく計画が立てられません。太郎君が素敵な旅を満喫できるように、太郎君の計画の助けになるプログラムを作ってあげましょう。

線路の情報、駅の数を入力とし、問い合わせに応じて、最小金額または最短時間を出力するプログラムを作成してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。

n m
a1 b1 cost1 time1
a2 b2 cost2 time2
:
an bn costn timen
k
p1 q1 r1
p2 q2 r2
:
pk qk rk

1 行目に線路の情報の数 n (1 ≤ n ≤ 3000)と駅の数 m (1 ≤ m ≤ 100) が与えられます。

続く n 行に i 番目の路線の情報が与えられます。各路線の情報として、路線がつなぐ２つの駅の番号 ai, bi (1 ≤ ai, bi ≤ m)、料金 costi (1 ≤ costi ≤ 1000)、移動時間 timei (1 ≤ timei ≤ 1000) が与えられます。ただし、各駅は 1 から m まで順番に番号が付けられているものとします。
なお、ai と bi が線路でつながっていれば、ai から bi、 bi からai の両方の移動が同じ料金と時間で可能とします。

続く行に問い合わせの数 k (1 ≤ k ≤ 200) が与えられます。続く k 行に i 番目の問い合わせが与えられます。各問合わせとして、出発駅 pi 、到着駅 qi 、出力する値の種類 ri (0 または 1)が与えられます。なお、問い合わせには必ず経路があるものとします。

データセットの数は 50 を超えない。

Output

データセットごとに、最小金額もしくは最短時間を１行に出力します。ri が 0 の時は最小金額を、 1 の時は最短時間を出力します。

Sample Input

6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0

Output for the Sample Input

450
35

Solution in Ruby (judge verdict: Time Limit Exceeded)

class PriorityQueue
    def initialize
        @priority_queue = {}
    end

    def push(priority, var)
        @priority_queue[priority] ||= []
        @priority_queue[priority] << var
    end

    def pop
        min_key = @priority_queue.keys.min
        return_var = @priority_queue[min_key].shift
        @priority_queue.delete(min_key) if @priority_queue[min_key].length == 0
        return return_var
    end

    def empty?
        @priority_queue.empty?
    end
end

class Node
    attr_reader :name, :check, :from_node
    attr_accessor :cost

    def initialize(node_data)
        @name, @cost, @to_nodes = node_data[:name], node_data[:cost], node_data[:to_node]
        @check = @from_node = nil
    end

    def node_check(dijkstras)
        @to_nodes.each do |to_node|
            node = dijkstras.nodes[to_node[:name].to_sym]
            next if node.check
            node.cost_check(to_node[:cost] + @cost, self)
            dijkstras.priority_queue.push(node.cost, node)
        end
        self
    end

    def done
        @check = true
    end

    def cost_check(cost, from_node)
        if @cost == nil || @cost > cost
            @cost = cost
            @from_node = from_node
        end
    end
end

class Dijkstras
    attr_accessor :nodes, :priority_queue

    def initialize(nodes_data, start_node_name, goal_node_name)
        @priority_queue = PriorityQueue.new
        @nodes = {}
        nodes_data.each do |node_data|
            node = Node.new(node_data)
            @nodes[node.name.to_sym] = node
        end
        @start_node = nodes[start_node_name.to_sym]
        @goal_node = nodes[goal_node_name.to_sym]
    end

    def route_check
        @start_node.cost = 0
        @priority_queue.push(@start_node.cost, @start_node)

        while(!@priority_queue.empty?)
            done_node = @priority_queue.pop
            next if done_node.check
            done_node.node_check(self).done
        end
    end

    def print_route
        current_node = @goal_node
        print current_node.name
        while((current_node = current_node.from_node) != nil)
            print " -> #{current_node.name}"
        end
    end
end

loop do
    n, m = gets.split.map(&:to_i)
    break if n == 0 && m == 0
    ds = n.times.map{gets.split.map(&:to_i)}
    k = gets.to_i
    qs = k.times.map{gets.split.map(&:to_i)}
    costs = Array.new(m+1)
    times = Array.new(m+1)
    1.upto(m) do |i|
        costs[i] = Hash.new
        costs[i][:name] = i.to_s
        costs[i][:cost] = nil
        costs[i][:to_node] = Array.new
        times[i] = Hash.new
        times[i][:name] = i.to_s
        times[i][:cost] = nil
        times[i][:to_node] = Array.new
    end
    ds.each do |d|
        costs[d[0]][:to_node] += [{:name => d[1].to_s, :cost => d[2]}]
        costs[d[1]][:to_node] += [{:name => d[0].to_s, :cost => d[2]}]
        times[d[0]][:to_node] += [{:name => d[1].to_s, :cost => d[3]}]
        times[d[1]][:to_node] += [{:name => d[0].to_s, :cost => d[3]}]
    end
    costs = costs[1...costs.size]
    times = times[1...times.size]
    dijcs = Array.new(m+1)
    dijts = Array.new(m+1)
    1.upto(m) do |i|
        dijcs[i] = Dijkstras.new(costs, i.to_s, (m - 1).to_s)
        dijcs[i].route_check
        dijts[i] = Dijkstras.new(times, i.to_s, (m - 1).to_s)
        dijts[i].route_check
    end
    puts dijcs[1].nodes[:"1"].cost

    qs.each do |q|
        case q[2]
        when 0
            puts dijcs[q[0]].nodes[q[1].to_s.to_sym].cost
        when 1
            puts dijts[q[0]].nodes[q[1].to_s.to_sym].cost
        end
    end
end