#include <bits/stdc++.h>

using namespace std;

using ld = long double;
const int N = 2e5 + 5;
struct Edge {
    int u, v, w;
    Edge(int u, int v, int w): u(u), v(v), w(w) {}
    bool operator < (const Edge &other) const {
        return w < other.w;
    }
};
vector<Edge> e;

const int MP = 19;
vector<int> adj[N];
int P[N], lvl[N];
int lift[MP][N];

struct Dsu {
    int par[N], rnk[N];
    void init() {
        for (int i = 0; i < N; ++i)
            par[i] = i, rnk[i] = 1;
    }
    int findParent(int u){
        return par[u] = (par[u] == u ? u : findParent(par[u]));
    }
    bool merge(int u, int v){
        u = findParent(u);
        v = findParent(v);
        if(u == v)return false;
        if(rnk[u] < rnk[v])
            swap(u,v);
        par[v] = u;
        rnk[u] += rnk[v];
        return true;
    }
    void join(int u, int v){
        u = findParent(u);
        v = findParent(v);
        par[u] = v;
    }
};



void dfs(int u, int pr, int l){
    lift[0][u] = pr;
    for (int p = 1; p < MP; ++p)
        if (~lift[p - 1][u])
            lift[p][u] = lift[p - 1][lift[p - 1][u]];
    P[u] = pr;
    lvl[u] = l;
    for(auto &v: adj[u])
        if(v != pr)
            dfs(v, u,l + 1);
}

int raise(int x, int k) {
    if (k == 0)
        return x;
    for (int i = 0; ~x and i < MP; ++i)
        if ((k >> i) & 1)
            x = lift[i][x];
    return x;
}

int LCA(int u, int v) {
    if (u == v) return u;
    if (lvl[u] < lvl[v])
        swap(u, v);
    u = raise(u, lvl[u] - lvl[v]);
    if (u == v) return u;
    for (int i = MP - 1; i >= 0; --i)
        if (lift[i][u] != lift[i][v]) {
            u = lift[i][u];
            v = lift[i][v];
        }
    return lift[0][u];
}

int main() {
    ios::sync_with_stdio(false); cout.tie(nullptr); cin.tie(nullptr);
    int n , m;
    cin >> n >> m;
    vector<int> h(n + 1);
    for(int i = 1; i <= n; ++i)
        cin >> h[i];
    for(int i = 0; i < m; ++i){
        int u, v, w;
        cin >> u >> v;
        w = abs(h[u] - h[v]);
        e.emplace_back(u,v,w);
    }

    sort(e.begin(), e.end());
    Dsu mst;
    mst.init();
    vector<Edge> notUsed;
    for(int i = 0; i < m; ++i){
        int u,v,w;
        u = e[i].u; v = e[i].v; w = e[i].w;
        if(!mst.merge(u,v)){ // merged before, so skip
            notUsed.emplace_back(e[i]);
        }else{
            adj[u].emplace_back(v);
            adj[v].emplace_back(u);
        }
    }

    lvl[0] = INT_MIN;
    dfs(1, 0, 0);
    vector<int> ans(n + 1, -1);
    mst.init();
    for(int i = 0; i < notUsed.size(); ++i){
        Edge e = notUsed[i];
        int u = e.u, v = e.v, w = e.w;
        u = mst.findParent(u);
        v = mst.findParent(v);
        int lca = LCA(u,v);
        while(u and lvl[u] >= lvl[lca]){
            ans[u] = w;
            mst.join(u, P[u]);
            u = mst.findParent(u);
        }
        while(v and lvl[v] >= lvl[lca]){
            ans[v] = w;
            mst.join(v, P[v]);
            v = mst.findParent(v);
        }
    }
    for(int i = 1; i <= n; ++i)
        cout << ans[i] << ' ';

    return 0;
}