#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define sz(x) signed(size(x))

inline void solve() {
        int n, m;
        cin >> n >> m;

        vector<int> a(n);
        for (int i = 0; i < n; i++) cin >> a[i];

        vector<tuple<int, int, int>> edge;
        for (int i = 0; i < m; i++) {
                int u, v;
                cin >> u >> v;
                u--, v--;
                edge.emplace_back(abs(a[u] - a[v]), u, v);
        }
        sort(edge.begin(), edge.end());

        vector<int> to(n), si(n);
        for (int i = 0; i < n; i++) {
                to[i] = i;
                si[i] = 1;
        }
        auto find = [&](int x) -> int {
                while (to[x] != x) {
                        x = to[x];
                }
                return x;
        };
        auto merge = [&](int x, int y) -> void {
                x = find(x);
                y = find(y);
                if (x == y) return;
                if (si[x] < si[y]) swap(x, y);
                si[x] += si[y];
                to[y] = x;
        };

        vector<vector<int>> adj(n);
        vector<tuple<int,int,int>> e;
        for (auto& [val, u, v] : edge) {
                if (find(u) == find(v)) {
                        e.emplace_back(val, u, v);
                        continue;
                }
                merge(u, v);
                adj[u].push_back(v);
                adj[v].push_back(u);
        }

        vector<int> vis(n), lv(n);
        vector dp(n, vector<int>(20));
        auto build = [&](auto build, int x, int lst) -> void {
                dp[x][0] = lst;
                vis[x] = 1;
                for (int i = 1; i < 20; i++) {
                        dp[x][i] = dp[dp[x][i - 1]][i - 1];
                }
                for (auto y : adj[x]) {
                        if (y == lst) continue;
                        lv[y] = lv[x] + 1;
                        build(build, y, x);
                }
        };

        vector<int> rt;
        for (int i = 0; i < n; i++) {
                if (!vis[i]) {
                        rt.push_back(i);
                        build(build, i, i);
                }
        }

        auto upd = [&](int& x, int k) -> void {
                for (int i = 0; k >> i; i++) {
                        if (k >> i & 1) {
                                x = dp[x][i];
                        }
                }
        };
        auto lca = [&](int x, int y) -> int {
                if (lv[x] > lv[y]) upd(x, lv[x] - lv[y]);
                else upd(y, lv[y] - lv[x]);
                if (x == y) return x;
                for (int i = 0; i < 20; i++) {
                        if (dp[x][i] != dp[y][i]) {
                                x = dp[x][i], y = dp[y][i];
                        }
                }
                return dp[x][0];
        };

        vector<vector<pair<int, int>>> ins(n), rm(n);
        int id = 0;
        for (auto [val, u, v] : e) {
                int z = lca(u, v);
                ins[u].push_back({val, id});
                ins[v].push_back({val, id});
                if (dp[z][0] != z) {
                        rm[dp[z][0]].push_back({val, id});
                }
                id++;
        }

        vector<int> res(n, -1);
        auto dfs = [&](auto dfs, int x, int lst) -> set<pair<int,int>> {
                vis[x] = 1;
                set<pair<int, int>> s;
                for (auto val : ins[x]) {
                        s.insert(val);
                }

                for (auto y : adj[x]) {
                        if (y == lst) continue;
                        auto sy = dfs(dfs, y, x);
                        if (s.size() < sy.size()) swap(s, sy);
                        for (auto val : sy) {
                                s.insert(val);
                        }
                }
                for (auto val : rm[x]) {
                        s.erase(val);
                }
                if(s.size()) res[x] = s.begin()->first;
                return s;
        };

        for (int i = 0; i < n; i++) vis[i] = 0;
        for (int i = 0; i < n; i++) {
                if (!vis[i]) {
                        dfs(dfs, i, i);
                }
        }

        for (auto x : res) {
                cout << x << " ";
        }
        cout << '\n';

        return;
}

signed main() {
        cin.tie(0)->sync_with_stdio(0);
        int t = 1;
        while (t--)
                solve();
        return 0;
}