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 Rust (1.15.1) (judge verdict: Wrong Answer)

macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; input_inner ! { iter , $ ( $ r ) * } } ; ( iter = $ iter : ident , $ ( $ r : tt ) * ) => { let s = { use std :: io :: Read ; let mut s = String :: new ( ) ; std :: io :: stdin ( ) . read_to_string ( & mut s ) . unwrap ( ) ; s } ; let mut $ iter = s . split_whitespace ( ) ; input_inner ! { $ iter , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let s = { use std :: io :: Read ; let mut s = String :: new ( ) ; std :: io :: stdin ( ) . read_to_string ( & mut s ) . unwrap ( ) ; s } ; let mut iter = s . split_whitespace ( ) ; input_inner ! { iter , $ ( $ r ) * } } ; }
macro_rules ! input_inner { ( $ iter : expr ) => { } ; ( $ iter : expr , ) => { } ; ( $ iter : expr , mut $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let mut $ var = read_value ! ( $ iter , $ t ) ; input_inner ! { $ iter $ ( $ r ) * } } ; ( $ iter : expr , mut $ var : ident $ ( $ r : tt ) * ) => { input_inner ! { $ iter , mut $ var : usize $ ( $ r ) * } } ; ( $ iter : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ iter , $ t ) ; input_inner ! { $ iter $ ( $ r ) * } } ; ( $ iter : expr , $ var : ident $ ( $ r : tt ) * ) => { input_inner ! { $ iter , $ var : usize $ ( $ r ) * } } ; }
macro_rules ! read_value { ( $ iter : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ iter , $ t ) ) ,* ) } ; ( $ iter : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ iter , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ iter : expr , { chars : $ base : expr } ) => { read_value ! ( $ iter , String ) . chars ( ) . map ( | c | ( c as u8 - $ base as u8 ) as usize ) . collect ::< Vec < usize >> ( ) } ; ( $ iter : expr , { char : $ base : expr } ) => { read_value ! ( $ iter , { chars : $ base } ) [ 0 ] } ; ( $ iter : expr , chars ) => { read_value ! ( $ iter , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ iter : expr , char ) => { read_value ! ( $ iter , chars ) [ 0 ] } ; ( $ iter : expr , usize1 ) => { read_value ! ( $ iter , usize ) - 1 } ; ( $ iter : expr , $ t : ty ) => { $ iter . next ( ) . unwrap ( ) . parse ::<$ t > ( ) . unwrap ( ) } ; }
pub mod at {
    use std;
    pub struct UnionFind {
        parents: Vec<isize>,
    }
    use std::collections::HashMap;
    impl UnionFind {
        pub fn new(n: usize) -> UnionFind {
            let parents = vec![-1; n];
            UnionFind { parents: parents }
        }
        pub fn find(&mut self, x: usize) -> usize {
            if self.parents[x] < 0 {
                x
            } else {
                let xx = self.parents[x] as usize;
                let y = self.find(xx);
                self.parents[x] = y as isize;
                y
            }
        }
        pub fn unite(&mut self, x: usize, y: usize) -> bool {
            use std::mem::swap;
            let mut x = self.find(x);
            let mut y = self.find(y);
            if x == y {
                return false;
            }
            if self.parents[x] > self.parents[y] {
                swap(&mut x, &mut y);
            }
            self.parents[x] += self.parents[y];
            self.parents[y] = x as isize;
            true
        }
        pub fn size(&mut self, x: usize) -> usize {
            let x = self.find(x);
            (-self.parents[x]) as usize
        }
        pub fn same(&mut self, x: usize, y: usize) -> bool {
            self.find(x) == self.find(y)
        }
        pub fn members(&mut self, x: usize) -> Vec<usize> {
            let root = self.find(x);
            (0..self.parents.len())
                .into_iter()
                .filter(|i| self.find(*i) == root)
                .collect::<Vec<usize>>()
        }
        pub fn roots(&mut self) -> Vec<usize> {
            (0..self.parents.len())
                .into_iter()
                .filter(|i| self.parents[*i] < 0)
                .collect::<Vec<usize>>()
        }
        pub fn all_group_members(&mut self) -> HashMap<usize, Vec<usize>> {
            let mut groups_map = HashMap::new();
            for x in 0..self.parents.len() {
                let r = self.find(x);
                groups_map.entry(r).or_insert(vec![]).push(x);
            }
            groups_map
        }
    }
    use std::cmp::Ordering;
    #[derive(Eq, PartialEq, Clone, Debug)]
    pub struct Rev<T>(pub T);
    impl<T: PartialOrd> PartialOrd for Rev<T> {
        fn partial_cmp(&self, other: &Rev<T>) -> Option<Ordering> {
            other.0.partial_cmp(&self.0)
        }
    }
    impl<T: Ord> Ord for Rev<T> {
        fn cmp(&self, other: &Rev<T>) -> Ordering {
            other.0.cmp(&self.0)
        }
    }
}
use at::*;
use std::collections::BinaryHeap;
fn main() {
    input! { n, m, a: [usize; n], xy: [(usize,usize); m] };
    let mut uf = UnionFind::new(n);
    for &(x, y) in xy.iter() {
        uf.unite(x, y);
    }
    let groups_map = uf.all_group_members();
    let mut used = vec![false; n];
    let mut ai = (0..n).map(|i| (a[i], i)).collect::<Vec<_>>();
    ai.sort();
    let mut heap = BinaryHeap::new();
    let r = uf.find(ai[0].1);
    let mut ans = 0;
    for j in 0..n {
        let (c, i) = ai[j];
        if used[i] {
            continue;
        }
        if uf.same(r, i) {
            for &x in &groups_map[&uf.find(i)] {
                used[x] = true;
                heap.push(Rev((a[x], x)));
            }
        } else {
            ans += c;
            uf.unite(r, i);
            if let Some(r) = heap.pop() {
                let (d, k) = r.0;
                ans += d;
                for &x in &groups_map[&uf.find(k)] {
                    used[x] = true;
                    if x != k {
                        heap.push(Rev((a[x], x)));
                    }
                }
            } else {
                break;
            }
        }
    }
    if uf.size(r) == n {
        println!("{}", ans);
    } else {
        println!("Impossible");
    }
}