import sys

def main():
    import sys
    input = sys.stdin.read().split()
    idx = 0
    N = int(input[idx])
    idx +=1
    
    X = []
    for _ in range(N):
        row = list(map(int, input[idx:idx+N]))
        idx +=N
        X.append(row)
    A = list(map(int, input[idx:idx+N]))
    idx +=N
    
    # Precompute dependency masks
    deps_mask = [0] * N
    for i in range(N):
        for j in range(N):
            if X[i][j]:
                deps_mask[i] |= 1 << j
    
    # Precompute T(S) for all S
    precompute_T = [0] * (1 << N)
    for S in range(1 << N):
        T = 0
        while True:
            current = S | T
            new_T = T
            for i in range(N):
                if not (current & (1 << i)):
                    required = deps_mask[i]
                    if (current & required) == required:
                        new_T |= 1 << i
            if new_T == T:
                break
            T = new_T
        precompute_T[S] = T
    
    INF = float('inf')
    dp = [INF] * (1 << N)
    dp[0] = 0
    
    ans = INF
    for S in range(1 << N):
        if dp[S] == INF:
            continue
        T = precompute_T[S]
        current_cover = S | T
        if current_cover == (1 << N) - 1:
            ans = min(ans, dp[S])
            continue
        # Add each uncovered member
        for i in range(N):
            if not (current_cover & (1 << i)):
                next_S = S | (1 << i)
                if dp[next_S] > dp[S] + A[i]:
                    dp[next_S] = dp[S] + A[i]
    
    print(ans if ans != INF else 0)

if __name__ == "__main__":
    main()