#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
const int N = 100005;
vector<int> adj[N];
ll h[N];
int n, m;


const ll INF = 1e18;
vector<ll> Dijkstra(int src) {
    vector<ll> dis(n, INF);
    vector<ll> vis(n, false);

    using pll = pair<ll, int>;
    priority_queue<pll, vector<pll>, greater<pll>> pq;

    dis[src] = 0;
    pq.push({0, src});
    while(!pq.empty()) {
        int x = pq.top().second;
        pq.pop();
        if(vis[x]) continue;

        vis[x] = true;
        for(auto v : adj[x]) {
            ll w = (h[v] - h[x]) * (h[v] - h[x]);
            if(dis[v] > dis[x] + w) {
                dis[v] = dis[x] + w;
                pq.push({dis[v], v});
            }
        }
    }
    return dis;
}

struct Line {
    ld a, b; // ax + b
    ld val(ld x) { return (a - x) * (a - x) / 2.0 + b; }
    Line() {}
    Line(ld _a, ld _b) : a(_a), b(_b) {}
};
struct Node {
    int L, R;
    Line line;
    Node *lc, *rc;
};

int cur;

void build(Node *r, int L, int R) {
    r->L = L, r->R = R;
    r->line = Line(2e5, INF);
    if(L == R) return;
    int M = (L + R) / 2;
    build(r->lc = new Node(), L, M);
    build(r->rc = new Node(), M + 1, R);
}
void update(Node *r, Line line) {
    Line left_line, right_line;
    if(line.a > r->line.a) {
        left_line = line;
        right_line = r->line;
    } else {
        left_line = r->line;
        right_line = line;
    }

    int M = (r->L + r->R) / 2;
    ld Mx = h[adj[cur][M]];
    if(left_line.val(Mx) < right_line.val(Mx)) {
        r->line = left_line;
        if(r->L != r->R) update(r->rc, right_line);
    } else {
        r->line = right_line;
        if(r->L != r->R) update(r->lc, left_line);
    }
}
ld qry(Node *r, ld x) {
    if(r->L == r->R)
        return r->line.val(x);
    int M = (r->L + r->R) / 2;
    ld Mx = h[adj[cur][M]];
    if(x <= Mx) return min(r->line.val(x), qry(r->lc, x));
    else return min(r->line.val(x), qry(r->rc, x));
}

int main() {
    cin.tie(0);
    ios_base::sync_with_stdio(false);

    int s, t;
    cin >> n >> m >> s >> t;
    s--, t--;
    for(int i = 0; i < n; i++) {
        cin >> h[i];
    }
    
    for(int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        a--, b--;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }

    vector<ll> from_src = Dijkstra(s), to_dst = Dijkstra(t);


    ld ans = from_src[t];
    for(int i = 0; i < n; i++) {
        sort(adj[i].begin(), adj[i].end(), [&](int a, int b) {
            return h[a] < h[b];
        });
        
        cur = i;
        Node *root;
        build(root = new Node(), 0, (int)adj[i].size() - 1);
        for(auto v : adj[i]) {
            ans = min(qry(root, h[v]) + to_dst[v], ans);
            update(root, Line(h[v], from_src[v]));
        }

        reverse(adj[i].begin(), adj[i].end());

        Node *root2;
        build(root2 = new Node(), 0, (int)adj[i].size() - 1);
        for(auto v : adj[i]) {
            ans = min(qry(root2, h[v]) + to_dst[v], ans);
            update(root2, Line(h[v], from_src[v]));
        }
    }

    cout << fixed << setprecision(10) << ans << "\n";
}