#include <bits/stdc++.h>
int nx, ny;
int mx[400], my[400];
bool visit[400];
bool mat[400][400];
bool DFS(int u) {
  for (int v = 1; v <= ny; v++) {
    if (mat[u][v] && !visit[v]) {
      visit[v] = true;
      if (my[v] == -1 || DFS(my[v])) {
        my[v] = u;
        mx[u] = v;
        return true;
      }
    }
  }
  return false;
}
int Hungary() {
  int ret = 0;
  memset(mx, 0xff, sizeof(mx));
  memset(my, 0xff, sizeof(my));
  for (int u = 1; u <= nx; u++) {
    if (mx[u] == -1) {
      memset(visit, 0, sizeof(visit));
      if (DFS(u)) ret++;
    }
  }
  return ret;
}
struct Edge {
  int u, v, f;
  int next;
} list[200000];
int level[400];
int stk[400], tp;
int que[400], qt, qh;
int head[400], cur[400], ln;
void Init() {
  ln = 0;
  memset(head, 0xff, sizeof(head));
}
void Add(int u, int v, int f) {
  list[ln].u = u;
  list[ln].v = v;
  list[ln].f = f;
  list[ln].next = head[u];
  head[u] = ln++;
  list[ln].u = v;
  list[ln].v = u;
  list[ln].f = 0;
  list[ln].next = head[v];
  head[v] = ln++;
}
void BFS(int s, int t) {
  memset(level, 0xff, sizeof(level));
  qt = qh = 0;
  que[qh++] = s;
  level[s] = 0;
  while (qt < qh) {
    int u = que[qt++];
    for (int p = head[u]; p != -1; p = list[p].next) {
      if (list[p].f == 0) continue;
      int v = list[p].v;
      if (level[v] == -1) {
        level[v] = level[u] + 1;
        que[qh++] = v;
        if (v == t) return;
      }
    }
  }
}
int Dinic(int s, int t, int n) {
  int ret = 0;
  while (true) {
    BFS(s, t);
    if (level[t] == -1) break;
    memcpy(cur, head, sizeof(cur));
    tp = 0;
    int u = s;
    while (true) {
      if (u == t) {
        int mink = 0, delta = 1000000000;
        for (int i = 0; i < tp; i++) {
          if (list[stk[i]].f < delta) {
            delta = list[stk[i]].f;
            mink = i;
          }
        }
        for (int i = 0; i < tp; i++) {
          list[stk[i]].f -= delta;
          list[stk[i] ^ 1].f += delta;
        }
        tp = mink;
        u = list[stk[tp]].u;
        ret += delta;
      }
      int p;
      for (p = cur[u]; p != -1; p = list[p].next) {
        if (list[p].f == 0) continue;
        int v = list[p].v;
        if (level[u] + 1 == level[v]) break;
      }
      cur[u] = p;
      if (p != -1) {
        stk[tp++] = p;
        u = list[p].v;
      } else {
        level[u] = -1;
        if (tp == 0) break;
        tp--;
        u = list[stk[tp]].u;
      }
    }
  }
  return ret;
}
int main() {
  int n, k, x;
  while (scanf("%d", &n) != EOF) {
    nx = ny = n;
    memset(mat, 0, sizeof(mat));
    for (int i = 1; i <= n; i++) {
      scanf("%d", &k);
      while (k--) {
        scanf("%d", &x);
        mat[i][x] = true;
      }
    }
    Hungary();
    Init();
    int sum = 0, flow = 0;
    for (int i = 1; i <= n; i++) {
      scanf("%d", &x);
      if (x < 0) {
        sum += (-x);
        Add(0, i, -x);
      } else
        Add(i, n + 1, x);
    }
    for (int i = 1; i <= n; i++) {
      for (int j = 1; j <= n; j++) {
        if (!mat[i][j]) continue;
        if (my[j] == i) continue;
        Add(i, my[j], 1000000000);
      }
    }
    flow = Dinic(0, n + 1, n + 2);
    printf("%d\n", -(sum - flow));
  }
  return 0;
}
