import java.io.*;
import java.util.*;

public class TaskE {
    private final InputReader reader;
    private final OutputWriter writer;

    public TaskE(InputReader reader, OutputWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWriter writer = new OutputWriter(System.out);
        new TaskE(reader, writer).run();
        writer.writer.flush();
    }

    int[] F;
    class Edge implements Comparable<Edge> {
        int a, b, l;
        Edge(int a, int b, int l) {
            this.a = a;
            this.b = b;
            this.l = l;
        }
        @Override
        public int compareTo(Edge other) {
            return -Integer.compare(this.l, other.l);
        }
    }

    List<Integer>[] E;

    class Node {
        int l, r, sum;
        boolean whole;
        Node(int v) {
            if (v == 0) {
                l = r = sum = 0;
                whole = false;
            } else {
                l = r = 1;
                sum = 0;
                whole = true;
            }
        }
        Node(int l, int r, int sum, boolean whole) {
            this.l = l;
            this.r = r;
            this.sum = sum;
            this.whole = whole;
        }
        Node reverse() {
            return new Node(r, l, sum, whole);
        }
        int value() {
            if (whole)
                return F[l]; //!
            else
                return F[l] + F[r] + sum;
        }
    }

    Node combine(Node a, Node b) {
        if (a == null)
            return b;
        if (b == null)
            return a;
        if (a.whole && b.whole)
            return new Node(a.l + b.l, a.r + b.r, a.sum + b.sum, true);
        if (a.whole && !b.whole)
            return new Node(a.l + b.l, b.r, a.sum + b.sum, false);
        if (!a.whole && b.whole)
            return new Node(a.l, a.r + b.r, a.sum + b.sum, false);
        return new Node(a.l, b.r, a.sum + b.sum + F[a.r + b.l], false);
    }

    class SegmentTree {
        int N;
        Node[] T;
        SegmentTree(int n) {
            N = 1;
            while (N < n)
                 N <<= 1;
            T = new Node[2 * N];
            for (int i = N + n - 1; i >= N; i--)
                T[i] = new Node(0);
            for (int i = N - 1; i > 0; i--)
                T[i] = combine(T[2 * i], T[2 * i + 1]);
        }
        void set(int x, int i) {
            x += N;
            T[x] = new Node(i);
            for (x >>= 1; x > 0; x >>= 1)
                T[x] = combine(T[2 * x], T[2 * x + 1]);
        }
        Node get(int l, int r) {
            Node resl = null, resr = null;
            l += N;
            r += N;
            while (l <= r) {
                if ((l & 1) == 1)
                    resl = combine(resl, T[l]);
                if ((r & 1) == 0)
                    resr = combine(T[r], resr);
                l = (l + 1) >> 1;
                r = (r - 1) >> 1;
            }
            return combine(resl, resr);
        }
    }

    int lgn;
    int[][] up;
    int[] S;
    int[] to;
    int[] D;
    void DFS1(int x, int p) {
        up[0][x] = p;
        for (int d = 1; d < lgn; d++)
            up[d][x] = up[d - 1][up[d - 1][x]];
        S[x] = 1;
        to[x] = -1;
        for (int i = 0; i < E[x].size(); i++) {
            int y = E[x].get(i);
            if (y == p) {
                E[x].set(i, E[x].get(E[x].size() - 1));
                E[x].remove(E[x].size() - 1);
                --i;
                continue;
            }
            D[y] = D[x] + 1;
            DFS1(y, x);
            S[x] += y;
        }
        int mxs = -1;
        for (int i = 0; i < E[x].size(); i++) {
            int y = E[x].get(i);
            if (mxs == -1 || S[mxs] < S[y])
                mxs = y;
        }
        to[x] = mxs;
    }

    SegmentTree[] ST;
    int[] ind;
    int[] top;
    void DFS2(int x) {
        if (to[x] == -1) {
            ST[x] = new SegmentTree(ind[x] + 1);
        } else {
            ind[to[x]] = ind[x] + 1;
            top[to[x]] = top[x];
        }
        for (int y : E[x]) {
            if (y != to[x])
                top[y] = y;
        }
        for (int y : E[x]) {
            DFS2(y);
        }
        if (to[x] != -1) {
            ST[x] = ST[to[x]];
        }
    }

    int lca(int a, int b) {
        if (D[a] > D[b]) {
            int t = a;
            a = b;
            b = t;
        }
        for (int d = lgn - 1; d >= 0; d--) {
            if (D[b] - (1 << d) >= D[a])
                b = up[d][b];
        }
        if (a == b)
            return a;
        for (int d = lgn - 1; d >= 0; d--) {
            if (up[d][a] != up[d][b]) {
                a = up[d][a];
                b = up[d][b];
            }
        }
        if (a == b)
            throw new AssertionError();
        if (up[0][a] != up[0][b])
            throw new AssertionError();
        return up[0][a];
    }

    class Query implements Comparable<Query> {
        int a, b, x;
        int id;
        Query(int a, int b, int x, int id) {
            this.a = a;
            this.b = b;
            this.x = x;
            this.id = id;
        }
        @Override
        public int compareTo(Query other) {
            return -Integer.compare(this.x, other.x);
        }
    }

    Node get(int x, int y) {
        Node res = null;
        while (true) {
            if (D[x] < D[y])

                throw new AssertionError();
            if (ST[x] == ST[y]) {
                res = combine(ST[x].get(ind[y] + 1, ind[x]), res);
                break;
            } else {
                res = combine(ST[x].get(0, ind[x]), res);
                x = up[0][top[x]];
            }
        }
        return res;
    }

    public void run() {
        int n = reader.nextInt();
        int q = reader.nextInt();
        F = new int[n];
        for (int i = 1; i < n; i++) {
            F[i] = reader.nextInt();
        }
        Edge[] edges = new Edge[n - 1];
        for (int i = 0; i < n - 1; i++) {
            int a = reader.nextInt() - 1;
            int b = reader.nextInt() - 1;
            int l = reader.nextInt();
            edges[i] = new Edge(a, b, l);
        }
        E = new List[n];
        for (int i = 0; i < n; i++)
            E[i] = new ArrayList<Integer>(1);
        for (Edge e : edges) {
            E[e.a].add(e.b);
            E[e.b].add(e.a);
        }
        while ((1 << lgn) < n + 1)
            ++lgn;
        up = new int[lgn][n];
        S = new int[n];
        to = new int[n];
        D = new int[n];
        DFS1(0, 0);
        ST = new SegmentTree[n];
        ind = new int[n];
        top = new int[n];
        DFS2(0);
        Query[] Q = new Query[q];
        for (int i = 0; i < q; i++) {
            int a = reader.nextInt() - 1;
            int b = reader.nextInt() - 1;
            int l = reader.nextInt();
            Q[i] = new Query(a, b, l, i);
        }
        Arrays.sort(edges);
        Arrays.sort(Q);
        int pte = 0;
        int[] Ans = new int[q];
        for (Query query : Q) {
            while (pte != edges.length && edges[pte].l >= query.x) {
                int a = edges[pte].a;
                int b = edges[pte].b;
                if (up[0][b] == a) {
                    int t = b;
                    b = a;
                    a = t;
                } else if (up[0][a] != b)
                    throw new AssertionError();
                ST[a].set(ind[a], 1);
                pte++;
            }
            int a = query.a;
            int b = query.b;
            int l = lca(a, b);
            Node u = get(a, l);
            Node v = get(b, l);
            if (v != null)
                v = v.reverse();
            Node res = combine(v, u);
            int ans = (res == null) ? 0 : res.value(); //!
            Ans[query.id] = ans;
        }
        for (int a : Ans)
            writer.printf("%d\n", a);
    }


    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}