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
