#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

#define int unsigned

constexpr int N = 5e4 + 9;
constexpr int M = 1e5 + 9;
constexpr int Z = 10;
int n, m, a[N];

int hd[N], tot;

struct edg {
  int v, nx;
} e[N * 2];

IL void add_edge (int u, int v) {
  e[++tot] = {v, hd[u]};
  hd[u] = tot;
}

pair<int, int> q[M];
int ans[M];

int lis[N], nxt[M];

IL int mex (const vi &v) {
  static int buc[Z + 3];
  me(buc, 0);
  for (int x : v) {
    ++buc[x];
  }
  int ret = 0;
  while (buc[ret]) {
    ++ret;
  }
  return ret;
}

int b[N], lst[Z], fst[Z], L;

IL int to (const int &x) {
  return x ^ 1 ? b[x - 1] : Z;
}

struct umap {
  int v[Z + 1];
  int operator [] (int x) const {
    return v[to(x)];
  }
  int& operator [] (int x) {
    return v[to(x)];
  }
} f[N], g[N][Z];

IL int at (int x, int y, int c) {
  return x > y ? 0 : g[y][c][x];
}

IL int at (int x, int y) {
  return x > y ? 0 : f[y][x];
}

void append (int c) {
  b[++L] = c;
  lst[c] = L;
  fst[c] > L && (fst[c] = L, 0);
  vi tmp{1};
  L (i, 0, Z - 1) {
    if (lst[i] && lst[i] < L) {
      tmp.eb(lst[i] + 1);
    }
  }
  sort(tmp.begin(), tmp.end(), greater<>());
  for (int x : tmp) {
    vi qwq;
    L (c, 0, Z - 1) {
      if (c == b[L]) {
        g[L][c][x] = at(x, L - 1, c);
        qwq.eb(g[L][c][x]);
      } else {
        int y = lst[c] + 1;
        if (y > x) {
          g[L][c][x] = at(x, L - 1, c) ^ at(y, L - 1) ^ f[L][y];
          qwq.eb(g[L][c][x]);
        }
      }
    }
    f[L][x] = mex(qwq);
    L (c, 0, Z - 1) {
      if (c ^ b[L] && lst[c] < x) {
        g[L][c][x] = f[L][x];
      }
    }
  }
}

int lab[N];

IL int pd (int u, int f) {
  int msk = 0, ban = 0;
  for (int i = hd[u], v; i; i = e[i].nx) {
    if ((v = e[i].v) ^ f) {
      int t = pd(v, u);
      msk |= ban & t;
      ban |= t;
    }
  }
  int l = msk ? 32 - __builtin_clz(msk) : 0;
  lab[u] = __builtin_ctz((ban >> l) + 1) + l;
  assert(lab[u] <= 20);
  return (ban >> lab[u] | 1) << lab[u];
}

bool vis[N];

int mp[2][N];

struct vmap {
  int v[Z + 1], *p;
  int& operator [] (int x) {
    return v[p[x]];
  }
  int operator [] (int x) const {
    return v[p[x]];
  }
  int safe (int x) {
    return x ? v[p[x]] : 0;
  }
} F[2][N], G[2][N][Z];

int ff[2][N][Z], len[2][N];

int op, sq[N], dfc;

void dfs (int u, int f) {
  sq[++dfc] = u;
  int c = a[u];
  int memlst = lst[c];
  int memfst = fst[c];
  append(c);
  len[op][u] = L;
  mc(ff[op][u], fst);
  F[op][u].v[Z] = at(1, L);
  L (i, 0, Z - 1) {
    G[op][u][i].v[Z] = at(1, L, i);
  }
  L (i, 0, Z - 1) {
    if (1 < fst[i] && fst[i] <= L) {
      F[op][u].v[i] = at(1, fst[i] - 1);
      L (j, 0, Z - 1) {
        G[op][u][j].v[i] = at(1, fst[i] - 1, j);
      }
    }
  }
  for (int i = hd[u], v; i; i = e[i].nx) {
    if ((v = e[i].v) ^ f && !vis[v]) {
      dfs(v, u);
    }
  }
  lst[c] = memlst;
  fst[c] = memfst;
  --L;
}

int col[N];

struct vmap2 {
  int v[Z + 1][Z + 1];
  int get (int x, int y) const {
    return v[mp[0][x]][mp[1][y]];
  }
  int& get (int x, int y) {
    return v[mp[0][x]][mp[1][y]];
  }
} H, W[Z];

void dfz (int u) {
  vis[u] = true;
  op = 0;
  dfs(u, 0);
  op = 1;
  col[u] = u;
  vi Rt;
  for (int i = hd[u], v; i; i = e[i].nx) {
    if (!vis[v = e[i].v]) {
      dfc = 0;
      dfs(v, 0);
      int rt = v;
      L (i, 1, dfc) {
        if (lab[sq[i]] > lab[rt]) {
          rt = sq[i];
        }
      }
      assert(rt != u);
      assert(lab[rt] < lab[u]);
      Rt.eb(rt);
      L (i, 1, dfc) {
        col[sq[i]] = rt;
      }
    }
  }
  int _ = lis[u];
  while (_) {
    int id = _;
    _ = nxt[_];
    auto [x, y] = q[id];
    if (col[x] == col[y]) {
      nxt[id] = lis[col[x]];
      lis[col[x]] = id;
      continue;
    }
    if (y == u) {
      swap(x, y);
    }
    int l1 = len[0][x];
    int l2 = len[1][y];
    mp[0][l1] = mp[1][l2] = Z;
    vi tmp0, tmp1;
    tmp0.eb(l1);
    tmp1.eb(l2);
    L (i, 0, Z - 1) {
      int p = ff[0][x][i];
      if (1 < p && p <= l1) {
        mp[0][p - 1] = i;
        tmp0.eb(p - 1);
      }
      p = ff[1][y][i];
      if (1 < p && p <= l2) {
        mp[1][p - 1] = i;
        tmp1.eb(p - 1);
      }
    }
    auto qwq = [&] (int p, int q) -> int {
      return !p || !q ? (p ? F[0][x][p] : (q ? F[1][y][q] : 0)) : H.get(p, q);
    }; 
    sort(tmp0.begin(), tmp0.end());
    sort(tmp1.begin(), tmp1.end());
    vi whq;
    whq.reserve(10);
    for (int p : tmp0) {
      for (int q : tmp1) {
        L (c, 0, Z - 1) {
          int v = G[0][x][c][p] ^ G[1][y][c][q];
          int pp = min(p + 1, ff[0][x][c]);
          int qq = min(q + 1, ff[1][y][c]);
          if (pp <= p || qq <= q) {
            W[c].get(p, q) = v ^ F[0][x].safe(pp - 1) ^ F[1][y].safe(qq - 1) ^ qwq(pp - 1, qq - 1);
            whq.eb(W[c].get(p, q));
          } 
        }
        int SG = H.get(p, q) = mex(whq);
        whq.clear();
        L (c, 0, Z - 1) {
          if (ff[0][x][c] > p && ff[1][y][c] > q) {
            W[c].get(p, q) = SG;
          }
        }
      }
    }
    if (H.get(l1, l2)) {
      L (i, 0, Z - 1) {
        if (ff[0][x][i] <= l1 || ff[1][y][i] <= l2) {
          ans[id] += !W[i].get(l1, l2);
        }
      }
    } 
  }
  for (int v : Rt) {
    dfz(v);
  }
}

signed main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  char ch;
  do {
    cin.get(ch);
  } while (ch < '0' || ch > '9');
  L (i, 1, n) {
    a[i] = ch ^ 48;
    cin.get(ch);
  }
  L (i, 1, n - 1) {
    int u, v;
    cin >> u >> v;
    add_edge(u, v);
    add_edge(v, u);
  }
  me(fst, 0x3f);
  pd(1, 0);
  int rt = 1;
  L (i, 2, n) {
    if (lab[i] > lab[rt]) {
      rt = i;
    }
  }
  L (i, 1, m) {
    int x, y;
    cin >> x >> y;
    if (x == y) {
      ans[i] = 1;
    } else {
      q[i] = {x, y};
      nxt[i] = lis[rt];
      lis[rt] = i;
    }
  }
  L (o, 0, 1) {
    L (i, 1, n) {
      F[o][i].p = mp[o];
      L (c, 0, Z - 1) {
        G[o][i][c].p = mp[o];
      }
    }
  }
  dfz(rt);
  L (i, 1, m) {
    if (ans[i]) {
      cout << "Alice " << ans[i] << '\n';
    } else {
      cout << "Bob\n";
    }
  }
  cerr << clock() << '\n';
}
// I love WHQ!