import java.io.*;
import java.util.*;
import java.math.*;

/**
 * Solution to Gold Bandits
 * 
 * @author vanb
 */
public class gold_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A State of a Dijkstra-style search.
     * 
     * @author vanb
     */
    public class State implements Comparable<State>
    {
        /** The node, the total distance form node 0, and the accumulated wealth. */
        public int node, distance, wealth;
        
        /** The state we came from. */
        public State from;
        
        public State( int node, int distance, int wealth, State from )
        {
            this.node = node;
            this.distance = distance;
            this.wealth = wealth;
            this.from = from;
        }

        @Override
        /**
         * Compare two States, first by distance (increasing), then by wealth (decreasing).
         * 
         * @param s Another State to compare with
         * @return The usual for compareTo
         */
        public int compareTo( State s )
        {
            int diff = distance-s.distance;
            if( diff==0 ) diff = s.wealth - wealth;
            return diff;
        }
    }
            
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "gold.in" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "gold.vanb" ) );
        
        // The Gold in each village
        int gold[] = new int[40];
        
        // The system of roads
        boolean road[][] = new boolean[40][40];
        
        // Whether or not a node has been visited in the current search
        boolean visited[] = new boolean[40];
        
        // The number of nodes
        int n;

        // A priority queue for the Dijkstras
        PriorityQueue<State> pq = new PriorityQueue<State>();
        
        for(;;)
        {
            n = sc.nextInt();
            int m = sc.nextInt();
            if( n==0 && m==0 ) break;
            
            for( int i=0; i<n; i++ )
            {
                Arrays.fill( road[i], false );
            }
            
            // Read Gold for each village
            for( int i=2; i<n; i++ )
            {
                gold[i] = sc.nextInt();
            }
            
            // Read Roads between villages
            for( int i=0; i<m; i++ )
            {
                int a = sc.nextInt()-1;
                int b = sc.nextInt()-1;
                road[a][b] = road[b][a] = true;
            }
            
            // First, find the Shortest Path with the Greatest Wealth.
            // A modified Dijkstra will do the trick. Just
            // sort the states first by distance (increasing), 
            // and then by wealth (decreasing).
            Arrays.fill( visited, false );
            pq.clear();
            pq.add( new State( 0, 0, 0, null ) );
            int tribute = 0;
            State last = null;
            while( !pq.isEmpty() )
            {
                State s = pq.poll();
                if( s.node==1 )
                {
                    tribute = s.wealth;
                    last = s;
                    break;
                }
                
                visited[s.node] = true; 
                
                for( int i=0; i<n; i++ ) if( road[s.node][i] && !visited[i] )
                {
                    pq.add( new State( i, s.distance+1, s.wealth+gold[i], s ) );    
                }
            }
            
            // Next, we've got to figure out how much gold on the path we can't
            // take, because we have to get home. We'll use Dijkstra again, where the
            // gold is the 'distance' to minimize.
            
            // First, we've got to zero out all gold that is NOT on the path we just found.
            Arrays.fill( visited, false );
            for( State s = last; s!=null; s=s.from ) visited[s.node] = true;
            for( int i=0; i<n; i++ ) if( !visited[i] ) gold[i] = 0;

            // Now, our second Dijkstra, to calculate the least amount of gold we have to NOT take
            // in order to get back home safely. We'll measure 'distance' in Gold, 
            // and wealth will always be 0.
            Arrays.fill( visited, false );
            pq.clear();
            pq.add( new State( 0, 0, 0, null ) );
            int getback = 0;
            while( !pq.isEmpty() )
            {
                State s = pq.poll();
                if( s.node==1 )
                {
                    getback = s.distance;
                    break;
                }
                
                visited[s.node] = true; 
                
                for( int i=0; i<n; i++ ) if( road[s.node][i] && !visited[i] )
                {
                    pq.add( new State( i, s.distance+gold[i], 0, s ) );    
                }
            }
            
            // And, here's the answer: our tribute (1st Dijkstra) 
            // minus the amount we have to not take (2nd Dijkstra) to get back home safely.
            ps.println( tribute-getback );            
        }
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        //long start = System.currentTimeMillis();
        new gold_vanb().doit();     
        //System.out.println( System.currentTimeMillis() - start );
    }   
}