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 Rust (1.15.1) (judge verdict: Time Limit Exceeded)

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String {
            bytes
                .by_ref()
                .map(|r| r.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_imports)]
use std::cmp::{min, max};
use std::collections::HashMap;

fn main() {
    input!{
        n: usize,
        q: usize,
        es: [(usize1, usize1, usize, usize); n - 1],
        qs: [(usize, usize, usize1, usize1); q]
    }
    let mut t = vec![vec![]; n];
    for &(a, b, c, d) in &es {
        t[a].push((b, c, d));
        t[b].push((a, c, d));
    }
    let mut eular = vec![];
    let mut dist = vec![(0, HashMap::new()); n];
    eular_dfs(0, 0, &t, &mut eular, &mut dist, 0);
    let mut idx = vec![2 * n; n];
    for i in 0..eular.len() {
        idx[eular[i].0] = min(idx[eular[i].0], i);
    }
    let (ids, ds) = eular.iter().cloned().unzip::<usize, usize, Vec<usize>, Vec<usize>>();
    let mut segt = SegT::fromVec(ds, ids);
    for &(x, y, u, v) in &qs {
        let lca = segt.get(min(idx[u], idx[v]), max(idx[u], idx[v]));
        let du = dist.get(u).unwrap();
        let dv = dist.get(v).unwrap();
        let dlca = dist.get(lca).unwrap();
        let dxu = *du.1.get(&x).unwrap_or(&(0, 0));
        let dxv = *dv.1.get(&x).unwrap_or(&(0, 0));
        let dxlca = *dlca.1.get(&x).unwrap_or(&(0, 0));
        println!("{}", du.0 + dv.0 - 2 * dlca.0 - (dxu.0 + dxv.0 - 2 * dxlca.0) + y * (dxu.1 + dxv.1 - 2 * dxlca.1));
    }
}

fn eular_dfs(r: usize, p: usize, t: &Vec<Vec<(usize, usize, usize)>>, e: &mut Vec<(usize, usize)>, dist: &mut Vec<(usize, HashMap<usize, (usize, usize)>)>, d: usize) {
    e.push((r, d));
    for &(b, c, l) in &t[r] {
        if b == p {
            continue;
        }
        let mut dp = dist[r].clone();
        dp.0 += l;
        {
            let mut x = dp.1.entry(c).or_insert((0, 0));
            x.0 += l;
            x.1 += 1;
        }
        dist[b] = dp;
        eular_dfs(b, r, t, e, dist, d + 1);
        e.push((r, d));
    }
}

struct SegT {
    v: Vec<usize>,
    w: Vec<usize>,
    n: usize
}

impl SegT {
    fn fromVec(xs: Vec<usize>, ids: Vec<usize>) -> SegT {
        let l = xs.len();
        let mut s = 1;
        while s < l {
            s *= 2;
        }
        let mut v = vec![usize::max_value(); 2 * s - 1];
        let mut w = vec![0; 2 * s - 1];
        for i in 0..l {
            v[i + s - 1] = xs[i];
            w[i + s - 1] = ids[i];
        }
        for i in 2..s + 1 {
            let p = s - i;
            if v[2 * p + 1] < v[2 * p + 2] {
                v[p] = v[2 * p + 1];
                w[p] = w[2 * p + 1];
            } else {
                v[p] = v[2 * p + 2];
                w[p] = w[2 * p + 2];
            }
        }
        SegT{v: v, w: w, n: s}
    }

    fn get(&mut self, l: usize, r: usize) -> usize {
        let n = self.n;
        self.get_rec(l, r, 0, 0, n - 1).1
    }

    fn get_rec(&mut self, l: usize, r: usize, p: usize, pl: usize, pr: usize) -> (usize, usize) {
        if pl > r || pr < l {
            (usize::max_value(), 0)
        } else if l <= pl && pr <= r {
            (self.v[p], self.w[p])
        } else {
            let a = self.get_rec(l, r, 2 * p + 1, pl, (pl + pr - 1) / 2);
            let b = self.get_rec(l, r, 2 * p + 2, (pl + pr + 1) / 2, pr);
            if a.0 < b.0 {
                a
            } else {
                b
            }
        }
    }
}