Problem:
Score : 600 points

Problem 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.

Constraints

1 ≤ N ≤ 100,000

0 ≤ M ≤ N-1

1 ≤ a_i ≤ 10^9

0 ≤ x_i,y_i ≤ N-1

The given graph is a forest.

All input values are integers.

Input

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

Output

Print the minimum total cost required to make the forest connected, or print Impossible if it is impossible.

Sample Input 1

7 5
1 2 3 4 5 6 7
3 0
4 0
1 2
1 3
5 6

Sample Output 1

7

If we connect vertices 0 and 5, the graph becomes connected, for the cost of 1 + 6 = 7 dollars.

Sample Input 2

5 0
3 1 4 1 5

Sample Output 2

Impossible

We can't make the graph connected.

Sample Input 3

1 0
5

Sample Output 3

0

The graph is already connected, so we do not need to add any edges.

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;

namespace AtCoder
{
    class Node
    {
        public readonly int id;
        private Node parent;
        private List<Node> children;
        private int rank;
        public Node(int id)
        {
            this.id = id;
            parent = null;
            children = new List<Node>();
            rank = 0;
        }
        public Node Find()
        {
            if (parent != null)
            {
                var p = parent.Find();
                if (parent != p)
                {
                    p.children.Add(this);
                    parent = p;
                }
                return p;
            }
            else
            {
                return this;
            }
        }
        public static void Unite(Node a, Node b)
        {
            Node p = a.Find();
            Node q = b.Find();
            if (q.rank > p.rank)
            {
                q.children.Add(p);
                q.rank = Math.Max(p.rank + 1, q.rank);
                p.parent = q;
            }
            else
            {
                p.children.Add(q);
                p.rank = Math.Max(q.rank + 1, p.rank);
                q.parent = p;
            }
        }
    }
    class Program
    {
        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }

        private static long? Solve(int N, long[] a, Node[] nodes)
        {
            var islands = new Dictionary<int, List<long>>();
            foreach (var node in nodes)
            {
                int id = node.Find().id;
                if (!islands.ContainsKey(id)) { islands[id] = new List<long>(); }
                islands[id].Add(a[node.id]);
            }
            int n = islands.Count;
            if (n == 1) { return 0; }
            long ans = 0;
            var values2 = new List<long>();
            foreach (var values1 in islands.Values)
            {
                values1.Sort();
                ans += values1[0];
                values2.AddRange(values1.Skip(1));
            }
            values2.Sort();
            if (values2.Count >= n - 2)
            {
                return ans + values2.Take(n - 2).Sum();
            }
            return null;
        }
        static void Main(string[] args)
        {
            int[] values1 = ReadInts();
            int N = values1[0];
            int M = values1[1];
            long[] a = ReadLongs();
            var nodes = new Node[N];
            for (int i = 0; i < N; ++i) { nodes[i] = new Node(i); }
            for (int i = 0; i < M; ++i)
            {
                int[] values2 = ReadInts();
                int x = values2[0];
                int y = values2[1];
                Node.Unite(nodes[x], nodes[y]);
            }
            long? ans = Solve(N, a, nodes);
            Console.WriteLine(ans.HasValue ? ans.Value.ToString() : "Impossible");
        }
    }
}