import sys
sys.setrecursionlimit(200000)

def dfs_iterative(start, adj, credit, dp, visited):
    stack = [start]
    parent = [-1] * len(adj)
    order = []
    
    while stack:
        node = stack[-1]
        if visited[node] == 0:
            visited[node] = 1
            order.append(node)
            for neighbor in adj[node]:
                if visited[neighbor] == 0:  # 还没有访问过
                    parent[neighbor] = node
                    stack.append(neighbor)
        else:
            stack.pop()

    # 处理DFS结果
    for u in reversed(order):
        dp[u][0] = 0  # 不选u
        dp[u][1] = credit[u]  # 选u时的初始学分是该课程的学分
        for v in adj[u]:
            if v != parent[u]:
                dp[u][0] += max(dp[v][0], dp[v][1])  # 如果不选u，则v可以选也可以不选
                dp[u][1] += dp[v][0]  # 如果选u，则v不能选

def main():
    # 读取输入
    n = int(input())
    credit = [0] * n
    for i in range(n):
        credit[i] = int(input())
    
    # 邻接表存储图
    adj = [[] for _ in range(n)]
    
    # 读取冲突关系并构建图
    for i in range(n):
        data = list(map(int, input().split()))
        Ai = data[0]
        for j in range(1, Ai + 1):
            adj[i].append(data[j] - 1)  # 课程编号从1开始，转换为0-based
            adj[data[j] - 1].append(i)  # 无向图
    
    # DP数组，dp[u][0]表示不选u时的最大学分，dp[u][1]表示选u时的最大学分
    dp = [[0, 0] for _ in range(n)]
    visited = [0] * n  # 0: 未访问，1: 正在访问，2: 已访问
    total_max_credits = 0
    
    # 遍历每个连通分量
    for i in range(n):
        if visited[i] == 0:  # 如果课程i没有被访问过
            dfs_iterative(i, adj, credit, dp, visited)
            # 对于每个连通分量的根节点，选择dp[u][0]和dp[u][1]中的较大者
            total_max_credits += max(dp[i][0], dp[i][1])
    
    print(total_max_credits)

if __name__ == "__main__":
    main()