#include <bits/stdc++.h>

using i64 = int64_t;
template <typename T>
using minpq = std::priority_queue<T, std::vector<T>, std::greater<T>>;

constexpr i64 INF = 1e18;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m, s, t;
    std::cin >> n >> m >> s >> t;
    --s, --t;

    std::vector<int> h(n);
    for (int &i : h) {
        std::cin >> i;
    }

    std::vector<std::vector<int>> adj(n);
    for (int i = 0; i < m; ++i) {
        int u, v;
        std::cin >> u >> v;
        --u, --v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    auto get_dist = [&](int src) -> std::vector<i64> {
        std::vector<i64> dist(n, INF);
        minpq<std::pair<i64, int>> q;

        dist[src] = 0;
        q.emplace(dist[src], src);

        std::vector<uint8_t> vist(n);
        while (!q.empty()) {
            auto [_, node] = q.top();
            q.pop();
            if (vist[node]) continue;
            vist[node] = true;

            for (int to : adj[node]) {
                i64 w = i64(h[node] - h[to]) * (h[node] - h[to]);
                if (dist[to] > dist[node] + w) {
                    dist[to] = dist[node] + w;
                    q.emplace(dist[to], to);
                }
            }
        }
        return dist;
    };

    std::vector<i64> f = get_dist(s), g = get_dist(t);
    i64 ans = INF;
    for (int to : adj[s]) {
        ans = std::min(ans, g[to]);
    }
    for (int to : adj[t]) {
        ans = std::min(ans, f[to]);
    }

    auto check = [&](int x) -> void {
        auto a = adj[x];
        std::sort(a.begin(), a.end(), [&](int x, int y) {
            return h[x] < h[y];
        });

        auto val = [&](int x, int y) -> i64 {
            return 2 * (f[x] + g[y]) + (h[x] - h[y]) * (h[x] - h[y]);
        };

        auto solve = [&](auto &self, int L, int R, int l, int r) -> void {
            if (l > r) return;
            
            int mid = (l + r) / 2;

            int x = std::min(R, mid - 1);
            i64 res = val(a[x], a[mid]);
            for (int i = x - 1; i >= L; --i) {
                if (val(a[i], a[mid]) < res) {
                    x = i;
                    res = val(a[x], a[mid]);
                }
            }

            ans = std::min(ans, res);
            self(self, L, x, l, mid - 1);
            self(self, x, R, mid + 1, r);
        };

        solve(solve, 0, a.size() - 1, 1, a.size() - 1);
        std::reverse(a.begin(), a.end());
        solve(solve, 0, a.size() - 1, 1, a.size() - 1);
    };

    for (int i = 0; i < n; ++i) {
        check(i);
    }

    std::cout << ans / 2;
    if (ans % 2 == 1) {
        std::cout << ".5";
    }
}