output_description: Print the minimum total cost required to make the forest connected, or print
  `Impossible` if it is impossible.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      a_0 a_1 .. a_{N-1}
      x_1 y_1
      x_2 y_2
      :
      x_M y_M
attempt: import sys
  
  readline = sys.stdin.readline
  MOD = 10**9 + 7
  INF = float("INF")
  sys.setrecursionlimit(10**5)
  
  import heapq
  
  
  class PriorityQueue:
      class Reverse:
          def __init__(self, val):
              self.val = val
  
          def __lt__(self, other):
              return self.val > other.val
  
          def __repr__(self):
              return repr(self.val)
  
      def __init__(self, x=None, desc=False):
          if not x:
              x = []
          if desc:
              for i in range(len(x)):
                  x[i] = self.Reverse(x[i])
          self._desc = desc
          self._container = x
          heapq.heapify(self._container)
  
      @property
      def is_empty(self):
          return not self._container
  
      def pop(self):
          if self._desc:
              return heapq.heappop(self._container).val
          else:
              return heapq.heappop(self._container)
  
      def push(self, item):
          if self._desc:
              heapq.heappush(self._container, self.Reverse(item))
          else:
              heapq.heappush(self._container, item)
  
      def top(self):
          if self._desc:
              return self._container[0].val
          else:
              return self._container[0]
  
      def sum(self):
          return sum(self._container)
  
      def __len__(self):
          return len(self._container)
  
  
  def main():
      def solve():
          from collections import deque, defaultdict
  
          N, M = map(int, readline().split())
          a = list(map(int, readline().split()))
          edge = defaultdict(list)
          ans = 0
  
          for _ in range(M):
              x, y = map(int, readline().split())
              edge[x].append(y)
              edge[y].append(x)
  
          visited = [False] * N
  
          def bfs(s):
              que = deque()
              pq = PriorityQueue()
              que.append(s)
              visited[s] = True
              while que:
                  cur = que.popleft()
                  pq.push(a[cur])
                  for nx in edge[cur]:
                      if not visited[nx]:
                          visited[nx] = True
                          que.append(nx)
              return pq
  
          costs = bfs(0)
  
          for i in range(1, N):
              if not visited[i]:
                  next_costs = bfs(i)
                  if not costs:
                      return -1
                  ans += costs.pop()
                  ans += next_costs.pop()
  
                  while next_costs:
                      costs.push(next_costs.pop())
          return ans
  
      ans = solve()
      if ans == -1:
          print("Impossible")
      else:
          print(ans)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  You are given a forest with N vertices and M edges. The vertices are numbered
  0 through N-1. The edges are given in the format (x_i,y_i), which means that
  Vertex x_i and y_i are connected by an edge.
  
  Each vertex i has a value a_i. You want to add edges in the given forest so
  that the forest becomes connected. To add an edge, you choose two different
  vertices i and j, then span an edge between i and j. This operation costs a_i
  + a_j dollars, and afterward neither Vertex i nor j can be selected again.
  
  Find the minimum total cost required to make the forest connected, or print
  `Impossible` if it is impossible.
samples: [{"input": "7 5\n    1 2 3 4 5 6 7\n    3 0\n    4 0\n    1 2\n    1 3\n    5 6", "output": "7\n    \n\nIf we connect vertices 0 and 5, the graph becomes connected, for the cost of 1\n+ 6 = 7 dollars.\n\n* * *"}, {"input": "5 0\n    3 1 4 1 5", "output": "Impossible\n    \n\nWe can't make the graph connected.\n\n* * *"}, {"input": "1 0\n    5", "output": "0\n    \n\nThe graph is already connected, so we do not need to add any edges."}]