Problem:
Score : 600 points

Problem Statement

There is a tree with N vertices numbered 1 to N.
The i-th edge in this tree connects Vertex a_i and Vertex b_i, and the color and length of that edge are c_i and d_i, respectively.
Here the color of each edge is represented by an integer between 1 and N-1 (inclusive). The same integer corresponds to the same color, and different integers correspond to different colors.

Answer the following Q queries:

Query j (1 \leq j \leq Q): assuming that the length of every edge whose color is x_j is changed to y_j, find the distance between Vertex u_j and Vertex v_j. (The changes of the lengths of edges do not affect the subsequent queries.)

Constraints

2 \leq N \leq 10^5

1 \leq Q \leq 10^5

1 \leq a_i, b_i \leq N

1 \leq c_i \leq N-1

1 \leq d_i \leq 10^4

1 \leq x_j \leq N-1

1 \leq y_j \leq 10^4

1 \leq u_j < v_j \leq N

The given graph is a tree.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N Q
a_1 b_1 c_1 d_1
:
a_{N-1} b_{N-1} c_{N-1} d_{N-1}
x_1 y_1 u_1 v_1
:
x_Q y_Q u_Q v_Q

Output

Print Q lines. The j-th line (1 \leq j \leq Q) should contain the answer to Query j.

Sample Input 1

5 3
1 2 1 10
1 3 2 20
2 4 4 30
5 2 1 40
1 100 1 4
1 100 1 5
3 1000 3 4

Sample Output 1

130
200
60

The graph in this input is as follows:

Here the edges of Color 1 are shown as solid red lines, the edge of Color 2 is shown as a bold green line, and the edge of Color 4 is shown as a blue dashed line.

Query 1: Assuming that the length of every edge whose color is 1 is changed to 100, the distance between Vertex 1 and Vertex 4 is 100 + 30 = 130.

Query 2: Assuming that the length of every edge whose color is 1 is changed to 100, the distance between Vertex 1 and Vertex 5 is 100 + 100 = 200.

Query 3: Assuming that the length of every edge whose color is 3 is changed to 1000 (there is no such edge), the distance between Vertex 3 and Vertex 4 is 20 + 10 + 30 = 60. Note that the edges of Color 1 now have their original lengths.

Solution in Ruby (2.3.3) (judge verdict: Runtime Error)

N,Q = gets.split.map &:to_i
cds = (0..N).map{ {} }
(N-1).times {
  a,b,c,d = gets.split.map &:to_i
  cds[a][b] = cds[b][a] = [c,d]
}

M = Math.sqrt(N).floor
edges = Array.new(N+1, 0)
distances = Array.new(N+1, 0)
dtotal = Array.new(N+1,0)
td = 0
visited = { 1 => 1 }
queue = cds[1].map{ |n,_| [1,n] }.flatten
trail = [1]
lv = nil
express = {}
downes = (0..N).map{ {} }
upes   = Array.new(N+1,nil)
lcatrail = Array.new(N+1,nil)
depth = Array.new(N+1,nil)
depth[1] = 0

while queue.size > 0 do
  n = queue.pop
  if !visited[n]
    #p "> #{n}"
    visited[n] = 1
    parent = queue[-1]
    c,d = cds[parent][n]
    downes[parent][n] = 1
    edges[c] += 1
    distances[c] += d
    td += d
    dtotal[n] = td
    cds[n].each{ |m,_|
      next if visited[m]
      queue << n; queue << m
    }
    if trail.size % M == 0
      express[n] = [edges.dup,distances.dup]
    end
    i = 1
    ts = []
    while i <= trail.size do
      ts << trail[-i]
      i *= 2
    end
    lcatrail[n] = ts
    depth[n] = trail.size
    trail << n
    #p trail
  else
    #p "#{n} <"
    c,d = cds[lv][n]
    upes[lv] = n
    edges[c] -= 1
    distances[c] -= d
    td -= d
    trail.pop
  end
  lv = n
end

#p express, lcatrail, depth, upes, dtotal

def hop(lcatrail, u, d)
  while d > 0 do
    ts = lcatrail[u]
    m = d.bit_length-1
    u = ts[m]
    d -= (1 << m)
  end
  u
end

def lca(lcatrail, depth, u, v)
  d = depth[u] - depth[v]
  u2 = hop(lcatrail, u, d >= 0 ?  d : 0)
  v2 = hop(lcatrail, v, d <= 0 ? -d : 0)
  #p [u,v,d,u2,v2]
  while u2 != v2 do
    j = (1..lcatrail[u2].size).reverse_each.find{ |i|
      lcatrail[u2][-i] != lcatrail[v2][-i]
    } || 0
    u2 = lcatrail[u2][j]
    v2 = lcatrail[v2][j]
  end
  u2
end

def e_and_d(upes, cds, express, u, color)
  e,d = 0,0
  v = nil
  while u != 1 do
    if express[u]
      cos,dis = express[u]
      e += cos[color]
      d += dis[color]
      break
    end
    v = upes[u]
    co,di = cds[u][v]
    if co == color
      e += 1
      d += di
    end
    u = v
  end
  [e,d]
end

Q.times {
  x,y,u,v = gets.split.map &:to_i
  w = lca(lcatrail, depth, u, v)
  rs = [u,v,w].map{ |t| e_and_d(upes, cds, express, t, x) }
  xe = rs[0][0] + rs[1][0] - 2*rs[2][0]
  xd = rs[0][1] + rs[1][1] - 2*rs[2][1]
  td = dtotal[u] + dtotal[v] - 2*dtotal[w]
  p td - xd + xe*y
}