#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmin(T& a, const T& b) {
  if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
  if (a < b) a = b;
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T> >;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
  os << p.first << ',' << p.second;
  return os;
}
template <class T, class U>
istream& operator>>(istream& is, pair<T, U>& p) {
  is >> p.first >> p.second;
  return is;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (int i = 0; i < vec.size(); i++) {
    os << vec[i];
    if (i + 1 < vec.size()) os << ' ';
  }
  return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (int i = 0; i < vec.size(); i++) is >> vec[i];
  return is;
}
void fastio() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(20);
}
namespace Math {
template <int MOD>
struct ModInt {
  long long val;
  ModInt() : val(0ll) {}
  ModInt(const long long& v) : val(((v % MOD) + MOD) % MOD) {}
  bool operator==(const ModInt& x) const { return val == x.val; }
  bool operator!=(const ModInt& x) const { return !(*this == x); }
  bool operator<(const ModInt& x) const { return val < x.val; }
  bool operator>(const ModInt& x) const { return val > x.val; }
  bool operator>=(const ModInt& x) const { return !(*this < x); }
  bool operator<=(const ModInt& x) const { return !(*this > x); }
  ModInt& operator+=(const ModInt& x) {
    if ((val += x.val) >= MOD) val -= MOD;
    return *this;
  }
  ModInt& operator-=(const ModInt& x) {
    if ((val += MOD - x.val) >= MOD) val -= MOD;
    return *this;
  }
  ModInt& operator*=(const ModInt& x) {
    (val *= x.val) %= MOD;
    return *this;
  }
  ModInt operator+(const ModInt& x) const { return ModInt(*this) += x; }
  ModInt operator-(const ModInt& x) const { return ModInt(*this) -= x; }
  ModInt operator*(const ModInt& x) const { return ModInt(*this) *= x; }
  friend istream& operator>>(istream& i, ModInt& x) {
    long long v;
    i >> v;
    x = v;
    return i;
  }
  friend ostream& operator<<(ostream& o, const ModInt& x) {
    o << x.val;
    return o;
  }
};
template <int MOD>
ModInt<MOD> pow(ModInt<MOD> a, long long x) {
  ModInt<MOD> res = ModInt<MOD>(1ll);
  while (x) {
    if (x & 1) res *= a;
    x >>= 1;
    a = a * a;
  }
  return res;
}
constexpr int MOD = 1e9 + 7;
using mint = ModInt<MOD>;
vector<mint> inv, fac, facinv;
ModInt<MOD> nCr(int n, int r) {
  assert(!(n < r));
  assert(!(n < 0 || r < 0));
  return fac[n] * facinv[r] * facinv[n - r];
}
void init(int SIZE) {
  fac.resize(SIZE + 1);
  inv.resize(SIZE + 1);
  facinv.resize(SIZE + 1);
  fac[0] = inv[1] = facinv[0] = mint(1ll);
  for (int i = 1; i <= SIZE; i++) fac[i] = fac[i - 1] * mint(i);
  for (int i = 2; i <= SIZE; i++)
    inv[i] = mint(0ll) - mint(MOD / i) * inv[MOD % i];
  for (int i = 1; i <= SIZE; i++) facinv[i] = facinv[i - 1] * inv[i];
  return;
}
template <class T>
int digit(T x) {
  int res = 0;
  while (x) {
    x /= T(10);
    res++;
  }
  return res;
}
}  // namespace Math
namespace DS {
template <class T>
struct RangeSum {
  vector<T> vec;
  RangeSum() {}
  RangeSum(vector<T> elems) : vec(elems) {
    for (int i = 1; i < vec.size(); i++) {
      vec[i] += vec[i - 1];
    }
  }
  T sum(int l, int r) {
    if (l > r) return T(0);
    if (l == 0)
      return vec[r];
    else
      return vec[r] - vec[l - 1];
  }
};
template <class T>
struct BIT {
  int N;
  vector<T> bit;
  BIT(int N) : N(N) { bit = vector<T>(N + 1, T(0)); }
  void add(int i, T x) {
    i++;
    while (i <= N) {
      bit[i] += x;
      i += i & -i;
    }
    return;
  }
  T sum(int i) {
    i++;
    T res = T(0);
    while (i > 0) {
      res += bit[i];
      i -= i & -i;
    }
    return res;
  }
  T sum(int l, int r) {
    assert(l <= r);
    if (l == 0)
      return sum(r);
    else
      return sum(r) - sum(l - 1);
  }
};
}  // namespace DS
namespace Util {
template <class T>
struct SlideMin {
  vector<T> v;
  deque<int> deq;
  SlideMin(vector<T>& v) : v(v) {}
  void add(int id) {
    while (!deq.empty() && v[deq.back()] >= v[id]) deq.pop_back();
    deq.push_back(id);
  }
  T get(int id) {
    while (!deq.empty() && deq.front() < id) deq.pop_front();
    assert(!deq.empty());
    return v[deq.front()];
  }
};
template <class T>
struct SlideMax {
  vector<T> v;
  deque<int> deq;
  SlideMax(vector<T>& v) : v(v) {}
  void add(int id) {
    while (!deq.empty() && v[deq.back()] <= v[id]) deq.pop_back();
    deq.push_back(id);
  }
  T get(int id) {
    while (!deq.empty() && deq.front() < id) deq.pop_front();
    assert(!deq.empty());
    return v[deq.front()];
  }
};
}  // namespace Util
int N, M;
vector<int> D;
struct edge {
  int from, to, id;
  edge() {}
  edge(int from, int to, int id) : from(from), to(to), id(id) {}
};
vector<edge> G[100100];
int u[200100], v[200100];
int eid[200100];
int col[200100];
int cost[200100];
signed main() {
  fastio();
  memset(col, -1, sizeof(col));
  cin >> N >> M;
  D.resize(N);
  cin >> D;
  for (int i = 0; i < M; i++) {
    cin >> u[i] >> v[i];
    u[i]--;
    v[i]--;
    G[u[i]].push_back(edge(u[i], v[i], i));
    G[v[i]].push_back(edge(v[i], u[i], i));
  }
  for (int i = 0; i < N; i++) {
    bool found = false;
    for (int j = 0; j < G[i].size(); j++) {
      int u = G[i][j].to;
      if (D[u] <= D[i]) {
        found = true;
        eid[i] = G[i][j].id;
        break;
      }
    }
    if (!found) {
      cout << -1 << endl;
      return 0;
    }
  }
  for (int i = 0; i < N; i++) {
    int U = u[eid[i]];
    int V = v[eid[i]];
    cost[eid[i]] = max(D[U], D[V]);
    if (col[U] == -1) {
      if (col[V] == -1) {
        col[V] = 0;
        col[U] = 1;
      } else {
        col[U] = (col[V] ^ 1);
      }
    } else if (col[V] == -1) {
      col[V] = (col[U] ^ 1);
    }
  }
  for (int i = 0; i < M; i++) {
    if (cost[i] == 0) cost[i] = 1000000000;
  }
  for (int i = 0; i < N; i++) {
    if (col[i])
      cout << 'B';
    else
      cout << 'W';
  }
  cout << endl;
  for (int i = 0; i < M; i++) {
    cout << cost[i] << endl;
  }
  return 0;
}
