#include <bits/stdc++.h>
#define rep(i, m, n) for(int i = m; i < (n); i++)
#define print(x) cout << (x) << endl;
#define printa(x,n) for(int i = 0; i < n; i++){ cout << (x[i]) << " ";} cout << endl;
#define printa2(x,m,n) for(int i = 0; i < m; i++){ for(int j = 0; j < n; j++){ cout << x[i][j] << " ";} cout << endl;}
#define printp(x,n) for(int i = 0; i < n; i++){ cout << "(" << x[i].first << ", " << x[i].second << ") "; } cout << endl;
#define INF (1e18)
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
typedef struct{
    int x;
    int y;
} P;
typedef struct{
    ll to;
    ll cost;
} edge;
typedef pair<ll, ll> lpair;

ll parent[200010];

ll root(ll x){
    if(x == parent[x]){
        return x;
    }else{
        return parent[x] = root(parent[x]);
    }
}

void unite(ll a, ll b){
    a = root(a);
    b = root(b);
    if(a == b){
        return;
    }
    parent[a] = b;
}

void same(ll a, ll b){
    if(root(a) == root(b)){
        print("Yes");
    }else{
        print("No");
    }
}

bool comp(lpair l1, lpair l2){
    if(l1.second == l2.second){
        return l1.first < l2.first;
    }
    return l1.second < l2.second;
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll N,M;
    ll a[100010];
    ll x[100010], y[100010];
    // vector<ll> tree[100010];
    cin >> N >> M;
    rep(i,0,N){
        cin >> a[i];
    }
    rep(i,0,M){
        cin >> x[i] >> y[i];
    }
    // rep(i,0,M){
    //     tree[x[i]].push_back(y[i]);
    //     tree[y[i]].push_back(x[i]);
    // }
    rep(i,0,N){
        parent[i] = i;
    }
    rep(i,0,M){
        unite(x[i], y[i]);
    }

    if(M == N-1){
        print(0);
        return 0;
    }
    ll num = 2 * (N - 1 - M);
    if(num > N){
        print("Impossible");
        return 0;
    }
    vector<lpair> lp;
    rep(i,0,N){
        lp.push_back(make_pair(a[i], root(i)));
    }
    sort(lp.begin(), lp.end(), comp);
    ll ans = 0;
    ans += lp[0].first;
    vector<ll> lp2;
    rep(i,1,N){
        if(lp[i-1].second != lp[i].second){
            ans += lp[i].first;
        }else{
            lp2.push_back(lp[i].first);
        }
    }
    sort(lp2.begin(), lp2.end());
    rep(i,0,N-M-2){
        ans += lp2[i];
    }

    // ll roots[100010] = {};
    // rep(i,0,N){
    //     roots[i] = root(i);
    // }
    // sort(roots, roots+N);
    // ll gn = 1;
    // rep(i,1,N){
    //     if(roots[i-1] != roots[i]) gn++;
    // }
    // print(gn);
    // printa(roots, N);
    // printa(a,N);
    // vector<lpair> lp;
    // rep(i,0,N){
    //     lp.push_back(make_pair(a[i], root(i)));
    // }
    // sort(lp.begin(), lp.end(), comp);
    // // printp(lp, N);
    // vector<lpair> lp2;
    // ll ans = 0;
    // ll cnt = 1;
    // ans += lp[0].first;
    // if(gn > N/2 + 1){
    //     print("Impossible");
    //     return 0;
    // }
    // if(M == N-1){
    //     print(0);
    //     return 0;
    // }
    // rep(i,1,N){
    //     if(lp[i-1].second != lp[i].second){
    //         ans += lp[i].second;
    //         cnt++;
    //     }else{
    //         lp2.push_back(make_pair(lp[i].first, lp[i].second));
    //     }
    // }
    // sort(lp2.begin(), lp2.end());
    // rep(i,0,gn-2){
    //     ans += lp2[i].first;

    // }
    print(ans);

    // rep(i,0,N){

    // }
    // ll is_check[100010] = {};
    // ll ans = 0;
    // ll cnt = 0;
    // if(M == N-1){
    //     print(0);
    //     return 0;
    // }else if()
    // if(gn > N/2 + 1){
    //     print("Impossible");
    //     return 0;
    // }
    // priority_queue< pair<ll, ll>, vector< pair<ll, ll> >, greater< pair<ll, ll> > > pq;
    // rep(i,0,N){
    //     pq.push(make_pair(a[i], i));
    // }
    // while(cnt < gn-1){
    //     lpair val = pq.top();
    //     pq.pop();
    //     ll cost = val.first;
    //     ll pos = val.second;


    // }
    // rep(t,0,gn-1){
    //     bool find_flg = false;
    //     ll group_num = -1;
    //     ll pos = -1;
    //     rep(i,0,N){
    //         ll tt = lp[i].second;
    //         if(is_check[tt] == 0 && !find_flg){
    //             is_check[tt] = 1;
    //             find_flg = true;
    //             group_num = mp[tt];
    //             pos = tt;
    //         }else if(is_check[tt] == 0 && find_flg){
    //             if(group_num != mp[tt]){
    //                 ans += (a[pos] + a[tt]);
    //                 is_check[tt] = 1;
    //                 cnt++;
    //                 break;
    //             }
    //         }
    //     }
    //     if(cnt == gn-1) break;
    // }
    // print(ans);
    // rep(i,0,N){

    // }






}


Measured memory_bytes: 6768