#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using db = long double;

struct Frac {
    ll a = 1e9, b = 1;
    Frac() = default;
    Frac(ll a, ll b) : a(a), b(b) {}
    bool operator<(const Frac &oth) const { return a * oth.b < b * oth.a; }
    bool operator>(const Frac &oth) const { return a * oth.b > b * oth.a; }
    bool operator==(const Frac &oth) const { return a * oth.b == b * oth.a; }
};

struct Line {
    ll k = 0, b = -1e18;
    Line() = default;
    Line(ll k, ll b) : k(k), b(b) {}
    db inter(const Line &oth) const { return (b - oth.b) / db(oth.k - k); }
    Frac f(ll h, int i) const {
        if (-b < h || k < i) {
            return {};
        }
        if (k == i) {
            assert(h == -b);
            return {0, 1};
        }
        assert(k > i);
        assert(-b >= h);
        return Frac((-b - h), k - i);
    }
};

struct CHT {
    vector<Line> t;

    void insert(const Line &v) {
        assert(t.empty() || t.back().k > v.k);
        while (size(t) > 1 && v.inter(t.end()[-2]) < v.inter(t.back())) {
            t.pop_back();
        }
        t.push_back(v);
    }

    Frac query(ll h, int i) {
        if (t.empty()) {
            return {};
        }
        int lo = 0;
        while (lo < size(t) && !(t[lo].f(h, i) < Frac())) {
            lo += 1;
        }
        if (lo == size(t)) {
            return Frac();
        }
        int hi = size(t) - 1;
        while (lo < hi) {
            int mid = lo + hi >> 1;
            if (t[mid].f(h, i) < t[mid + 1].f(h, i)) {
                hi = mid;
            } else {
                lo = mid + 1;
            }
        }
        return t[lo].f(h, i);
    }
};

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

    int n;
    cin >> n;

    vector<int> h(n), Q(n);

    for (int i = 0; i < n; ++i) {
        cin >> h[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> Q[i];
        --Q[i];
    }

    vector<Frac> answers(n);

    auto solve = [&]() -> vector<Frac> {
        const int sz = 1 << __lg(n) + !!(n & (n - 1));
        CHT tree;

        vector<int> ord(n), inv(n), head(n);
        iota(ord.begin(), ord.end(), 0);
        sort(ord.begin(), ord.end(), [&](int i, int j) {
            return h[i] < h[j];
        });

        for (int i = 0, j = 0; i < n; i = j) {
            while (j < n && h[ord[i]] == h[ord[j]]) {
                j += 1;
            }
            int f = i;
            while (i < j) {
                inv[ord[i]] = i;
                head[ord[i]] = f;
                i += 1;
            }
        }

        vector<vector<int>> queries(n + 1);

        for (int s = 0; s < n; ++s) {
            int t = Q[s];
            if (h[t] <= h[s]) {
                queries[max(s, t) + 1].push_back(s);
            }
        }

        vector<Frac> ans(n);

        for (int i = n - 1; i >= 0; --i) {
            tree.insert({i, -h[i]});
            for (int s : queries[i]) {
                int t = Q[s];
                ans[s] = tree.query(h[t], t);
            }
        }

        return ans;
    };

    answers = solve();

    for (int s = 0; s < n; ++s) {
        int t = Q[s];
        if (t < s && h[t] <= h[s]) {
            answers[s] = min(answers[s], Frac(h[s] - h[t], s - t));
        } else if (t > s && h[t] >= h[s]) {
            answers[s] = min(answers[s], Frac(h[t] - h[s], t - s));
        }
    }

    reverse(h.begin(), h.end());
    reverse(Q.begin(), Q.end());
    for (int i = 0; i < n; ++i) {
        h[i] = 1e9 - h[i] + 1;
        Q[i] = n - Q[i] - 1;
    }

    auto sec = solve();
    reverse(sec.begin(), sec.end());

    for (int i = 0; i < n; ++i) {
        answers[i] = min(answers[i], sec[i]);
    }

    for (int s = 0; s < n; ++s) {
        Frac ans = answers[s];
        ll d = gcd(ans.a, ans.b);
        ans.a /= d, ans.b /= d;
        if (ans < Frac(1e9, 1)) {
            cout << ans.a << "/" << ans.b << '\n';
        } else {
            cout << "-1\n";
        }
    }

    return 0;
}