output_description: If there is no assignment satisfying the conditions, print a single line
  containing `-1`.
  
  If such an assignment exists, print one such assignment in the following
  format:
  
      
      
      S
      C_1
      C_2
      \vdots
      C_M
      
  
  Here,
  
    * the first line should contain the string S of length N. Its i-th character (1 \leq i \leq N) should be `W` if Vertex i is assigned white and `B` if it is assigned black.
    * The (i + 1)-th line (1 \leq i \leq M) should contain the integer weight C_i assigned to Edge i.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      D_1 D_2 ... D_N
      U_1 V_1
      U_2 V_2
      \vdots
      U_M V_M
attempt: def main():
      import sys
      from collections import deque
  
      input = sys.stdin.readline
  
      class UnionFind:
          def __init__(self, n):
              self.n = n
              self.root = [-1] * (n + 1)
              self.rnk = [0] * (n + 1)
  
          def find_root(self, x):
              if self.root[x] < 0:
                  return x
              else:
                  self.root[x] = self.find_root(self.root[x])
                  return self.root[x]
  
          def unite(self, x, y):
              x = self.find_root(x)
              y = self.find_root(y)
              if x == y:
                  return
              elif self.rnk[x] > self.rnk[y]:
                  self.root[x] += self.root[y]
                  self.root[y] = x
              else:
                  self.root[y] += self.root[x]
                  self.root[x] = y
                  if self.rnk[x] == self.rnk[y]:
                      self.rnk[y] += 1
  
          def isSameGroup(self, x, y):
              return self.find_root(x) == self.find_root(y)
  
          def size(self, x):
              return -self.root[self.find_root(x)]
  
      N, M = map(int, input().split())
      A = list(map(int, input().split()))
      edge = []
      for _ in range(M):
          u, v = map(int, input().split())
          edge.append((u, v))
  
      e2i = {}
      for i, e in enumerate(edge):
          u, v = e
          e2i[u * (N + 1) + v] = i
      adj = [[] for _ in range(N + 1)]
      ok = [0] * (N + 1)
      ans = [0] * M
      edge.sort(key=lambda e: max(e))
      UF = UnionFind(N + 1)
      adj = [[] for _ in range(N + 1)]
      for u, v in edge:
          if UF.isSameGroup(u, v):
              continue
          UF.unite(u, v)
          adj[u].append(v)
          adj[v].append(u)
          if A[u - 1] == A[v - 1]:
              ok[u] = 1
              ok[v] = 1
              ans[e2i[u * (N + 1) + v]] = A[u - 1]
          elif A[u - 1] < A[v - 1]:
              ok[v] = 1
              ans[e2i[u * (N + 1) + v]] = A[v - 1]
          else:
              ok[u] = 1
              ans[e2i[u * (N + 1) + v]] = A[u - 1]
      if sum(ok) != N:
          print(-1)
          exit()
      que = deque()
      que.append(1)
      seen = [0] * (N + 1)
      seen[1] = 1
      while que:
          v = que.popleft()
          for u in adj[v]:
              if seen[u] == 0:
                  seen[u] = seen[v] * (-1)
                  que.append(u)
      bw = ["B" if seen[i] == 1 else "W" for i in range(1, N + 1)]
      print("".join(bw))
      for a in ans:
          if a == 0:
              print(10**18)
          else:
              print(a)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  We have a connected undirected graph with N vertices and M edges. Edge i in
  this graph (1 \leq i \leq M) connects Vertex U_i and Vertex V_i
  bidirectionally. We are additionally given N integers D_1, D_2, ..., D_N.
  
  Determine whether the conditions below can be satisfied by assigning a color -
  white or black - to each vertex and an integer weight between 1 and 10^9
  (inclusive) to each edge in this graph. If the answer is yes, find one such
  assignment of colors and integers, too.
  
    * There is at least one vertex assigned white and at least one vertex assigned black.
    * For each vertex v (1 \leq v \leq N), the following holds.
      * The minimum cost to travel from Vertex v to a vertex whose color assigned is different from that of Vertex v by traversing the edges is equal to D_v.
  
  Here, the cost of traversing the edges is the sum of the weights of the edges
  traversed.
samples: [{"input": "5 5\n    3 4 3 5 7\n    1 2\n    1 3\n    3 2\n    4 2\n    4 5", "output": "BWWBB\n    4\n    3\n    1\n    5\n    2\n    \n\nAssume that we assign the colors and integers as the sample output, and let us\nconsider Vertex 5, for example. To travel from Vertex 5, which is assigned\nblack, to a vertex that is assigned white with the minimum cost, we should\nmake these moves: Vertex 5 \\to Vertex 4 \\to Vertex 2. The total cost of these\nmoves is 7, which satisfies the condition. We can also verify that the\ncondition is satisfied for other vertices.\n\n* * *"}, {"input": "5 7\n    1 2 3 4 5\n    1 2\n    1 3\n    1 4\n    2 3\n    2 5\n    3 5\n    4 5", "output": "-1\n    \n\n* * *"}, {"input": "4 6\n    1 1 1 1\n    1 2\n    1 3\n    1 4\n    2 3\n    2 4\n    3 4", "output": "BBBW\n    1\n    1\n    1\n    2\n    1\n    1"}]