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

const long long INF = 1e18;
const int MAXN = 200005;

int B, N, M;
long long cost[MAXN];
int mask[MAXN]; // Mask các căn cứ mà node này có thể reach được
vector<int> adj[MAXN]; // Đồ thị ngược: node u -> node v nghĩa là mua u sẽ có info từ v (v là quen của u)
// Hoặc đồ thị xuôi: u quen v -> u -> v. Dùng đồ thị ngược để DFS từ lính lên.

void dfs(int u) {
    if (mask[u] != -1) return; // Đã tính rồi
    mask[u] = 0;

    // Nếu là lính (1..N), mask cơ bản là bit tương ứng căn cứ
    if (1 <= u && u <= N) {
        // base_of[u] cần được lưu trữ hoặc suy ra. 
        // Trong bài này, ta cần map lính vào căn cứ. 
        // Giả sử ta có base[u] là căn cứ của lính u.
        // Mask = (1 << (base[u] - 1)).
        // Code mẫu dưới đây giả định đã xử lý base[u]
    }

    // Duyệt các node có thể reach được từ u (các node mà u quen biết)
    // Nếu đồ thị là u.quen(v) -> adj[u].push_back(v)
    // Khi mua u, ta có info từ v. Nên ta cần merge mask của v vào mask của u.
    // Tuy nhiên, v có thể chưa tính mask.
    // Cách tốt nhất là dùng đồ thị ngược: v -> u (nghĩa là u quen v, mua u có v).
    // Hoặc DFS topo từ lính lên.

    // Giải pháp:
    // Xây dựng đồ thị: u (người mua) -> v (người quen).
    // Nếu ta duyệt DFS từ u, ta cần info từ v. Nên ta phải gọi dfs(v) trước.
    // Ta có thể dùng Topo sort hoặc duyệt từ sink (lính) về nguồn (si quan).
    // Hoặc dùng memoization: dfs(u) trả về mask của u.
    // Mask(u) = (base_mask nếu là lính) OR (Union of mask(v) for v in adj[u]).
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    cin >> B >> N >> M;

    // Đọc lính
    int soldier_idx = 1;
    for (int b = 0; b < B; ++b) {
        int K; cin >> K;
        while(K--) {
            long long c; cin >> c;
            cost[soldier_idx] = c;
            // Gán mask cho lính
            mask[soldier_idx] = (1 << b);
            soldier_idx++;
        }
    }

    // Đọc sĩ quan
    int officer_idx = N + 1;
    for (int i = 0; i < M; ++i) {
        long long S; int R;
        cin >> S >> R;
        cost[officer_idx] = S;
        mask[officer_idx] = -1; // Chưa tính
        for (int j = 0; j < R; ++j) {
            int acquaintance;
            cin >> acquaintance;
            // Sĩ quan officer_idx quen acquaintance
            // Mua officer_idx -> có info từ acquaintance
            adj[officer_idx].push_back(acquaintance);
        }
        officer_idx++;
    }

    // Tính mask cho tất cả (chỉ cần tính cho sĩ quan, lính đã có sẵn)
    // Dùng topo sort hoặc DFS memoization
    // Do đồ thị có thể có chu trình (si quan quen nhau), cần cẩn thận.
    // Nếu có chu trình, ta có thể coi Strongly Connected Components (SCC).
    // Hoặc đơn giản hơn: DFS với visited set để tránh loop, nhưng cycle vẫn cho phép info chia sẻ.
    // Trong cycle, mua 1 node sẽ có info cả cycle. Ta có thể coi cycle là 1 node tổng hợp.

    // Cách tiếp cận SCC:
    // 1. Xây dựng đồ thị G: u -> v (u quen v).
    // 2. Tìm SCC.
    // 3. Xây dựng DAG của các SCC.
    // 4. Mask của SCC = Union mask của các node trong SCC và Union mask của SCC children.
    // 5. Chi phí của SCC = Min(cost của các node trong SCC).
    // 6. Quy hoạch động trên DAG (Top-down hoặc Bottom-up).

    // Code mẫu:
    // (Logic này khá phức tạp để viết gọn, nên thường sẽ dùng BFS/DFS mark).
    // Tuy nhiên, do B nhỏ (<=12), ta có thể dùng Bitmask DP.
    // Xem solution 1 và 2.

    return 0;
}

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

const int MAXN = 200005;
const int MAXB = 12;

int B, N, M;
long long cost[MAXN];
int base_of[MAXN]; // base of soldier
int mask[MAXN]; // Mask các căn cứ mà node này có thể reach được
vector<int> adj[MAXN]; // Đồ thị xuôi: u -> v (u quen v)
vector<int> rev_adj[MAXN]; // Đồ thị ngược: v -> u (u quen v) - dùng để lan truyền từ lính

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    cin >> B >> N >> M;

    // 1. Đọc lính
    int soldier_ptr = 1;
    for (int b = 0; b < B; ++b) {
        int K; cin >> K;
        while(K--) {
            long long c; cin >> c;
            cost[soldier_ptr] = c;
            base_of[soldier_ptr] = b;
            mask[soldier_ptr] = (1 << b);
            soldier_ptr++;
        }
    }

    // 2. Đọc sĩ quan và xây dựng đồ thị
    int officer_ptr = N + 1;
    for (int i = 0; i < M; ++i) {
        long long S; int R;
        cin >> S >> R;
        cost[officer_ptr] = S;
        mask[officer_ptr] = 0;
        for (int j = 0; j < R; ++j) {
            int acq; cin >> acq;
            adj[officer_ptr].push_back(acq);
            rev_adj[acq].push_back(officer_ptr);
        }
        officer_ptr++;
    }

    // 3. Tính mask cho tất cả các node (Lính + Sĩ quan)
    // Do có chu trình, không thể dùng DFS đơn giản.
    // Có thể dùng BFS/DFS nhiều lần (Fixed Point Iteration) hoặc Topo sort trên SCC.
    // Tuy nhiên, với N, M lớn nhưng B nhỏ, ta có thể tối ưu.

    // Cách tiếp cận lan truyền (BFS) từ lính:
    // Ta cần tìm mask cho mỗi sĩ quan.
    // Nếu ta dùng BFS từ lính trên đồ thị ngược (rev_adj), ta có thể lan truyền mask.
    // Tuy nhiên, trong SCC, info có thể đi vòng.
    // Nếu ta dùng SCC, ta coi SCC là 1 node.

    // Logic SCC + DP (như solution 1):
    // 1. Xây dựng SCC.
    // 2. Tính mask cho mỗi SCC (Bottom-up trên DAG).
    // 3. Dùng DP để chọn SCC tối ưu.

    // Code mẫu logic SCC:
    // ... (Tham khảo Solution 1) ...
    // Rất khó để viết gọn trong snippet, nên chú trọng vào logic.
    // Solution 1 làm BFS cho từng căn cứ để tính mask sĩ quan.
    // Solution 2 dùng SCC.

    return 0;
}

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

const long long INF = 1e18;
const int MAXB = 12;

int main() {
    // Giả sử đã có danh sách các đối tượng (lính + sĩ quan) với (cost, mask)
    // Danh sách này có tên là 'items'
    // int num_items = N + M_scc; 

    // DP array
    vector<long long> dp(1 << MAXB, INF);
    dp[0] = 0;

    // Duyệt qua từng item
    // Có thể tối ưu bằng cách sort items theo cost tăng dần?
    // Hoặc dùng Min-Heap (Dijkstra-like) để tìm state tốt nhất chưa visit.

    // Dijkstra approach:
    // Node là các mask.
    // Edge là mua 1 item từ state hiện tại.
    // Weight là cost của item.

    // Code mẫu Dijkstra:
    /*
    priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<pair<long long, int>>> pq;
    pq.push({0, 0});

    while(!pq.empty()) {
        long long d = pq.top().first;
        int u = pq.top().second;
        pq.pop();

        if (d > dp[u]) continue;

        for (auto &item : items) {
            int v = u | item.mask;
            long long nd = d + item.cost;
            if (nd < dp[v]) {
                dp[v] = nd;
                pq.push({nd, v});
            }
        }
    }
    */

    // Tuy nhiên, với B=12, số state là 4096. Item có thể lên tới 10^5.
    // Dùng Dijkstra có thể chậm (4096 * 10^5).
    // Nên dùng DP thường:
    for (int i = 0; i < num_items; ++i) {
        for (int mask = (1 << B) - 1; mask >= 0; --mask) {
             if (dp[mask] != INF) {
                 int next_mask = mask | items[i].mask;
                 dp[next_mask] = min(dp[next_mask], dp[mask] + items[i].cost);
             }
        }
    }

    // Hoặc tối ưu: sort items theo cost, dùng set/heap.
    // Nhưng DP bitmask O(Items * 2^B) là chấp nhận được (10^5 * 4096 ~ 4e8, cần tối ưu).
    // Có thể dùng KnapSack style: Iterate mask -> Iterate item.
    // Hoặc chỉ dùng item hiệu quả.

    return 0;
}