#include <bits/stdc++.h>
using namespace std;
struct Scanner {
  bool hasNext = 1;
  bool hasRead = 1;
  int nextInt() {
    hasRead = 0;
    int res = 0;
    char flag = 1, ch = getchar();
    while (ch != EOF && !isdigit(ch)) {
      hasRead = 1;
      flag = (ch == '-') ? -flag : flag;
      ch = getchar();
    }
    while (ch != EOF && isdigit(ch)) {
      hasRead = 1;
      res = res * 10 + (ch - '0');
      ch = getchar();
    }
    if (ch == EOF) hasNext = 0;
    return res * flag;
  }
  long long nextLL() {
    hasRead = 0;
    long long res = 0;
    char flag = 1, ch = getchar();
    while (ch != EOF && !isdigit(ch)) {
      hasRead = 1;
      flag = (ch == '-') ? -flag : flag;
      ch = getchar();
    }
    while (ch != EOF && isdigit(ch)) {
      hasRead = 1;
      res = res * 10 + (ch - '0');
      ch = getchar();
    }
    if (ch == EOF) hasNext = 0;
    return res * flag;
  }
  char nextChar() {
    hasRead = 0;
    char ch = getchar();
    while (ch != EOF && isspace(ch)) {
      hasRead = 1;
      ch = getchar();
    }
    if (ch == EOF) hasNext = 0;
    return ch;
  }
  int nextString(char *str) {
    hasRead = 0;
    int len = 0;
    char ch = getchar();
    while (ch != EOF && isspace(ch)) {
      hasRead = 1;
      ch = getchar();
    }
    while (ch != EOF && !isspace(ch)) {
      hasRead = 1;
      str[++len] = ch;
      ch = getchar();
    }
    str[len + 1] = 0;
    if (ch == EOF) hasNext = 0;
    return len;
  }
} sc;
long long rd() {
  long long x = sc.nextLL();
  return x;
}
void rd(int &x) { x = sc.nextInt(); }
void rd(long long &x) { x = sc.nextLL(); }
void rd(char &x) { x = sc.nextChar(); }
void rd(char *x) { sc.nextString(x); }
template <typename T1, typename T2>
void rd(pair<T1, T2> &x) {
  rd(x.first);
  rd(x.second);
}
template <typename T>
void rd(T *x, int n) {
  for (int i = 1; i <= n; ++i) rd(x[i]);
}
void printInt(int x) {
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  if (x >= 10) printInt(x / 10);
  putchar('0' + x % 10);
}
void printLL(long long x) {
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  if (x >= 10) printLL(x / 10);
  putchar('0' + x % 10);
}
void pr(int x, char ch = '\n') {
  printInt(x);
  putchar(ch);
}
void pr(long long x, char ch = '\n') {
  printLL(x);
  putchar(ch);
}
template <typename T1, typename T2>
void pr(pair<T1, T2> x, char ch = '\n') {
  pr(x.first, ' ');
  pr(x.second, ch);
}
template <typename T>
void pr(T *x, int n) {
  for (int i = 1; i <= n; ++i) pr(x[i], " \n"[i == n]);
}
template <typename T>
void pr(vector<T> &x) {
  int n = x.size();
  for (int i = 1; i <= n; ++i) pr(x[i - 1], " \n"[i == n]);
}
template <typename T>
void cmin(T &x, T y) {
  if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
  if (y > x) x = y;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int MOD = 1000000007;
const int MAXN = 3000 + 10;
int n, m;
vector<int> G[MAXN];
int w[MAXN], b[MAXN];
int siz[MAXN];
vector<pair<int, long long> > dp[MAXN];
pair<int, long long> add(pair<int, long long> A, pair<int, long long> B) {
  A.first += B.first;
  A.second += B.second;
  return A;
}
void dfs(int u, int p) {
  siz[u] = 1;
  dp[u] = vector<pair<int, long long> >(siz[u] + 1,
                                        pair<int, long long>(-INF, -LINF));
  dp[u][0] = pair<int, long long>(0, w[u] - b[u]);
  for (int v : G[u]) {
    if (p == v) continue;
    dfs(v, u);
    vector<pair<int, long long> > tmp = dp[u];
    dp[u] = vector<pair<int, long long> >(siz[u] + siz[v] + 1,
                                          pair<int, long long>(-INF, -LINF));
    for (int i = 0; i <= siz[u] && i <= m; ++i) {
      for (int j = 0; j <= siz[v] && i + j <= m; ++j)
        cmax(dp[u][i + j], add(tmp[i], dp[v][j]));
    }
    siz[u] += siz[v];
  }
  for (int i = min(siz[u] - 1, m - 1); i >= 0; --i)
    cmax(dp[u][i + 1],
         pair<int, long long>(dp[u][i].first + (dp[u][i].second > 0), 0LL));
}
struct Solver {
  void InitOnce() {}
  void Read() {
    rd(n);
    rd(m);
    rd(b, n);
    rd(w, n);
    for (int i = 1; i <= n; ++i) G[i].clear();
    for (int i = 1; i <= n - 1; ++i) {
      int u, v;
      rd(u), rd(v);
      G[u].emplace_back(v);
      G[v].emplace_back(u);
    }
  }
  void Solve() {
    dfs(1, 0);
    int res = dp[1][m - 1].first + (dp[1][m - 1].second > 0);
    pr(res);
  }
} solver;
int main() {
  solver.InitOnce();
  int t = 1;
  t = sc.nextInt();
  t = INF;
  while (t--) {
    solver.Read();
    if (!sc.hasRead) break;
    solver.Solve();
    if (!sc.hasNext) break;
  }
  return 0;
}
