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 Ruby (2.3.3) (judge verdict: Runtime Error)

n,m=gets.split
n=n.to_i
m=m.to_i

arr=gets.split.map(&:to_i)

arr2=[]
arr3=Array.new(n,1000000)


n.times{
    
    arr2<<[]}

m.times{
    a,b=gets.split
    a=a.to_i
    b=b.to_i
    
    arr2[a]+=[b]
    arr2[b]+=[a]}
    
now=[0]




k=0
s=0
loop{
  
  loop{
     if arr3[k]==1000000 
      break
  else 
  k+=1
  end
      
      
  }
  
  
  arr3[k]=s
  now=[k]
  
  


                    loop{
                    
                    
                        ll=now.length
                        
                            tt=0
                                ll.times{
                                    arr3[now[tt]]=s
                                
                                   
                                   
                                  now+=arr2[now[tt]] 
                                  tt+=1
                                   
                                }
                                
                        now=now[ll..-1].uniq  
                        
                        jj=now.length
                            ss=0
                            
                            
                            jj.times{
                               if arr3[now[ss]]<1000000 
                                now.delete_at(ss)
                                
                            else
                            ss+=1
                            end
                                
                            }
                              
                        
                      if now.length==0
                      break
                      end
                        
                        
                        
                    
                        
                    }
                   
     if arr3.include?(1000000)  
     
    else
    break
    end
                            
                        
   k+=1                   
s+=1
}

arr6=[]
(s+1).times{
    
    arr6<<[]
}

i=-1
n.times{
    i+=1
  arr6[arr3[i]]<<arr[i]}
i=0
(s+1).times{
  arr6[i]=arr6[i].sort 
    
    i+=1
}

ans=0

if s==1
    puts 0
    exit

elsif 2*s>n
    puts "IMPOSSIBLE"
exit


end




arr8=[]
                1.times{
                  aaa=arr6.flatten.min
                    i=0
                    loop{
                       if arr6[i][0]==aaa 
                       break
                   end
                       i+=1 
                    }
                    
                    
                    ans+=aaa
                     arr6[i].delete_at(0)
                     sss=arr6[i]
                 arr6.delete_at(i)
                   arr8<<sss
                    arr8=arr8.flatten
                    
                    bbb=arr6.flatten.min
                    i=0
                    loop{
                       if arr6[i][0]==bbb 
                       break
                   end
                       i+=1 
                    }
    
    
    ans+=bbb
     arr6[i].delete_at(0)
     sss=arr6[i]
 arr6.delete_at(i)
arr8<<sss
    arr8=arr8.flatten}

loop{

if arr8.length==0 && arr6.length>0
  puts "IMPOSSIBLE"
  break
 elsif  arr6.length==0
 puts  ans
 break
 end
   
   min1=arr6.flatten.min 
   min2=arr8.min
   
   
    i=0
    loop{
       if arr6[i][0]==min1 
       break
   end
       i+=1 
    }
    
   
   bbb=arr8.index(min2)
    
    ans+=min1+min2
    
    arr6[i].delete_at(0)
    sss=arr6[i]
    arr6.delete_at[i]
    arr8<<sss
    arr8=arr8.flatten
    arr8.delete_at(bbb)
}