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)

#[allow(unused_imports)]
use std::cmp::{Ordering};

#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};

#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};

#[allow(unused_imports)]
use std::iter::FromIterator;

#[allow(unused_macros)]
macro_rules! min {
    ($x: expr) => ($x);
    ($x: expr, $($z: expr),+) => {{
        std::cmp::min($x, min!($($z),*))
    }}
}

#[allow(unused_macros)]
macro_rules! max {
    ($x: expr) => ($x);
    ($x: expr, $($z: expr),+) => {{
        std::cmp::max($x, max!($($z),*))
    }}
}

#[allow(unused_macros)]
macro_rules! get { 
    ([$t: ty]) => { 
        { 
            let mut line = String::new(); 
            stdin().read_line(&mut line).unwrap(); 
            line.split_whitespace().map(|t|t.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    };
    ([$t: ty];$n: expr) => {
        (0..$n).map(|_|get!([$t])).collect::<Vec<_>>()
    };
    ($t: ty) => {
        {
            let mut line = String::new();
            stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t: ty),*) => {
        { 
            let mut line = String::new();
            stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ($(iter.next().unwrap().parse::<$t>().unwrap(),)*)
        }
    };
    ($t: ty; $n: expr) => {
        (0..$n).map(|_|get!($t)).collect::<Vec<_>>()
    };
    ($($t: ty),*; $n: expr) => {
        (0..$n).map(|_|get!($($t),*)).collect::<Vec<_>>()
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        #[cfg(debug_assertions)]
        writeln!(&mut std::io::stderr(), concat!("[DEBUG] ", $(stringify!($a), "={:?} "),*), $($a),*).unwrap();
    }
}

const BIG_STACK_SIZE: bool = true;

#[allow(dead_code)]
fn main() {
    use std::thread;
    if BIG_STACK_SIZE {
        thread::Builder::new()
            .stack_size(32 * 1024 * 1024)
            .name("solve".into())
            .spawn(solve)
            .unwrap()
            .join()
            .unwrap();
    } else {
        solve();
    }
}

#[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)
    }
}

struct Tree<T>(pub BinaryHeap<T>);

impl<T: PartialEq+Ord> PartialEq for Tree<T> {
    fn eq(&self, other: &Self) -> bool {
        self.0.peek() == other.0.peek()
    }
}

impl<T: PartialEq+Ord> Eq for Tree<T>{}

impl<T: PartialOrd+Ord> PartialOrd for Tree<T> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.0.peek().unwrap().partial_cmp(&other.0.peek().unwrap())
    }
}

impl<T: Ord> Ord for Tree<T> {
    fn cmp(&self, other: &Self) -> Ordering {
        self.0.peek().unwrap().cmp(&other.0.peek().unwrap())
    }
}

fn solve() {
    let (n,m) = get!(usize, usize);
    let a = get!([usize]);
    let xy = get!(usize, usize; m);

    if m == 0 {
        if n == 1 {
            println!("0");
        } else {
            println!("Impossible");
        }
        return;
    }

    let mut undecided = BinaryHeap::new();
    let mut undecided_ones = Vec::new();
    
    let mut nodes = vec![Vec::new(); n];
    for (x,y) in xy {
        nodes[x].push(y);
        nodes[y].push(x);
    }

    let mut queue = VecDeque::new();
    let mut visited = vec![false; n];
    for i in 0..n {
        if visited[i] {
            continue;
        }
        let mut heap = BinaryHeap::new();
        heap.push(Rev(a[i]));
        queue.push_back(i);
        visited[i] = true;
        while let Some(node) = queue.pop_front() {
            for &next in &nodes[node] {
                if visited[next] {
                    continue;
                }
                heap.push(Rev(a[next]));
                queue.push_back(next);
                visited[next] = true;
            }
        }
        if heap.len() == 1 {
            undecided_ones.push(a[i]);
        } else {
            undecided.push(Tree(heap));
        }
    }
    let mut decided = BinaryHeap::new();
    let mut tmp = BinaryHeap::new();
    let mut i = 0;
    let mut mxi = 0;
    let mut mx = 0;
    while let Some(tree) = undecided.pop() {
        if mx < tree.0.len() {
            mx = tree.0.len();
            mxi = i;
        }
        i += 1;
        tmp.push(tree);
    }
    i = 0;
    while let Some(tree) = tmp.pop() {
        if i == mxi {
            decided = tree.0;
        } else {
            undecided.push(tree);
        }
        i += 1;
    }

    let mut sum = 0;
    while let Some(Tree(mut heap)) = undecided.pop() {
        let Rev(cost1) = heap.pop().unwrap();
        let Rev(cost2) = decided.pop().unwrap();
        sum += cost1 + cost2;
        for Rev(cost) in heap {
            decided.push(Rev(cost));
        }
    }

    if decided.len() < undecided_ones.len() {
        println!("-1");
        return;
    }

    for _ in 0..undecided_ones.len() {
        sum += decided.pop().unwrap().0;
    }
    sum += undecided_ones.into_iter().sum::<usize>();
    println!("{}", sum);
}