#include <bits/stdc++.h>
using namespace std;

#define fileio() freopen("input.txt","r",stdin); freopen("output.txt","w",stdout)
#define fio() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define all(x) (x).begin(), (x).end()
#define allr(x) x.rbegin(), x.rend()
#define cmprs(x) sort(all(x)),x.erase(unique(all(x)),x.end())
#define endl "\n"
#define sp " "
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define rz resize
#define sz(a) (int)(a.size())
#define clr(a) a.clear()

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, ll> pil;
typedef tuple<int, int, int> tpi;
typedef tuple<ll, ll, ll> tpl;
typedef pair<double, ll> pdl;
typedef pair<double, int> pdi;

const int dx[] = {1,-1,0,0,1,1,-1,-1};
const int dy[] = {0,0,1,-1,1,-1,1,-1};
const ll MOD = 1e9+7;
const ll INF = 1e12;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const int MAX = 101010; // PLZ CHK!

struct LiChao {
    struct Line {
        ll a,b;
        ll get(ll x) {return a*x+b;}
    };

    struct Node {
        int l,r;
        ll s,e;
        Line line;
    };
    vector<Node> tree;
    // For max query, initialize -LINF instead
    void init(ll s, ll e) { tree.pb({-1,-1,s,e,{0,LINF}}); }
    void upd(int node, Line v) {
        auto [l,r,s,e,curl]=tree[node];
        ll m=(s+e)>>1;
        Line lo=curl, hi=v;

        if (lo.get(s)>hi.get(s)) swap(lo,hi);

        if (lo.get(e)<=hi.get(e)) {
            tree[node].line=lo;
            return;
        }

        if (lo.get(m)<=hi.get(m)) {
            tree[node].line=lo;
            if (tree[node].r==-1) {
                tree[node].r=sz(tree);
                tree.pb({-1,-1,m+1,e,{0,LINF}});
            }
            upd(tree[node].r,hi);
        }
        else {
            tree[node].line=hi;
            if (tree[node].l==-1) {
                tree[node].l=sz(tree);
                tree.pb({-1,-1,s,m,{0,LINF}});
            }
            upd(tree[node].l,lo);
        }
    }
    ll qry(int node, ll x) {
        if (node==-1) return LINF;
        auto [l,r,s,e,curl]=tree[node];
        ll m=(s+e)>>1;
        if (x<=m) return min(tree[node].line.get(x), qry(tree[node].l,x));
        else return min(tree[node].line.get(x), qry(tree[node].r,x));
    }
};

int N,M,S,T;
ll H[MAX];
vector<ll> DS,DT;
vector<int> G[MAX];

void dij(int s, vector<ll> &d) {
    d.assign(N+1,LINF);
    priority_queue<pll,vector<pll>,greater<pll>> pq;
    d[s]=0;
    pq.push({d[s],s});

    while (!pq.empty()) {
        auto [dst,cur]=pq.top(); pq.pop();
        if (dst!=d[cur]) continue;

        for (int nxt:G[cur]) {
            ll cst=(H[cur]-H[nxt])*(H[cur]-H[nxt]);
            if (d[nxt]>d[cur]+cst) {
                d[nxt]=d[cur]+cst;
                pq.push({d[nxt],nxt});
            }
        }
    }
}

int main() {
    fio();
    cin>>N>>M>>S>>T;
    for (int i=1; i<=N; i++) {
        cin>>H[i];
        H[i]*=2;
    }
    for (int i=0; i<M; i++) {
        int u,v; cin>>u>>v;
        G[u].pb(v), G[v].pb(u);
    }   

    dij(S,DS),dij(T,DT);

    ll ans=DS[T];
    for (int v:G[S]) ans=min(ans, DT[v]);
    for (int v:G[T]) ans=min(ans, DS[v]);

    for (int u=1; u<=N; u++) {
        if (u==S || u==T) continue;
        LiChao li; li.init(-1e18,1e18);
        for (int v:G[u]) li.upd(0,{-H[v],H[v]*H[v]/2+DT[v]});
        for (int v:G[u]) {
            ll t=li.qry(0,H[v])+H[v]*H[v]/2+DS[v];
            ans=min(ans, t);
        }
    }

    cout<<fixed; cout.precision(10);
    cout<<1.0*ans/4.0;
    return 0;
}