using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using static System.Console;
using static System.Convert;
using static System.Math;
//using Debug;
//using static System.Globalization.CultureInfo;
using System.Text;
class Program
{
    static void Main(string[] args)
    {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        Console.SetOut(sw);
        Solve();
        Console.Out.Flush();
        //WriteLine(Solve());
    }
    static int[] ar;
    static void Solve()
    {
        var nm = Input.ar;
        ar = Input.ar;
        if (nm[0]-1==nm[1])
        { WriteLine(0);return; }
        if(nm[0]<2*(nm[0]-nm[1]-1))
        { WriteLine("Impossible");return; }
        var uf = new Program.UnionFind(nm[0]);
        for(var i=0;i<nm[1];i++)
        {
            var xy = Input.ar;
            uf.Union(xy[0], xy[1]);
        }
        var res = 0L;
        var use = new bool[nm[0]];
        for(var i=0;i<nm[0];i++)
            if(!use[uf.min(i).v2])
            {
                use[uf.min(i).v2] = true;
                res += uf.min(i).v1;
            }
        var pq = new PriorityQueue<int>(false);
        for (var i = 0; i < nm[0]; i++)
            if (!use[i])
                pq.Enqueue(ar[i]);
        for (var i = 0; i < nm[0] - nm[1] - 2; i++)
            res += pq.Dequeue();
        WriteLine(res);
    }
    public class UnionFind
    {
        private int _num;
        private int[] _parent, _size, _rank;
            private Pair<int,int>[] _min;
        public UnionFind(int num)
        {
            _num = num;
            _parent = new int[num]; _size = new int[num]; _rank = new int[num];
            _min = new Pair<int,int>[num];
            for (var i = 0; i < num; i++) { _parent[i] = i; _size[i] = 1;_min[i] = new Pair<int, int>(ar[i],i); }
        }
        private int Find(int i)
            => i == _parent[i] ? i : (_parent[i] = Find(_parent[i]));
        public int Parent(int i)
            => Find(i);
        public int Size(int i)
            => _size[Find(i)];
        public Pair<int,int> min(int i)
            => _min[Find(i)];
        public bool Union(int v1, int v2)
        {
            v1 = Find(v1); v2 = Find(v2);
            if (v1 == v2) return false;
            _num--;
            if (_rank[v1] > _rank[v2])
            {
                _parent[v2] = v1;
                _size[v1] += _size[v2];
                _min[v1] = _min[v1] > _min[v2] ? _min[v2] : _min[v1];
            }
            else
            {
                _parent[v1] = v2;
                _size[v2] += _size[v1];
                _min[v2] = _min[v1] < _min[v2] ? _min[v1] : _min[v2];
                if (_rank[v1] == _rank[v2])
                    _rank[v2]++;
            }
            return true;
        }
        public bool IsSame(int v1, int v2)
            => Find(v1) == Find(v2);
    }
}

public class Input
{
    public static string read => ReadLine().Trim();
    public static int[] ar => read.Split(' ').Select(int.Parse).ToArray();
    public static int num => ToInt32(read);
    public static long[] arL => read.Split(' ').Select(long.Parse).ToArray();
    public static long numL => ToInt64(read);
    public static char[][] gred(int h)
        => Enumerable.Repeat(0, h).Select(_ => read.ToCharArray()).ToArray();
    public static int[] ar1D(int n)
        => Enumerable.Repeat(0, n).Select(_ => num).ToArray();
    public static long[] arL1D(int n)
        => Enumerable.Repeat(0, n).Select(_ => numL).ToArray();
    public static string[] strs(int n)
        => Enumerable.Repeat(0, n).Select(_ => read).ToArray();
    public static int[][] ar2D(int n)
        => Enumerable.Repeat(0, n).Select(_ => ar).ToArray();
    public static long[][] arL2D(int n)
        => Enumerable.Repeat(0, n).Select(_ => arL).ToArray();
    public static T getValue<T>(string g)
    {
        var t = typeof(T);
        if (t == typeof(int))
            return (T)(object)int.Parse(g);
        if (t == typeof(long))
            return (T)(object)long.Parse(g);
        if (t == typeof(string))
            return (T)(object)g;
        if (t == typeof(char))
            return (T)(object)char.Parse(g);
        if (t == typeof(double))
            return (T)(object)double.Parse(g);
        if (t == typeof(bool))
            return (T)(object)bool.Parse(g);
        return default(T);
    }
    public static string[] Make<T1, T2>(out T1 v1, out T2 v2)
    {
        var r = read.Trim().Split(' ');
        v1 = getValue<T1>(r[0]);
        v2 = getValue<T2>(r[1]);
        return r;
    }
    public static string[] Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3)
    {
        var r = Make(out v1, out v2);
        v3 = getValue<T3>(r[2]);
        return r;
    }
    public static string[] Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4)
    {
        var r = Make(out v1, out v2, out v3);
        v4 = getValue<T4>(r[3]);
        return r;
    }
    public static string[] Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5)
    {
        var r = Make(out v1, out v2, out v3, out v4);
        v5 = getValue<T5>(r[4]);
        return r;
    }
    public const long Inf = (long)1e18;
    public const double eps = 1e-6;
    public const string Alfa = "abcdefghijklmnopqrstuvwxyz";
    public const int MOD = 1000000007;
}

public class Pair<T1, T2> : IComparable<Pair<T1, T2>>
{
    public T1 v1 { get; set; }
    public T2 v2 { get; set; }
    public Pair() : this(default(T1), default(T2)) { }
    public Pair(T1 v1, T2 v2)
    { this.v1 = v1;this.v2 = v2; }

    public int CompareTo(Pair<T1, T2> p)
    {
        var c = Comparer<T1>.Default.Compare(v1, p.v1);
        if (c == 0)
            c = Comparer<T2>.Default.Compare(v2, p.v2);
        return c;
    }
    public override string ToString()
        => $"{v1.ToString()} {v2.ToString()}";
    public static bool operator >(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) == 1;
    public static bool operator >=(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) != -1;
    public static bool operator <(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) == -1;
    public static bool operator <=(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) != 1;
}

public class PriorityQueue<T> where T : IComparable<T>
{
    public List<T> _item;
    public int Count { get { return _item.Count; } }
    public bool IsMaxHeap { get; set; }
    public T Peek { get { return _item[0]; } }
    public PriorityQueue(bool IsMaxHeap = true,IEnumerable<T> list=null)
    {
        _item = new List<T>();
        this.IsMaxHeap = IsMaxHeap;
        if (list != null)
        {
            _item.AddRange(list);
            Build();
        }
    }
    private int Compare(int i, int j) => (IsMaxHeap ? 1 : -1) * _item[i].CompareTo(_item[j]);
    private void Swap(int i,int j) { var t = _item[i];_item[i] = _item[j];_item[j] = t; }
    private int Parent(int i)
        => (i - 1) >> 1;
    private int Left(int i)
        => (i << 1) + 1;
    public T Enqueue(T val)
    {
        int i = _item.Count;
        _item.Add(val);
        while (i > 0)
        {
            int p = Parent(i);
            if (Compare(i, p) > 0)
                Swap(i, p);
            i = p;
        }
        return val;
    }
    private void Heapify(int index)
    {
        for (int i = index, j; (j = Left(i)) < _item.Count; i = j)
        {
            if (j != _item.Count - 1 && Compare(j, j + 1) < 0) j++;
            if (Compare(i, j) < 0)
                Swap(i, j);
        }
    }
    public T Dequeue()
    {
        T val = _item[0];
        _item[0] = _item[_item.Count-1];
        _item.RemoveAt(_item.Count - 1);
        Heapify(0);
        return val;
    }
    private void Build()
    {
        for (var i = (_item.Count >> 1) - 1; i >= 0; i--)
            Heapify(i);
    }
}


Measured memory_bytes: 34268