Problem: Takahashi, who is a novice in competitive programming, wants to learn M algorithms. Initially, his _understanding level_ of each of the M algorithms is 0.  Takahashi is visiting a bookstore, where he finds N books on algorithms. The i-th book (1\leq i\leq N) is sold for C_i yen (the currency of Japan). If he buys and reads it, his understanding level of the j-th algorithm will increase by A_{i,j} for each j (1\leq j\leq M). There is no other way to increase the understanding levels of the algorithms.  Takahashi's objective is to make his understanding levels of all the M algorithms X or higher. Determine whether this objective is achievable. If it is achievable, find the minimum amount of money needed to achieve it.

Submission attempts (in order):
from itertools import combinations as co
n,m,x=map(int,input().split())
A=[[] for i in range(m)]
ansl=[]
for i in range(n):
    A[i].append(map(int,input().split()))
for i in range(n):
    for j in range(1,m+1):
        if A[i][j]<x:
            break
        if j==m:
            ansl.append(A[i][0])

if n==1:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for i,j in co(range(n),2):
    for k in range(1,m+1):
        if A[i][k]+A[j][k]<x:
            break
        if k==m:
            ansl.append(A[i][0]+A[j][0])
if n==2:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for i,j,k in co(range(n),3):
    for l in range(1,m+1):
        if A[i][l]+A[j][l]+A[k][l]<x:
            break
        if l==m:
            ansl.append(A[i][0]+A[j][0]+A[k][0])
if n==3:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for h,i,j,k in co(range(n),4):
    for l in range(1,m+1):
        if A[h][l]+A[i][l]+A[j][l]+A[k][l]<x:
            break
        if l==m:
            ansl.append(A[h][0]+A[i][0]+A[j][0]+A[k][0])
if n==4:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for g,h,i,j,k in co(range(n),5):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [g,h,i,j,k]]))
if n==5:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for f,g,h,i,j,k in co(range(n),6):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [f,g,h,i,j,k]]))
if n==6:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for e,f,g,h,i,j,k in co(range(n),7):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [e,f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [e,f,g,h,i,j,k]]))
if n==7:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for d,e,f,g,h,i,j,k in co(range(n),8):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [d,e,f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [d,e,f,g,h,i,j,k]]))
if n==8:
    print(min(ansl))
    quit()
for c,d,e,f,g,h,i,j,k in co(range(n),9):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [c,d,e,f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [c,d,e,f,g,h,i,j,k]]))
if n==9:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for b,c,d,e,f,g,h,i,j,k in co(range(n),10):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [b,c,d,e,f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [b,c,d,e,f,g,h,i,j,k]]))
if n==10:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for a,b,c,d,e,f,g,h,i,j,k in co(range(n),11):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [a,b,c,d,e,f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [a,b,c,d,e,f,g,h,i,j,k]]))
if n==11:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()
for a0,a,b,c,d,e,f,g,h,i,j,k in co(range(n),12):
    for l in range(1,m+1):
        if sum([A[alp][l] for alp in [a0,a,b,c,d,e,f,g,h,i,j,k]])<x:
            break
        if l==m:
            ansl.append(sum([A[alp][0] for alp in [a0,a,b,c,d,e,f,g,h,i,j,k]]))
if n==12:
    print(min(ansl) if len(ansl)!>0 else "-1")
    quit()


from itertools import combinations as co
n,m,x=map(int,input().split())
A=[]
ansl=[]

for i in range(n):
    A.append(list(map(int,input().split())))
a0,a,b,c,d,e,f,g,h,i,j,k,l=0,0,0,0,0,0,0,0,0,0,0,0,0
alp=[i,(i,j),(i,j,k),(h,i,j,k),(g,h,i,j,k),(f,g,h,i,j,k),(e,f,g,h,i,j,k),(d,e,f,g,h,i,j,k),(c,d,e,f,g,h,i,j,k),(b,c,d,e,f,g,h,i,j,k),(a,b,c,d,e,f,g,h,i,j,k),(a0,a,b,c,d,e,f,g,h,i,j,k)]
for t in range(n):
    for alp[t] in co(range(n),t+1):
        for l in range(1,m+1):
            if sum([A[al][l] for al in alp[t]])<x:
                break
            if l==m:
                ansl.append(sum([A[al][0] for al in alp[t]]))
    if n==t+1:
        print(min(ansl) if len(ansl)>0 else "-1")
        quit()



Verdicts: Runtime Error

Accepted