How far away？ (HDU

　There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this "How far is it if I want to go from house A to house B"? Usually it hard to answer. But luckily int this village the answer is always unique, since the roads are built in the way that there is a unique simple path("simple" means you can't visit a place twice) between every two houses. Yout task is to answer all these curious people.

 

Input

　First line is a single integer T(T<=10), indicating the number of test cases. 
　For each test case,in the first line there are two numbers n(2<=n<=40000) and m (1<=m<=200),the number of houses and the number of queries. The following n-1 lines each consisting three numbers i,j,k, separated bu a single space, meaning that there is a road connecting house i and house j,with length k(0<k<=40000).The houses are labeled from 1 to n. 
　Next m lines each has distinct integers i and j, you areato answer the distance between house i and house j.

Output

For each test case,output m lines. Each line represents the answer of the query.Outputa bland line after each test case.

Sample Input

2
3 2
1 2 10
3 1 15
1 2
2 3

2 2
1 2 100
1 2
2 1

Sample Output

10
25
100
100

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<map>
#include<queue>
#include<vector>

#define int long long

using namespace std;

const int maxx = 1e5 + 5;

struct node1
{
    int u, v, w, next;
    node1(){};
    node1(int u_, int v_, int w_, int next_)
    {
        u = u_;
        v = v_;
        w = w_;
        next = next_;
    }
} edge[maxx*2];

struct node2
{
    int u, v, id, next;
    node2(){};
    node2(int u_, int v_, int id_, int next_)
    {
        u = u_;
        v = v_;
        id = id_;
        next = next_;
    }
} qu[maxx*2];

int cur1, cur2, re[maxx][5];
int head1[maxx], head2[maxx], de[maxx];
int pre[maxx];
bool vis[maxx];


void init(int n)
{
    cur1 = cur2 = 0;
    memset(vis, false, sizeof(vis));
    memset(head1, -1, sizeof(head1));
    memset(head2, -1, sizeof(head2));
    memset(qu, 0, sizeof(qu));
    memset(edge, 0, sizeof(edge));
    memset(de, 0, sizeof(de));
    for(int i=1; i<=n; i++)
    {
        pre[i] = i;
    }
}

void add_edge(int u, int v, int w)
{
    edge[cur1] = (node1){u, v, w, head1[u]};
    head1[u] = cur1++;
}

void add_qu(int u, int v, int id)
{
    qu[cur2] = (node2){u, v, id, head2[u]};
    head2[u] = cur2++;
}

int find_pre(int x)
{
    if(pre[x]==x) return x;
    else return pre[x] = find_pre(pre[x]);
}

void Tarjan(int x)
{
    int pre1, pre2;
    vis[x] = true;
    for(int i=head1[x]; ~i; i=edge[i].next)
    {
        int v = edge[i].v;
        if(vis[v]==false)
        {
            de[v] = de[x] + edge[i].w;
            Tarjan(v);
            pre1 = find_pre(x);
            pre2 = find_pre(v);
            if(pre1 != pre2)
            {
                pre[pre2] = pre1;
            }
        }
    }

    for(int i=head2[x]; ~i; i=qu[i].next)
    {
        int v = qu[i].v;
        if(vis[v]==true)
        {
            re[qu[i].id][2] = find_pre(v);
        }
    }
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int t, n, m;
    int u, v, w;

    cin >> t;
    while(t--)
    {
        cin >> n >> m;
        init(n);

        for(int i=1; i<n; i++)
        {
            cin >> u >> v >> w;
            add_edge(u, v, w);
            add_edge(v, u, w);
        }
        for(int i=1; i<=m; i++)
        {
            cin >> u >> v;
            add_qu(u, v, i);
            add_qu(v, u, i);
            re[i][0] = u;
            re[i][1] = v;
        }

        Tarjan(1);

        for(int i=1; i<=m; i++)
        {
            cout << de[re[i][0]] + de[re[i][1]] - 2 * de[re[i][2]] << endl;
        }
    }

    return 0;
}