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 Python (3.4.3) (judge verdict: Runtime Error)

    def LI(): return list(map(int, input().split()))
    def LS(): return input().split()
    def I(): return int(input())
    def S(): return input()
     
    n, m = LI()
    a = LI()
    d = dict([(i, [i])for i in range(n)])
    for i in range(m):
        x, y = LI()
        d[x].append(y)
        d[y].append(x)
     
            
    pow = [1]*n
     
    def mori(num, mori_list):
        for c in d[num]:
            if pow[c] == 1:
                mori_list.append(a[c])
                pow[c] = 0
                mori(c, mori_list)
     
    zen_mori = []
    for i in range(n):
        if pow[i] == 1:
            mori_list = []
            mori(i, mori_list)
            zen_mori.append(sorted(mori_list)[::-1])
     
     
    l = len(zen_mori)
    check_list = [0]*l
     
    if n - l < l - 2:
        print("Impossible")
        exit()
     
    ans = 0
    for cnt in range(l-1):
        pos = 0
        one, two = 0, 0
        use = []
        while True:
            min_list = [[zen_mori[i][-1] if len(zen_mori[i]) > 0 else (10**9 + 1), i] for i in range(l)]
            use = sorted(min_list)
            one, two = use[pos][1], use[pos+1][1]
            if check_list[one] == 1 and check_list[two] == 1:
                pos += 1
                continue
            if len(zen_mori[one]) == 1 and len(zen_mori[two]) == 1:
                pos += 1
                continue
            break
        ans += use[pos][0] + use[pos+1][0]
        try:
            zen_mori[one].pop()
        except:
            pass
        try:
            zen_mori[two].pop()
        except:
            pass
        check_list[one] = 1
        check_list[two] = 1
    print(ans)