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 Java8 (OpenJDK 1.8.0) (judge verdict: Runtime Error)

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args){
        PrintWriter out = new PrintWriter(System.out);
        FastScanner sc = new FastScanner();

        int N = sc.nextInt();
        int Q = sc.nextInt();
        int a[] = new int[N-1];
        int b[] = new int[N-1];
        int c[] = new int[N-1];
        int d[] = new int[N-1];
        ArrayList[] links = new ArrayList[N];
        ArrayList<Integer> parents_list[] = new ArrayList[N];
        for (int i=0;i<N;i++) {
            links[i] = new ArrayList<Link>();
            parents_list[i] = new ArrayList<Integer>();
        }

        for (int i=0;i<N-1;i++) {
            a[i] = sc.nextInt() - 1;
            b[i] = sc.nextInt() - 1;
            c[i] = sc.nextInt() - 1;
            d[i] = sc.nextInt();
            links[a[i]].add(new Link(a[i], b[i], c[i], d[i]));
            links[b[i]].add(new Link(b[i], a[i], c[i], d[i]));
        }

        int distance[][] = new int[N][N];
        int num[][] = new int[N][N];
        int total_distance[] = new int[N];

        calc_distance(0, -1, num, distance, total_distance, links, parents_list);
//        for (int i=0;i<N;i++) {
//            for (int j=0;j<N;j++) {
//                out.printf("%5d ", distance[i][j]);
//            }
//            out.println();
//        }
//
//        out.println();
//        for (int i=0;i<N;i++) {
//            out.printf("%5d ", total_distance[i]);
//            out.println();
//        }
//
//        for (int i=0;i<N;i++) {
//            for (int j=0;j<N;j++) {
//                out.printf("%5d ", num[i][j]);
//            }
//            out.println();
//        }

        for (int i=0;i<Q;i++) {
            int x = sc.nextInt() - 1;
            int y = sc.nextInt();
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;

            int p = 0;
            if (u != 0 && v != 0) p = same_parent(u, v, parents_list);

            long ans = total_distance[u] + total_distance[v] - total_distance[p] * 2;
            ans -= distance[u][x] + distance[v][x] - distance[p][x] * 2;
            ans += (num[u][x] + num[v][x] - num[p][x] * 2) * y;
            out.println(ans);
        }

        out.flush();
    }

    public static void calc_distance(int now, int parent, int num[][], int distance[][], int total_distance[],
            ArrayList<Link> links[], ArrayList<Integer> parents_list[]) {
        for (Link l: links[now]) {
            if (l.to == parent) continue;

            distance[l.to] = distance[now].clone();
            distance[l.to][l.color] += l.distance;
            num[l.to] = num[now].clone();
            num[l.to][l.color]++;
            total_distance[l.to] = total_distance[now] + l.distance;

            parents_list[l.to] = (ArrayList<Integer>) parents_list[now].clone();
            parents_list[l.to].add(now);

            calc_distance(l.to, now, num, distance, total_distance, links, parents_list);
        }
    }

    /*
5 3
1 2 1 10
1 3 2 20
2 4 4 30
5 2 1 40
1 100  4 5
     */
    public static int same_parent(int a, int b, ArrayList<Integer> parents_list[]) {
        ArrayList<Integer> A = parents_list[a];
        ArrayList<Integer> B = parents_list[b];
        int l = 0;
        int ret = 0;
        int r = Math.min(A.size(), B.size()) - 1;

        while (true) {
            int mid = (l + r) / 2;
            if (A.get(mid) != B.get(mid)) {
                r = mid - 1;
            } else {
                ret = mid;
                l = mid + 1;
            }

            if (l > r) {
                break;
            }
        }

        return ret;
    }

    public static class Link {
        int from, to, color, distance;
        Link(int from, int to, int color, int distance) {
            this.from = from;
            this.to = to;
            this.color = color;
            this.distance = distance;
        }
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        int[] nextIntArray(int N) {
            int a[] = new int[N];
            for (int i=0;i<N;i++) {
                a[i] = this.nextInt();
            }

            return a;
        }

        long[] nextLongArray(int N) {
            long a[] = new long[N];
            for (int i=0;i<N;i++) {
                a[i] = this.nextLong();
            }

            return a;
        }

        double[] nextDoubleArray(int N) {
            double a[] = new double[N];
            for (int i=0;i<N;i++) {
                a[i] = this.nextDouble();
            }

            return a;
        }

        String[] nextTokenArray(int N) {
            String a[] = new String[N];
            for (int i=0;i<N;i++) {
                a[i] = this.nextToken();
            }

            return a;
        }
    }
}