// Original C++ solution (slower):
#include <iostream>

#include <vector>

#include <algorithm>

#define llint long long



using namespace std;



llint parent[100005];

llint N, M;

llint a[100005];

vector<llint> cmp[100005];



void init(){

	for(llint i = 0; i < N; i++) parent[i] = i;

}



llint root(llint i)

{

	if(parent[i] == i) return i;

	return parent[i] = root(parent[i]);

}



void unite(llint i, llint j)

{

	llint root_i = root(i), root_j = root(j);

	if(root_i == root_j) return;

	parent[root_i] = root_j;

}



bool same(llint i, llint j)

{

	return root(i) == root(j);

}



int main(void)

{

	cin >> N >> M;

	for(llint i = 0; i < N; i++) cin >> a[i];

	init();

	

	llint x, y;

	for(llint i = 0; i < M; i++){

		cin >> x >> y;

		unite(x, y);

	}

	

	for(llint i = 0; i < N; i++) root(i);

	for(llint i = 0; i < N; i++){

		cmp[parent[i]].push_back(a[i]);

	}

	

	llint cnt = 0, ccnt = 0;

	for(llint i = 0; i < N; i++){

		if(cmp[i].size() == 1) cnt++;

		if(cmp[i].size() > 0) ccnt++;

	}

	

	if(ccnt == 1){

		cout << 0 << endl;

		return 0;

	}

	if(2*(N-M-1) > N){

		cout << "Impossible" << endl;

		return 0;

	}

	

	llint sum = 0;

	for(llint i = 0; i < N; i++){

		if(cmp[i].size() > 0){

			sort(cmp[i].begin(), cmp[i].end());

			sum += cmp[i][0];

		}

	}

	

	vector<llint> vec;

	for(llint i = 0; i < N; i++){

		if(cmp[i].size() > 1){

			for(llint j = 1; j < cmp[i].size(); j++) vec.push_back(cmp[i][j]);

		}

	}

	sort(vec.begin(), vec.end());

	

	for(llint i = 0; i < 2*(N-M-1)-(N-M); i++) sum += vec[i];

	cout << sum << endl;

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <string>

#include <vector>

#include <algorithm>

#include <utility>

#include <map>

#define llint long long

#define inf 1e18



using namespace std;

typedef pair<llint, llint> P;



struct UnionFind{

	int size;

	vector<int> parent;

	

	UnionFind(){}

	UnionFind(int size){

		this->size = size;

		parent.resize(size+1);

		init();

	}

	void init(){

		for(int i = 0; i <= size; i++) parent[i] = i;

	}

	int root(int i){

		if(parent[i] == i) return i;

		return parent[i] = root(parent[i]);

	}

	bool same(int i, int j){

		return root(i) == root(j);

	}

	void unite(int i, int j){

		int root_i = root(i), root_j = root(j);

		if(root_i == root_j) return;

		parent[root_i] = root_j;

	}

};



llint n, m;

llint a[100005];

UnionFind uf(100005);

map<llint, vector<llint> > mp;

vector<llint> avec;



int main(void)

{

	ios::sync_with_stdio(0);

	cin.tie(0);

	

	cin >> n >> m;

	for(int i = 1; i <= n; i++) cin >> a[i];

	llint u, v;

	for(int i = 1; i <= m; i++){

		cin >> u >> v;

		u++, v++;

		uf.unite(u, v);

	}

	

	if(2*(n-m-1) > n){

		cout << "Impossible" << endl;

		return 0;

	}

	

	llint ans = 0;

	for(int i = 1; i <= n; i++){

		mp[uf.root(i)].push_back(a[i]);

	}

	if(mp.size() == 1){

		cout << 0 << endl;

		return 0;

	}

	for(auto it = mp.begin(); it != mp.end(); it++){

		vector<llint> &vec = it->second;

		sort(vec.begin(), vec.end());

		ans += vec[0];

		for(int i = 1; i < vec.size(); i++) avec.push_back(vec[i]);

	}

	sort(avec.begin(), avec.end());

	

	for(int i = 0; i < (n-m-2); i++) ans += avec[i];

	cout << ans << endl;

	

	return 0;

}

// Fastest known solution for this problem: