#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>

using namespace std;

typedef long long ll;

const int maxn = 5e4 + 5;
const int INF = 1 << 30;

struct edge
{
    int to, next;

    edge(int to = 0, int next = 0) : to(to), next(next) {}
} G[maxn << 1];
int head[maxn], tot, que[maxn], k, n, leaf[maxn], w[maxn];
ll lf[maxn], rg[maxn];
int used[maxn];

void init()
{
    memset(head, -1, sizeof(head));
    memset(w, -1, sizeof(w));
    tot = 0;
}

void addedge(int u, int v)
{
    G[tot] = edge(v, head[u]);
    head[u] = tot++;
    G[tot] = edge(u, head[v]);
    head[v] = tot++;
}

bool C(int x)
{
    int front = 0, rear = 0;
    memset(used, 0, sizeof(used));
    memset(lf, -1, sizeof(lf));
    memset(rg, -1, sizeof(rg));
    for(int i = 0; i < k; ++i)
    {
        int u = leaf[i];
        used[u] = 1;
        que[rear++] = u;
        lf[u] = rg[u] = w[u];
        used[u] = 1;
    }
    while(front < rear)
    {
        int u = que[front++];
        if(lf[u] > rg[u]) return false;
        used[u] = 1;
        for(int i = head[u]; ~i; i = G[i].next)
        {
            int v = G[i].to;
            if(used[v] == 1) continue;
            if(lf[v] == -1)
            {
                lf[v] = max(1LL, lf[u] - x);
                rg[v] = rg[u] + x;
                que[rear++] = v;
            }
            else
            {
                lf[v] = max(lf[v], lf[u] - x);
                rg[v] = min(rg[v], rg[u] + x);
            }
        }
    }
    return true;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &k);
        init();
        for(int i = 1; i < n; ++i)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            addedge(u, v);
        }
        for(int i = 0; i < k; ++i)
        {
            scanf("%d", leaf + i);
            scanf("%d", &w[leaf[i]]);
        }
        int l = 0, r = INF;
        for(int i = 0; i < k; ++i)
        {
            int u = leaf[i];
            for(int j = head[u]; ~j; j = G[j].next)
            {
                int v = G[j].to;
                if(~w[v]) l = max(l, abs(w[u] - w[v]));
            }
        }
        while(l < r)
        {
            int m = (l + r) >> 1;
            if(C(m)) r = m;
            else l = m + 1;
        }
        printf("%d\n", r);
    }
    return 0;
}