#include <bits/stdc++.h>
using namespace std;

#define int long long
#define pii pair<int, int>

const int INF = 1e18 + 7;

struct Edge {
    int to;
    int cost;
};

signed main() {
    // Tối ưu I/O cho C++
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    if (!(cin >> n)) return 0;

    vector<int> x(n + 1), A(n + 1);
    for (int i = 1; i <= n; i++) cin >> x[i];
    for (int i = 1; i <= n; i++) cin >> A[i];

    vector<vector<int>> port(n + 1);
    vector<int> compress;
    for (int i = 1; i <= n; i++) {
        int k; cin >> k;
        port[i].resize(k);
        for (int j = 0; j < k; j++) {
            cin >> port[i][j];
            compress.push_back(port[i][j]);
        }
    }

    // Nén tọa độ cho các loại cổng
    sort(compress.begin(), compress.end());
    compress.erase(unique(compress.begin(), compress.end()), compress.end());

    int P = compress.size();
    vector<vector<int>> machines_with_port(P + 1);

    for (int i = 1; i <= n; i++) {
        for (int &p : port[i]) {
            p = lower_bound(compress.begin(), compress.end(), p) - compress.begin() + 1;
            machines_with_port[p].push_back(i);
        }
    }

    // Tính toán số lượng nút tối đa (N máy thật + 2 * sum(k_i) nút ảo)
    int max_nodes = n;
    for (int p = 1; p <= P; p++) {
        max_nodes += 2 * machines_with_port[p].size();
    }

    vector<vector<Edge>> adj(max_nodes + 1);
    int total_nodes = n; // Các nút từ 1 đến N là các máy thật

    // Xây dựng các làn đường nút ảo
    for (int p = 1; p <= P; p++) {
        auto &machines = machines_with_port[p];
        int k = machines.size();
        if (k <= 1) continue;

        // Sắp xếp các máy có chung cổng theo Base Voltage x[i]
        sort(machines.begin(), machines.end(), [&](int a, int b) {
            return x[a] < x[b];
        });

        vector<int> U(k), D(k);
        for (int i = 0; i < k; i++) {
            U[i] = ++total_nodes;
            D[i] = ++total_nodes;
        }

        for (int i = 0; i < k; i++) {
            int u = machines[i];

            // 1. Máy thật chui vào làn đường (Chi phí 0)
            adj[u].push_back({U[i], 0});
            adj[u].push_back({D[i], 0});

            // 2. Đi từ làn đường ra máy thật (Trả chi phí Startup Cost A[u])
            adj[U[i]].push_back({u, A[u]});
            adj[D[i]].push_back({u, A[u]});

            // 3. Nối các nút ảo trên làn đường
            if (i < k - 1) { // Làn đi lên (tăng điện áp)
                int cost = x[machines[i + 1]] - x[machines[i]];
                adj[U[i]].push_back({U[i + 1], cost});
            }
            if (i > 0) {     // Làn đi xuống (giảm điện áp)
                int cost = x[machines[i]] - x[machines[i - 1]];
                adj[D[i]].push_back({D[i - 1], cost});
            }
        }
    }

    // Thuật toán Dijkstra tìm đường đi ngắn nhất từ 1 đến N
    vector<int> dist(total_nodes + 1, INF);
    priority_queue<pii, vector<pii>, greater<pii>> pq;

    dist[1] = 0;
    pq.push({0, 1});

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();

        if (d > dist[u]) continue;
        if (u == n) break; // Đã tới đích, dừng sớm để tối ưu thêm

        for (auto &edge : adj[u]) {
            int v = edge.to;
            int cost = edge.cost;
            if (dist[v] > dist[u] + cost) {
                dist[v] = dist[u] + cost;
                pq.push({dist[v], v});
            }
        }
    }

    cout << (dist[n] == INF ? -1 : dist[n]) << "\n";

    return 0;
}