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 Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

import Control.Applicative
import Control.Monad
import Data.Ix
import Data.List
import qualified Data.IntMap as IM

data Tree = Single Int | Tree Int Int | Repr Int

makeForest :: Int -> [Int] -> [[Int]] -> IM.IntMap Tree
makeForest n as = addEdge (IM.fromAscList $ zipWith (\a b -> (a,Single b)) (range (0,n-1)) as)
    where
        addEdge :: IM.IntMap Tree -> [[Int]] -> IM.IntMap Tree
        addEdge t [] = t
        addEdge t ([x,y]:es) = addEdge (IM.insert yi (Repr xi) $ IM.insert xi mergedTree t2) es
            where
                (xi,xt) = find x
                (yi,yt) = find y
                find r = case rt of
                    Repr r' -> find r'
                    _ -> (r,rt)
                    where rt = t IM.! r
                t1 = if x /= xi then IM.insert x (Repr xi) t else t
                t2 = if y /= yi then IM.insert y (Repr xi) t1 else t1
                mergedTree = case (xt,yt) of
                    (Single a,Single b) -> makeTree [a,b]
                    (Tree a1 a2,Single b) -> makeTree [a1,a2,b]
                    (Single a,Tree b1 b2) -> makeTree [a,b1,b2]
                    (Tree a1 a2,Tree b1 b2) -> makeTree [a1,a2,b1,b2]
                makeTree as = Tree m1 m2
                    where m1:m2:_ = sort as

main :: IO()
main = do
    [n,m] <- map read . words <$> getLine
    as <- map read . words <$> getLine
    es <- replicateM m $ map read . words <$> getLine
    putStrLn $ calcAns $ makeForest n as es
        where
            calcAns m
                | nTree == 1 = "0"
                | nSingle > 2 = "Impossible"
                | nSingle == 2 = show cost
                | nSingle == 1 = show (cost - max1)
                | nSingle == 0 = show (cost - max1 - max2)
                where
                    (nTree,nSingle,cost,max1,max2) = foldr count (0,0,0,0,0) m
                    count (Single a) (x,y,z,m1,m2) = (x+1,y+1,z+a,m1,m2)
                    count (Tree a b) (x,y,z,m1,m2) = (x+1,y,z+a+b,m1',m2')
                        where [_,m2',m1'] = sort [b,m2,m1]
                    count (Repr _) xy = xy