input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, C = list(map(int,input().split()))
D = [0] * C
for i in range(C):
t = list(map(int,input().split()))
D[i] = t
c = [0] * N
for i in range(N):
t = list(map(int,input().split()))
c[i] = t
Dsum = [0] * C
for k in range(C):
ccc = [0, 0, 0]
for i in range(N):
for j in range(N):
ccc[(i+j)%3] += D[c[i][j]-1][k]
Dsum[k] = ccc
ans = 9876543210
for i in range(C):
for j in range(C):
for k in range(C):
if i != j and j != k and k != i:
ans = min(ans, Dsum[i][0]+Dsum[j][1]+Dsum[k][2])
print(ans) | N, C = list(map(int,input().split()))
D = []
for i in range(C):
t = list(map(int,input().split()))
D.append(t)
c = []
for i in range(N):
t = list(map(int,input().split()))
c.append(t)
Dsum = []
for k in range(C):
ccc = [0, 0, 0]
for i in range(N):
for j in range(N):
ccc[(i+j)%3] += D[c[i][j]-1][k]
Dsum.append(ccc)
ans = 9876543210
for i in range(C):
for j in range(C):
for k in range(C):
if i != j and j != k and k != i:
ans = min(ans, Dsum[i][0]+Dsum[j][1]+Dsum[k][2])
print(ans) | p03330 |
N, C = list(map(int, input().split()))
D = [ [int(i) for i in input().split()] for _ in range(C) ]
c = [ [int(i) for i in input().split()] for _ in range(N) ]
costD = [ [0, 0, 0] for _ in range(C)]
for c0 in range(C):
for i in range(N):
for j in range(N):
costD[c0][(i+j)%3] += D[c[i][j]-1][c0]
kohoD = []
for c1 in range(C):
for c2 in range(C):
if c1 == c2:
continue
for c3 in range(C):
if c1 == c3 or c2 == c3:
continue
kohoD += [(costD[c1][0] + costD[c2][1] + costD[c3][2])]
print((min(kohoD))) | import itertools
def main():
N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(C)]
CC = [list([int(x) - 1 for x in input().split()]) for _ in range(N)]
cost = [[0 for _ in range(C)] for _ in range(3)]
for c in range(C):
for i in range(N):
for j in range(N):
cost[(i + j) % 3][c] += D[CC[i][j]][c]
res = float("inf")
color = [i for i in range(C)]
for i, c in enumerate(list(itertools.permutations(color, 3))):
tmp = 0
for it in range(3):
tmp += cost[it][c[it]]
res = min(res, tmp)
print(res)
main() | p03330 |
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for i in range(C)]
L = [list(map(int,input().split())) for i in range(N)]
d0 = {}
d1 = {}
d2 = {}
for i in range(N) :
for j in range(N) :
before = L[i][j] - 1
if (i+j) % 3 == 0 :
if before not in d0 :
d0[before] = 1
else :
d0[before] += 1
elif (i+j) % 3 == 1 :
if before not in d1 :
d1[before] = 1
else :
d1[before] += 1
else :
if before not in d2 :
d2[before] = 1
else :
d2[before] += 1
B = []
for d in [d0,d1,d2] :
A = []
for after in range(C) :
calc = 0
for before in d :
calc += D[before][after] * d[before]
A.append([calc,after])
A = sorted(A,key=lambda x:x[0],reverse=False)[:3]
B.append(A)
ans = float("inf")
for i in range(3) :
for j in range(3) :
for k in range(3) :
if (B[0][i][1] - B[1][j][1]) * (B[1][j][1] - B[2][k][1]) * (B[2][k][1] - B[0][i][1]) == 0 :
continue
ans = min(ans, B[0][i][0] + B[1][j][0] + B[2][k][0])
print(ans)
| N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for i in range(C)]
L = [list(map(int,input().split())) for i in range(N)]
di = [{}, {}, {}]
for i in range(N) :
for j in range(N) :
num = (i+j) % 3
before = L[i][j] - 1
if before not in di[num] :
di[num][before] = 1
else :
di[num][before] += 1
B = []
for d in di :
A = []
for after in range(C) :
calc = 0
for before in d :
calc += D[before][after] * d[before]
A.append([calc,after])
A = sorted(A,key=lambda x:x[0],reverse=False)[:3]
B.append(A)
ans = float("inf")
for i in range(3) :
for j in range(3) :
for k in range(3) :
if (B[0][i][1] - B[1][j][1]) * (B[1][j][1] - B[2][k][1]) * (B[2][k][1] - B[0][i][1]) == 0 :
continue
ans = min(ans, B[0][i][0] + B[1][j][0] + B[2][k][0])
print(ans)
| p03330 |
import itertools
N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for i in range(C)]
c = [list(map(int, input().split())) for i in range(N)]
# 全探索だと間に合わない
# 一旦実装だけしてみる
corres = list(itertools.permutations(list(range(C)), 3))
ans = float('inf')
indices = [2, 0, 1]
for corr in corres:
cost = 0
for i in range(N):
idx = indices[i%3]
for j in range(N):
cost += D[c[i][j]-1][corr[idx]]
idx = (idx + 1) % 3
ans = min(ans, cost)
print(ans) | N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for i in range(C)]
c = [list(map(int, input().split())) for i in range(N)]
cost0 = []
cost1 = []
cost2 = []
indices = [2, 0, 1]
for color in range(C):
cost = [0, 0, 0]
for i in range(N):
idx = indices[i%3]
for j in range(N):
cost[idx] += D[c[i][j]-1][color]
idx = (idx + 1) % 3
cost0.append([cost[0], color])
cost1.append([cost[1], color])
cost2.append([cost[2], color])
cost0.sort()
cost1.sort()
cost2.sort()
ans = float('inf')
for i in range(3):
for j in range(3):
for k in range(3):
if len(set([cost0[i][1], cost1[j][1], cost2[k][1]])) == 3:
ans = min(ans, cost0[i][0]+cost1[j][0]+cost2[k][0])
print(ans) | p03330 |
# 目指すグリッドは
# ABCABCABC..
# BCABCABCA..
# CABCABCAB..
# ABCABCABC..
# ...
# N = 500なので総マス数は250000
# 色の種類は30種類
# すべてのマスをあまりごとに3グループに分ける
# 各グループにおいて、各色が何マスずつあるかを計算する。250000回
# 長さ30の配列 * 3になるのであとは変更先の色をすべて試す。30 * 3回
# 隣あったマスを同じ色にすることができないため、
# グループごとに候補を3位まで用意し、3 * 2 * 1は6通りをすべて試す。
# 3位と4位がタイのときはどっちを取っても大丈夫
N,C = list(map(int,input().split()))
D = [[0]*C for i in range(C)] # 違和感
for i in range(C):
D[i] = list(map(int,input().split())) # 色は0-indexで指定
# D[i][j]で、iをjに変えるときの違和感を算出
# print(D)
groups = [[0]*C for i in range(3)]
for i in range(N):
line = list(map(int,input().split()))
for j in range(len(line)):
groups[(i+j)%3][line[j] - 1] += 1
# groups[i(グループ名)][j(色 0-index)] = 該当する個数 が出来た。
# 各グループに対して、各色に塗り替えたときの違和感を計算する
pattern = [[[0]*2 for j in range(C)] for i in range(3)]
# pattern[i(グループ名)][j(色 0-index))] = 対象の色に塗り替えたときの違和感
# 30 * 30 = 900, 900 * 3 = 2700
for i in range(len(groups)):
# グループごとのループ
for j in range(C):
# 変更後の色j
iwakan = 0 # 色jに変えるときの違和感を累積
for k in range(len(groups[i])):
# グループiには色kがいくつあるか
iwakan += groups[i][k] * D[k][j]
pattern[i][j][0] = iwakan
pattern[i][j][1] = j # あとで並び替えるため、何色に変えるかをメモしておく
for i in range(len(pattern)):
# print("bef",pattern[i])
pattern[i] = sorted(pattern[i],key = lambda x:x[0])
# print("after",pattern[i])
ans = 10 ** 9 + 7
for a in range(3): # グループ1が何位の数字を使うか
for b in range(3): # 同2
if pattern[0][a][1] == pattern[1][b][1]:
continue
for c in range(3): # 同3
if pattern[0][a][1] == pattern[2][c][1]:
continue
if pattern[1][b][1] == pattern[2][c][1]:
continue
val = pattern[0][a][0] + pattern[1][b][0] + pattern[2][c][0]
if val < ans:
ans = val
print(ans)
| # 目指すグリッドは
# ABCABCABC..
# BCABCABCA..
# CABCABCAB..
# ABCABCABC..
# ...
# N = 500なので総マス数は250000
# 色の種類は30種類
# すべてのマスをあまりごとに3グループに分ける
# 各グループにおいて、各色が何マスずつあるかを計算する。250000回
# 長さ30の配列 * 3になるのであとは変更先の色をすべて試す。30 * 3回
# 隣あったマスを同じ色にすることができないため、
# グループごとに候補を3位まで用意し、3 * 3 * 3 = 27通りをすべて試す。
# 3位と4位がタイのときはどっちを取っても大丈夫
N,C = list(map(int,input().split()))
D = [[0]*C for i in range(C)] # 違和感
for i in range(C):
D[i] = list(map(int,input().split())) # 色は0-indexで指定
# D[i][j]で、iをjに変えるときの違和感を算出
# print(D)
groups = [[0]*C for i in range(3)]
for i in range(N):
line = list(map(int,input().split()))
for j in range(len(line)):
groups[(i+j)%3][line[j] - 1] += 1
# groups[i(グループ名)][j(色 0-index)] = 該当する個数 が出来た。
# 各グループに対して、各色に塗り替えたときの違和感を計算する
pattern = [[[0]*2 for j in range(C)] for i in range(3)]
# pattern[i(グループ名)][j(色 0-index))] = 対象の色に塗り替えたときの違和感
# 30 * 30 = 900, 900 * 3 = 2700
for i in range(len(groups)):
# グループごとのループ
for j in range(C):
# 変更後の色j
iwakan = 0 # 色jに変えるときの違和感を累積
for k in range(len(groups[i])):
# グループiには色kがいくつあるか
iwakan += groups[i][k] * D[k][j]
pattern[i][j][0] = iwakan
pattern[i][j][1] = j # あとで並び替えるため、何色に変えるかをメモしておく
for i in range(len(pattern)):
pattern[i] = sorted(pattern[i],key = lambda x:x[0])
ans = 10 ** 9 + 7
for a in range(3): # グループ1が何位の数字を使うか
for b in range(3): # 同2
if pattern[0][a][1] == pattern[1][b][1]:
continue
for c in range(3): # 同3
if pattern[0][a][1] == pattern[2][c][1]:
continue
if pattern[1][b][1] == pattern[2][c][1]:
continue
val = pattern[0][a][0] + pattern[1][b][0] + pattern[2][c][0]
if val < ans:
ans = val
print(ans)
| p03330 |
n,m=list(map(int,input().split()))
d=[list((list(map(int,input().split())))) for _ in range(m)]
c=[list((list(map(int,input().split())))) for _ in range(n)]
x=[[[True for _ in range(n)] for _ in range(n)] for _ in range(m)]
for k in range(m):
for i in range(n):
for j in range(n):
if c[i][j]==k+1:
x[k][i][j]=False
res=[]
for c1 in range(m):
for c2 in range(m):
for c3 in range(m):
if c1==c2 or c2==c3 or c1==c3:
pass
else:
t=0
for i in range(n):
for j in range(n):
if (i+j)%3==0:
if x[c1][i][j]:
t+=d[c[i][j]-1][c1]
if (i+j)%3==1:
if x[c2][i][j]:
t+=d[c[i][j]-1][c2]
if (i+j)%3==2:
if x[c3][i][j]:
t+=d[c[i][j]-1][c3]
res.append(t)
print((min(res))) | n,m=list(map(int,input().split()))
d=[list((list(map(int,input().split())))) for _ in range(m)]
c=[list((list(map(int,input().split())))) for _ in range(n)]
x=[[0 for _ in range(m)] for _ in range(3)]
for i in range(n):
for j in range(n):
x[(i+j)%3][c[i][j]-1]+=1
res=[]
for c1 in range(m):
for c2 in range(m):
for c3 in range(m):
if c1==c2 or c2==c3 or c1==c3:
pass
else:
ans=0
for i in range(m):
ans+=x[0][i]*d[i][c1]
for i in range(m):
ans+=x[1][i]*d[i][c2]
for i in range(m):
ans+=x[2][i]*d[i][c3]
res.append(ans)
print((min(res))) | p03330 |
import itertools
N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(C)]
G = [list(map(int, input().split())) for _ in range(N)]
count_color = [[0 for _ in range(C+1)] for _ in range(3)]
for y in range(N):
for x in range(N):
count_color[(x+y)%3][G[y][x]] += 1
ans = 10**12
for colors in itertools.permutations(list(range(1, C+1)), 3):
iwakan = 0
for mod in range(3):
for c in range(1, C+1):
iwakan += D[c-1][colors[mod]-1]*count_color[mod][c]
if iwakan < ans:
ans = iwakan
print(ans)
| N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(C)]
G = [list(map(int, input().split())) for _ in range(N)]
GC = []
GC.append([0]*C)
GC.append([0]*C)
GC.append([0]*C)
for y in range(N):
for x in range(N):
GC[(y+x)%3][G[y][x]-1] += 1
ans = 1000000000
for a in range(C):
for b in range(C):
if a == b:
continue
for c in range(C):
if a == c or b == c:
continue
cost = 0
for i in range(C):
cost += GC[0][i]*D[i][a]
cost += GC[1][i]*D[i][b]
cost += GC[2][i]*D[i][c]
ans = min(ans, cost)
print(ans)
| p03330 |
import sys
N = int(sys.stdin.readline().strip())
A = list(map(int, sys.stdin.readline().strip().split()))
ans = 0
for i in range(N):
if i % 2 == 0 and A[i] % 2 == 1:
ans += 1
print(ans) | import sys
N = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))
ans = 0
for i in range(N):
if i % 2 == 0 and A[i] % 2 == 1:
ans += 1
print(ans) | p02607 |
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for i in range(N):
if i%2 == 0 and A[i]%2 != 0:
cnt += 1
else:
continue
print(cnt) | N = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for i in range(0, N, 2):
if A[i]%2 != 0:
cnt += 1
print(cnt) | p02607 |
n = int(eval(input()))
S = list(map(int, input().split()))
ans = 0
for i in range(0, n, 2):
if i%2 == 0 and S[i]%2 == 1:
ans += 1
print(ans)
| n = eval(input())
N = int(n)
list1 = input().split(" ")
Numbers = list1[:N]
count = 0
for i in range(0, N):
if (i+1) % 2 != 0:
if int(Numbers[i]) % 2 != 0:
count += 1
else:
continue
print(count)
| p02607 |
n,*l=list(map(int,open(0).read().split()))
c=0
for e,i in enumerate(l):
c+=((e+1)*i)%2
print(c) | _,*l=list(map(int,open(0).read().split()));print((sum(-~e*i%2 for e,i in enumerate(l)))) | p02607 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
ans = 0
for i in range(n):
if (i+1) % 2:
if a[i] % 2:
ans += 1
print(ans) | #!/usr/bin/env python3
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(0, n, 2):
if a[i] % 2:
ans += 1
print(ans) | p02607 |
print((sum([int(x)%2 for x in open(0).read().split()[1::2]]))) | N, *A = list(map(int, open(0).read().split()))
print((len([a for a in A[::2] if a%2]))) | p02607 |
N, *a = list(map(int, open(0).read().split()))
print((sum(1 for e in a[::2] if e % 2 == 1)))
| N, *a = list(map(int, open(0).read().split()))
print((sum(e % 2 for e in a[::2])))
| p02607 |
n = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
for i in range(n):
if i %2 == 1:
continue
if A[i] % 2 == 1:
ans += 1
print(ans) | n = eval(input())
ans = 0
for i,j in enumerate(map(int,input().split())):
ans += (~i&1 and j&1)
print(ans) | p02607 |
#!/usr/bin/env python3
# atcoder
# Türkler var mı?
# Herkese memnün oldum
import sys
iimr = lambda: map(int, sys.stdin.readline().rstrip().split())
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
MOD = (10 ** 9) + 7 # operować sobie na typie int32_t
def 関数(n, a):
res = 0
for i, num in enumerate(a):
index = i + 1
if index % 2 and num % 2:
res += 1
return res
def çözmek():
N = input()
a = list(iimr())
res = []
res.append(関数(N,a))
print(*res, sep="\n")
if __name__ == "__main__":
çözmek()
| #!/usr/bin/env python3
# atcoder
# Türkler var mı?
# Herkese memnün oldum
import sys
iimr = lambda: map(int, sys.stdin.readline().rstrip().split())
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
MOD = (10 ** 9) + 7 # operować sobie na typie int32_t
def 関数(n, a):
res = 0
for i, num in enumerate(a):
index = i + 1
index %= MOD
if index % 2 and num % 2:
res += 1
return res
def çözmek():
N = input()
a = list(iimr())
res = []
res.append(関数(N,a))
print(*res, sep="\n")
if __name__ == "__main__":
çözmek()
| p02607 |
eval(input())
print((len([i for n,i in enumerate(map(int,input().split()),1) if i%2==1 and n%2]))) | eval(input())
print((len([i for i in list(map(int,input().split()))[::2] if i%2]))) | p02607 |
N = int(eval(input()))
nombres = [int(x) for x in input().split()]
k = 0
for indexe,nombre in enumerate(nombres):
if ((indexe + 1)%2 == 1 and nombre%2 == 1):
k += 1
print(k) | n = int(eval(input()))
A = [int(x) for x in input().split()]
comp = 0
for el in range(0, n, 2):
if A[el] % 2 != 0:
comp += 1
print(comp) | p02607 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans=0
for i in range(0, N, 2):
if A[i]%2==1:
ans+=1
print(ans) | n=int(eval(input()))
a=list(map(int, input().split()))
ans=0
for i in range(0,n,2):
if a[i]%2==1:
ans+=1
print(ans) | p02607 |
N = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(0, N):
if (i+1) % 2 != 0 and a[i] % 2 != 0:
cnt += 1
print(cnt) | N = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(0, N, 2):
if a[i] % 2 != 0:
cnt += 1
print(cnt) | p02607 |
class BIT():
def __init__(self,number):
self.n=number
self.list=[0]*(number+1)
def add(self,i,x):#ith added x 1indexed
while i<=self.n:
self.list[i]+=x
i+=i&-i
def search(self,i):#1-i sum
s=0
while i>0:
s+=self.list[i]
i-=i&-i
return s
def suma(self,i,j):#i,i+1,..j sum
return self.search(j)-self.search(i-1)
N=int(eval(input()))
A=[int(i) for i in input().split()]
if ((N*(N+1))//2)%2==1:
a=((N*(N+1))//2)//2+1
else:
a=((N*(N+1))//2)//2
#a=((N*(N+1))//2)-((N*(N+1))//2)//2-1
def f(s):#ans is ijou s
X=[1 if a>=s else -1 for a in A]
p=[0]*(N+1)
for i in range(1,N+1):
p[i]=p[i-1]+X[i-1]
tree=BIT(2*N+1)
num=0
for i in range(1,N+2):
num+=tree.search(p[i-1]+N+1)
tree.add(p[i-1]+N+1,1)
if num>=a:
return True
else:
return False
x=10**9+1
y=-1
while x-y>1:
mid=(x+y)//2
if f(mid):
y=mid
else:
x=mid
print(y)
| class BIT():
def __init__(self,number):
self.n=number
self.list=[0]*(number+1)
def add(self,i,x):#ith added x 1indexed
while i<=self.n:
self.list[i]+=x
i+=i&-i
def search(self,i):#1-i sum
s=0
while i>0:
s+=self.list[i]
i-=i&-i
return s
def suma(self,i,j):#i,i+1,..j sum
return self.search(j)-self.search(i-1)
N=int(eval(input()))
A=[int(i) for i in input().split()]
if ((N*(N+1))//2)%2==1:
a=((N*(N+1))//2)//2+1
else:
a=((N*(N+1))//2)//2
#a=((N*(N+1))//2)-((N*(N+1))//2)//2-1
def f(s):#ans is ijou s
X=[1 if a>=s else -1 for a in A]
p=[0]*(N+1)
ma=0
mi=0
for i in range(1,N+1):
p[i]=p[i-1]+X[i-1]
ma=max(p[i],ma)
mi=min(p[i],mi)
tree=BIT(ma-mi+1)
num=0
for i in range(1,N+2):
num+=tree.search(p[i-1]-mi+1)
tree.add(p[i-1]-mi+1,1)
if num>=a:
return True
else:
return False
x=10**9+1
y=-1
while x-y>1:
mid=(x+y)//2
if f(mid):
y=mid
else:
x=mid
print(y)
| p03277 |
n = int(eval(input()))
a = list(map(int, input().split()))
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i&(-i)
return s
def add(self, i, x):
while i <= self.n:
self.bit[i] += x
i += i&(-i)
left, right = 0, 10**9
geta = n+1
while right-left > 1:
mid = (left+right)//2
num = 0
bit = BIT(2*n+1)
sum_ = 0
bit.add(sum_+geta, 1)
for i in range(n):
val = 1 if a[i] <= mid else -1
sum_ += val
num += bit.sum(sum_+geta-1)
bit.add(sum_+geta, 1)
if num > n*(n+1)//4:
right = mid
else:
left = mid
print(right)
| import math
n = int(eval(input()))
a = list(map(int, input().split()))
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i&(-i)
return s
def add(self, i, x):
while i <= self.n:
self.bit[i] += x
i += i&(-i)
a_sorted = sorted(list(set(a)))
left, right = 0, len(a_sorted) # number of unique elements of a
while right-left > 1: # bisection search: O(logA)
mid = (left+right)//2 # target index
num = 0 # number of ranges with majority >= a_sorted[mid]
bit = BIT(2*n+1) # initialize BIT: #regsum = bit.sum(regsum(+n))
sum_ = 0 # region sum
bit.add(sum_+n, 1)
for i in range(n): # O(n)
sum_ += 1 if a[i] >= a_sorted[mid] else -1 # update region sum by comaprison
num += bit.sum(sum_+n) # add #ranges by sum_+n: O(logn)
bit.add(sum_+n, 1) # increment BIT element at sum_+n(=count of interested regions)
# print(bit.bit, left, right)
# update search range
if num >= math.ceil(n*(n+1)//4):
left = mid
else:
right = mid
print((a_sorted[left]))
| p03277 |
N=int(eval(input()))
A=[int(i) for i in input().split()]
sorted_A=sorted(A)
def add(B,a,n):
x = a
while x<=n:
B[x]+=1
x+=x&(-x)
def sums(B,a):
x=a
S=0
while x!=0:
S+=B[x]
x-=x&(-x)
return S
def invnumber(n,A):
S=[0]*n
A=sorted([(A[i],i) for i in range(n)])
for i in range(1,n):
S[A[i][1]]=i
B=[0]*(n*2+1)
invs=0
for i in range(n):
s=S[i]+n
invs+=sums(B,s)
add(B,s,n*2)
return n*(n-1)//2-invs
def Check(x):
S=[0]
for i in range(N):
if A[i]>sorted_A[x]:
S.append(S[-1]+1)
else:
S.append(S[-1]-1)
return invnumber(N+1,S)
l,r=0,N-1
while l<r:
m=(l+r)//2
if Check(m)>(N*(N+1)//4):
r=m
else:
l=m+1
print((sorted_A[l]))
| N=int(eval(input()))
A=[int(i) for i in input().split()]
sorted_A=sorted(A)
def add(B,a,n):
x = a
while x<=n:
B[x]+=1
x+=x&(-x)
def sums(B,a):
x=a
S=0
while x!=0:
S+=B[x]
x-=x&(-x)
return S
def invnumber(n,A):
B=[0]*(n*2+1)
invs=0
for i in range(n):
s=A[i]+n
invs+=sums(B,s)
add(B,s,n*2)
return n*(n-1)//2-invs
def Check(x):
S=[0]
for i in range(N):
if A[i]>sorted_A[x]:
S.append(S[-1]+1)
else:
S.append(S[-1]-1)
return invnumber(N+1,S)
l,r=0,N-1
while l<r:
m=(l+r)//2
if Check(m)>N*(N+1)//4:
r=m
else:
l=m+1
print((sorted_A[l]))
| p03277 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
def init(bit, values):
for i,v in enumerate(values):
update(bit,i,v)
#A1 ~ Aiまでの和 O(logN)
def query(bit,i):
res_sum = 0
while i > 0:
res_sum += bit[i]
i -= i&(-i)
return res_sum
#Ai += x O(logN)
def update(bit,i,x):
while i <= len(bit)-1:
bit[i] += x
i += i&(-i)
return
n = int(eval(input()))
a = list(map(int, input().split()))
from collections import Counter
def sub(x):
cumsum = [None] * n
cumsum[0] = 1 if a[0]>=x else -1
for i in range(1,n):
cumsum[i] = cumsum[i-1] + (1 if a[i]>=x else -1)
### BIT
#A1 ... AnのBIT(1-indexed)
bit = [0]*(2*n+2)
update(bit, n+1, 1)
ans = 0
for v in cumsum:
ans += query(bit, v+n+1)
update(bit, n+v+1, 1)
return ans
l = 0
r = 10**9+1
tmp = (n+1)*n//2
thre = tmp//2 + tmp%2
while l<r-1:
m = (l+r)//2
if sub(m)>=thre:
l = m
else:
r = m
print(l) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
a = list(map(int, input().split()))
from collections import Counter
def sub(x):
l = [1 if item>=x else -1 for item in a]
count = [0] * (2*n+2)
count[n] = 1
i = n
cumsum = 1
ans = 0
for item in l:
i += item
if item==1:
cumsum += count[i]
else:
cumsum -= count[i+1]
ans += cumsum
count[i] += 1
cumsum += 1
return ans
l = 0
r = 10**9+1
tmp = (n+1)*n//2
thre = tmp//2 + tmp%2
while l<r-1:
m = (l+r)//2
if sub(m)>=thre:
l = m
else:
r = m
print(l) | p03277 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def add(i):
while i < len(bit):
bit[i] += 1
i += i&-i
def sum(i):
res = 0
while i > 0:
res += bit[i]
i -= i&-i
return res
n = I()
a = LI()
k = ((n*(n+1)) >> 1) >> 1
l = 0
r = max(a)+1
while r-l > 1:
m = (l+r) >> 1
b = [2*(i < m)-1 for i in a]
s = [0]
for i in b:
s.append(s[-1]+i)
b = list(set([i for i in s]))
b.sort()
s = [bisect.bisect_left(b,i)+2 for i in s]
bit = [0]*(max(s)+1)
res = 0
for i in s:
res += sum(i)
add(i+1)
if res <= k:
l = m
else:
r = m
print(l)
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def add(i):
while i < len(bit):
bit[i] += 1
i += i&-i
def sum(i):
res = 0
while i > 0:
res += bit[i]
i -= i&-i
return res
n = I()
a = LI()
f = list(set(a))
f.sort()
c = [bisect.bisect_left(f,i) for i in a]
k = ((n*(n+1)) >> 1) >> 1
l = 0
r = len(f)
while r-l > 1:
m = (l+r) >> 1
b = [2*(i < m)-1 for i in c]
s = [0]
for i in b:
s.append(s[-1]+i)
b = list(set([i for i in s]))
b.sort()
s = [bisect.bisect_left(b,i)+1 for i in s]
bit = [0]*(max(s)+1)
res = 0
for i in s:
res += sum(i)
add(i+1)
if res <= k:
l = m
else:
r = m
print((f[l]))
return
#Solve
if __name__ == "__main__":
solve()
| p03277 |
from operator import itemgetter
class BIT():
"""一点加算、区間取得クエリをそれぞれO(logN)で答える
add: i番目にvalを加える
get_sum: 区間[l, r)の和を求める
i, l, rは0-indexed
"""
def __init__(self, n):
self.n = n
self.bit = [0] * (n + 1)
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
"""i番目にvalを加える"""
i = i + 1
while i <= self.n:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
"""区間[l, r)の和を求める"""
return self._sum(r) - self._sum(l)
n =int(eval(input()))
a = list(map(int, input().split()))
def solve(val):
ruiseki = [0] * (n + 1)
for i, num in enumerate(a):
if num >= val:
ruiseki[i + 1] = ruiseki[i] + 1
else:
ruiseki[i + 1] = ruiseki[i] - 1
b = sorted(enumerate(ruiseki), key = itemgetter(1))
for i in range(n + 1):
bit.bit[i] = 0
res = 0
for i, _ in b:
bit.add(i, 1)
res += bit.get_sum(0, i)
if res >= cnt:
return True
return False
cnt = 0
for i in range(n):
cnt += n - i
cnt = (cnt + 1) // 2
bit = BIT(n + 1)
ok = 0
ng = 10**9 + 1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if solve(mid):
ok = mid
else:
ng = mid
print(ok) | from operator import itemgetter
import sys
input = sys.stdin.readline
class BIT():
"""一点加算、区間取得クエリをそれぞれO(logN)で答える
add: i番目にvalを加える
get_sum: 区間[l, r)の和を求める
i, l, rは0-indexed
"""
def __init__(self, n):
self.n = n
self.bit = [0] * (n + 1)
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
"""i番目にvalを加える"""
i = i + 1
while i <= self.n:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
"""区間[l, r)の和を求める"""
return self._sum(r) - self._sum(l)
n =int(eval(input()))
a = list(map(int, input().split()))
a_sorted = sorted(a)
def solve(val):
val = a_sorted[val]
ruiseki = [0] * (n + 1)
for i, num in enumerate(a):
if num >= val:
ruiseki[i + 1] = ruiseki[i] + 1
else:
ruiseki[i + 1] = ruiseki[i] - 1
b = sorted(enumerate(ruiseki), key = itemgetter(1))
for i in range(n + 1):
bit.bit[i] = 0
res = 0
for i, _ in b:
bit.add(i, 1)
res += bit.get_sum(0, i)
if res >= cnt:
return True
return False
cnt = 0
for i in range(n):
cnt += n - i
cnt = (cnt + 1) // 2
bit = BIT(n + 1)
ok = 0
ng = n
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if solve(mid):
ok = mid
else:
ng = mid
print((a_sorted[ok])) | p03277 |
N=int(eval(input()))
alist=list(map(int,input().split()))
numlist=[]
if len(alist)==1:
print((alist[0]))
exit()
i=1
for x in range(0,((N+1)//2)):
numlist+=[alist[x]]*i
i+=2
i=2
for x in range(N-1,((N+1)//2)-1,-1):
numlist+=[alist[x]]*i
i+=2
numlist.sort()
print((numlist[len(numlist)//2+1])) | N=int(eval(input()))
alist=list(map(int,input().split()))
numdict={}
amount=0
if len(alist)==1:
print((alist[0]))
exit()
for x in alist:
if x in numdict:
numdict[x]+=1
else:
numdict[x]=1
medilist=alist.copy()
newmedilist=[]
for i in range(1,N):
if i%2:
for x in range(0,N-i):
num=max(medilist[x],alist[x+i])
numdict[num]+=1
newmedilist.append(num)
else:
for x in range(0,N-i):
num=min(medilist[x],alist[x+i])
numdict[num]+=1
newmedilist.append(num)
medilist=newmedilist
b=N*(N+1)//4+1
numlist=sorted(numdict.keys())
c=0
for x in numlist:
c+=numdict[x]
if c>=b:
break
print(x) | p03277 |
import itertools
N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BinaryIndexedTree:
"""
Parameters
----------
array : list
to construct BIT from
f : func
binary operation of the abelian group
fi : func
inverse mapping of f
i.e. f(a, b) == c <-> fi(c, a) == b
e :
identity element of the abelian group
size : int
limit for array size
"""
def __init__(self, array, f, fi, e, size):
self.f = f
self.fi = fi
self.e = e
self.size = size
self.n = len(array)
self.dat = [e] * (size + 1)
self.array = [e] * size
self.build(array)
def build(self, array_):
for i, v in enumerate(array_):
self.modify(i, v)
def modify(self, p, v):
"""
set value at position p (0-indexed)
"""
fi, dat, f, size, array = self.fi, self.dat, self.f, self.size, self.array
dv = fi(v, array[p])
array[p] = v
p += 1
while p <= size:
dat[p] = f(dat[p], dv)
p += p & -p
def query(self, l, r):
"""
result on interval [l, r) (0-indexed)
"""
return self.fi(self._query(r), self._query(l))
def _query(self, p):
dat, f, res = self.dat, self.f, self.e
while p:
res = f(res, dat[p])
p -= p & -p
return res
e = 0
size = 2 * N + 2
f = lambda a, b: a + b
fi = lambda c, a: c - a
offset = N
def check(x):
cumsum = list(itertools.accumulate([0] + [1 if a <= x else -1 for a in A]))
# sum([l:r)) = cumsum[r] - cumsum[l] >= 0
# ⇔ cumsum[l] <= cumsum[r]
BIT = BinaryIndexedTree([e] * size, f=f, fi=fi, e=e, size=size)
count = 0
for c in cumsum:
c += offset
count += BIT.query(0, c + 1)
BIT.modify(c + 1, BIT.query(c + 1, c + 2) + 1)
return 2 * count > N * (N + 1) // 2
lb = -1
rb = 10**9 + 10
# check(x) == Trueとなる最小のx
while rb - lb > 1:
mid = (rb + lb) // 2
if check(mid):
rb = mid
else:
lb = mid
print(rb)
| import itertools
N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BinaryIndexedTree:
"""
Parameters
----------
array : list
to construct BIT from
f : func
binary operation of the abelian group
fi : func
inverse mapping of f
i.e. f(a, b) == c <-> fi(c, a) == b
e :
identity element of the abelian group
size : int
limit for array size
"""
def __init__(self, array, f, fi, e, size):
self.f = f
self.fi = fi
self.e = e
self.size = size
self.n = len(array)
self.dat = [e] * (size + 1)
self.array = [e] * size
self.build(array)
def build(self, array_):
for i, v in enumerate(array_):
self.modify(i, v)
def modify(self, p, v):
"""
set value at position p (0-indexed)
"""
fi, dat, f, size, array = self.fi, self.dat, self.f, self.size, self.array
dv = fi(v, array[p])
array[p] = v
p += 1
while p <= size:
dat[p] = f(dat[p], dv)
p += p & -p
def query(self, l, r):
"""
result on interval [l, r) (0-indexed)
"""
return self.fi(self._query(r), self._query(l))
def _query(self, p):
dat, f, res = self.dat, self.f, self.e
while p:
res = f(res, dat[p])
p -= p & -p
return res
e = 0
size = 2 * N + 2
f = lambda a, b: a + b
fi = lambda c, a: c - a
offset = N
def check(x):
cumsum = list(itertools.accumulate([0] + [1 if a <= x else -1 for a in A]))
# sum([l:r)) = cumsum[r] - cumsum[l] >= 0
# ⇔ cumsum[l] <= cumsum[r]
BIT = BinaryIndexedTree([e] * size, f=f, fi=fi, e=e, size=size)
count = 0
for c in cumsum:
c += offset
count += BIT.query(0, c + 1)
BIT.modify(c + 1, BIT.query(c + 1, c + 2) + 1)
return 2 * count > N * (N + 1) // 2
A_sorted = [0] + sorted(set(A)) + [10**10]
lb = 0
rb = len(A_sorted) - 1
# check(x) == Trueとなる最小のx
while rb - lb > 1:
mid = (rb + lb) // 2
if check(A_sorted[mid]):
rb = mid
else:
lb = mid
print((A_sorted[rb]))
| p03277 |
def d_median_of_medians(N, A):
class BIT(object):
def __init__(self, n):
self.size = n
self.tree = [0] * (self.size + 1)
def __str__(self):
return '[{}]'.format(', '.join(map(str, self.tree)))
def sum(self, index):
# 1からindexまでの和を計算
ret = 0
x = index
while x > 0:
ret += self.tree[x]
x -= x & (-x)
return ret
def add(self, index, value):
# tree[index]にvalueを加算
x = index
while x <= self.size:
self.tree[x] += value
x += x & (-x)
def pair(x):
a_prime = [-1] * N
for k in range(N):
if A[k] >= x:
a_prime[k] = 1 # x未満か否かを{-1, 1}に圧縮
s = [0]
min_s = 0
max_s = 0
tmp = 0
# 累積和と最小値, 最大値を同時に計算
for a in a_prime:
tmp += a
min_s = min(min_s, tmp)
max_s = max(max_s, tmp)
s.append(tmp)
bit_size = max_s - min_s + 1 # BITのサイズ
bit = BIT(bit_size)
ans = 0
for sk in s:
sk -= (min_s - 1) # sの最小値を1に調整
ans += bit.sum(sk)
bit.add(sk, 1)
return ans
# l<=rとなる(l, r)の取り方について、その半分以上の値を返す最大の値が中央値
border_median = (N * (N + 1) // 2 + 1) // 2
ok = 0
ng = 10**9 + 3
while ng - ok > 1:
mid = (ok + ng) // 2
if pair(mid) >= border_median:
ok = mid
else:
ng = mid
ans = ok
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((d_median_of_medians(N, A))) | def d_median_of_medians(N, A):
class BIT(object):
def __init__(self, n):
self.size = n
self.tree = [0] * (self.size + 1)
def __str__(self):
return '[{}]'.format(', '.join(map(str, self.tree)))
def sum(self, index):
# 1からindexまでの和を計算
ret = 0
x = index
while x > 0:
ret += self.tree[x]
x -= x & (-x)
return ret
def add(self, index, value):
# tree[index]にvalueを加算
x = index
while x <= self.size:
self.tree[x] += value
x += x & (-x)
def pair(x):
a_prime = [-1] * N
for k in range(N):
if A[k] >= x:
a_prime[k] = 1 # x未満か否かを{-1, 1}に圧縮
s = [0]
min_s = 0
max_s = 0
tmp = 0
# 累積和と最小値, 最大値を同時に計算
for a in a_prime:
tmp += a
min_s = min(min_s, tmp)
max_s = max(max_s, tmp)
s.append(tmp)
bit_size = max_s - min_s + 1 # BITのサイズ
bit = BIT(bit_size)
ans = 0
for sk in s:
sk -= (min_s - 1) # sの最小値を1に調整
ans += bit.sum(sk)
bit.add(sk, 1)
return ans
# l<=rとなる(l, r)の取り方について、その半分以上の値を返す最大の値が中央値
border_median = (N * (N + 1) // 2 + 1) // 2
ok = 0
ng = 10**9 + 1 # 数列の要素の値の制約から、この値は中央値になりえない
while ng - ok > 1:
mid = (ok + ng) // 2
if pair(mid) >= border_median:
ok = mid
else:
ng = mid
ans = ok
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((d_median_of_medians(N, A))) | p03277 |
# coding: utf-8
import sys
# import bisect
# import math
# import numpy as np
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: 数
"""
return int(self.input())
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if ((i >> j) & 1) == 1:
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
"""ここからメインコード"""
def main():
# 1文字に省略
r, e = range, enumerate
ip = IP()
id = Idea()
"""この下から書いてね"""
s = str(ip.I())
ans = 0
# 最後に+は付けられない
n = len(s) - 1
# bit全探索
for i in r(1 << n):
# sの中に+を入れて計算する
p = ""
for j in r(n):
p += s[j]
if (i >> j & 1) > 0:
p += "+"
p += s[-1]
ans += eval(p)
print(ans)
main()
| # coding: utf-8
import sys
# import bisect
# import math
# import numpy as np
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: 数
"""
return int(self.input())
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if ((i >> j) & 1) == 1:
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
"""ここからメインコード"""
def main():
# 1文字に省略
r, e = range, enumerate
ip = IP()
id = Idea()
"""この下から書いてね"""
s = str(ip.I())
ans = 0
# 最後に+は付けられない
n = len(s) - 1
# bit全探索
for i in r(1 << n):
# sの中に+を入れて計算する
p = ""
for j, d in e(s):
p += d
if (i >> j & 1) > 0:
p += "+"
if j == n:
break
# p += s[-1]
ans += eval(p)
print(ans)
main()
| p04001 |
# coding: utf-8
import sys
# import bisect
# import math
# import numpy as np
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: 数
"""
return int(self.input())
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e = range, enumerate
ip = IP()
id = Idea()
"""この下から書いてね"""
s = str(ip.I())
ans = 0
# 最後に+は付けられない
# bit全探索
for i in r(1 << len(s) - 1):
# sの中に+を入れて計算する
p = ""
for j, d in e(s):
p += d
if id.bit_n(i, j):
p += "+"
if j == len(s) - 1:
break
ans += eval(p)
print(ans)
main()
| import sys
# import bisect
# import math
# import itertools
# import numpy as np
# import collections
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e, p = range, enumerate, print
ip = IP()
id = Idea()
mod = 10 ** 9 + 7
"""この下から書いてね"""
s = str(ip.I())
ans = 0
for i in r(1 << len(s) - 1):
output = 0
res = 0
for j in r(len(s) - 1):
if (i >> j) & 1:
output += int(s[res:j + 1])
res = j + 1
output += int(s[res:len(s)])
ans += output
p(ans)
main()
| p04001 |
from itertools import combinations
S = str(eval(input()))
pos = [i for i in range(len(S)-1)]
insert_indices = [comb for i in range(len(S)) for comb in combinations(pos, i)]
ans = 0
for inds in insert_indices:
cur_ix = 0
cur_ans = 0
while cur_ix < len(S):
cur_ans += int(S[cur_ix])
if cur_ix == len(S)-1:
break
if cur_ix in inds:
ans += cur_ans
cur_ans = 0
else:
cur_ans *= 10
cur_ix += 1
ans += cur_ans
print(ans)
| from itertools import combinations
S = str(eval(input()))
n = len(S)
ans = 0
for i in range(1 << (n-1)):
cur_ans = int(S[0])
for j in range(n-1):
add_plus = (i >> (n-2-j)) & 1
if add_plus:
ans += cur_ans
cur_ans = 0
else:
cur_ans *= 10
cur_ans += int(S[j+1])
ans += cur_ans
print(ans)
| p04001 |
from itertools import permutations
import sys, re
inp = sys.stdin.readline().strip()
perms = []
used = []
total = 0
#orig = inp
def checkOrder(check, inp):
count = 0
for i in range(len(check)):
if check[i] == '+':
continue
elif check[i] == inp[count]:
count += 1
else:
return False
return True
for i in range(0, len(inp)):
withPlus = inp + '+' * i
perms = [''.join(p) for p in permutations(withPlus)]
for perm in perms:
if not re.match(r'.*\+\+.*', perm) and not perm[0] == '+' and not perm[-1] == '+':
if checkOrder(perm, inp) and not perm in used:
total += eval(perm)
used.append(perm)
print(total)
| import sys
perm = sys.stdin.readline().strip()
total = 0
# Add n * '+' to inp
def addPlus(inp, n):
total = 0
possible = [inp]
orig = inp
for i in range(1, len(orig)):
possible.append(orig[:i] + '+' + perm[i:])
for i in range(1, n):
curr = possible[:]
for item in curr:
for j in range(1, len(item)):
processed = item[:j] + '+' + item[j:]
if processed not in possible:
if '++' not in processed:
possible.append(processed)
for item in possible:
total += eval(item)
return total
print((addPlus(perm, len(perm) - 1)))
| p04001 |
import sys
def pokakito(num_line):
if not num_line and flag == 1:
result_lis.append(check_num)
return True
for num in num_line:
if three(num, num_line): return True
if two(num, num_line): return True
if straight(num, num_line): return True
def three(num, num_line):
count = 0
for check in num_line[:3]:
if check == num:
count += 1
else:
if count == 3:
if pokakito(num_line[3:]): return True
def two(num, num_line):
global flag
count = 0
for check in num_line[:2]:
if check == num:
count += 1
else:
if count == 2:
flag += 1
if pokakito(num_line[2:]): return True
flag -= 1
def straight(num, num_line):
num_lis = [num,num+1,num+2]
for i in range(3):
for check in num_lis:
if check < 0 or (not check in num_line):
for i in range(3):
num_lis[i] = num_lis[i]-1
break
else:
for n in num_lis:
index = 0
while num_line:
if num_line[index] == n:
del num_line[index]
break
index += 1
else:
if pokakito(num_line): return True
flag = 0
result_lis = []
check_num = 0
for input_line in sys.stdin:
for i in range(9):
check_num = i+1
input_line = input_line.rstrip()
line = sorted(input_line + str(check_num))
line = ''.join(line)
index = line.find(str(check_num))
if line[index:index+5] == str(check_num)*5:
continue
pokakito([int(char) for char in line])
result = sorted([str(num) for num in result_lis])
flag = 0
else:
if result_lis:
print(' '.join(result))
else:
print(0)
flag = 0
result_lis = []
check_num = 0 | import sys
def pokakito(num_line):
if not num_line and flag == 1:
result_lis.append(check_num)
return True
for num in num_line:
if three(num, num_line): return True
if two(num, num_line): return True
if straight(num, num_line): return True
def three(num, num_line):
count = 0
for check in num_line[:3]:
if check == num:
count += 1
else:
if count == 3:
if pokakito(num_line[3:]): return True
def two(num, num_line):
global flag
count = 0
for check in num_line[:2]:
if check == num:
count += 1
else:
if count == 2:
flag += 1
if pokakito(num_line[2:]): return True
flag -= 1
def straight(num, num_line):
for check in [num,num+1,num+2]:
if not check in num_line:
break
else:
for n in [num,num+1,num+2]:
index = 0
while num_line:
if num_line[index] == n:
del num_line[index]
break
index += 1
else:
if pokakito(num_line): return True
flag = 0
result_lis = []
check_num = 0
for input_line in sys.stdin:
for i in range(9):
check_num = i+1
input_line = input_line.rstrip()
line = sorted(input_line + str(check_num))
line = ''.join(line)
index = line.find(str(check_num))
if line[index:index+5] == str(check_num)*5:
continue
pokakito([int(char) for char in line])
result = sorted([str(num) for num in result_lis])
flag = 0
else:
if result_lis:
print(' '.join(result))
else:
print(0)
flag = 0
result_lis = []
check_num = 0 | p00043 |
import itertools
N, M = list(map(int,input().split()))
def main():
k = []
s = []
answers = []
for i in range(M + 1):
inputs = list(map(int,input().split()))
if i == M:
answers = inputs.copy()
else:
k.append(inputs[0])
s.append(inputs[1:])
allCandidates = []
for i in range(N + 1):
candidates = [1] * i + [0] * (N - i)
allCandidates.extend(list(itertools.permutations(candidates)))
result = []
for c in allCandidates:
ok = True
for i, ss in enumerate(s):
sumBulk = 0
for sNumber in ss:
sumBulk += c[sNumber - 1]
if sumBulk % 2 != answers[i]:
ok = False
if ok:
result.append(c)
print((len(list(set(result)))))
if __name__ == '__main__':
main() | import itertools
N, M = list(map(int,input().split()))
def main():
k = []
s = []
answers = []
for i in range(M + 1):
inputs = list(map(int,input().split()))
if i == M:
answers = inputs.copy()
else:
k.append(inputs[0])
s.append(inputs[1:])
allCandidates = (list(itertools.product(list(range(2)), repeat=N)))
result = []
for c in allCandidates:
ok = True
for i, ss in enumerate(s):
sumBulk = 0
for sNumber in ss:
sumBulk += c[sNumber - 1]
if sumBulk % 2 != answers[i]:
ok = False
if ok:
result.append(c)
print((len(list(set(result)))))
if __name__ == '__main__':
main() | p03031 |
n, m = list(map(int, input().split()))
k = [list(map(int, input().split()))[1:] for _ in range(m)]
p = list(map(int, input().split()))
answer = 0
## k = sorted(k, reverse=True, key=lambda x: len(x))
all = [] # 全てのスイッチの状態
for i in range(0, 2**n):
all.append(list(str(format(i, 'b').zfill(n))))
for a in all:
for index in range(len(k)):
switch_count = 0
for switch in k[index]: #1,2
switch_count+=int(a[switch-1])
#一つの電球に繋がってる全てのスイッチ確認終了
if switch_count%2 == p[index]:
if index == len(k)-1:
answer+=1
continue
break
print(answer)
| #!/usr/bin/env python3
def main():
N,M = list(map(int,input().split()))
K = []
s = []
answer = 0
for _ in range(M):
ks = list(map(int,input().split()))
K.append(ks[0])
s.append(ks[1:])
p = list(map(int,input().split()))
for switch in range(0,2**N):
for j in range(M):
count = 0
for k in s[j]:
if 1 << k-1 & switch:
count += 1
if count%2 == p[j]:
continue
else:
break
else:
answer +=1
print(answer)
if __name__ == '__main__':
main()
| p03031 |
n,m = list(map(int,input().split()))
l_list = [list(map(int,input().split())) for i in range(m)]
p = list(map(int,input().split()))
output = 0
for i in range(2 ** n):
lights = []
for j in range(n+1):
if ((i >> j) & 1):
lights.append(j+1)
for inde, l in enumerate(l_list):
if len(set(l[1:]) & set(lights)) % 2 != p[inde]:
break
else:
output += 1
print(output) | n,m = list(map(int,input().split()))
l_list = [list(map(int,input().split())) for i in range(m)]
p = list(map(int,input().split()))
output = 0
for i in range(2 ** n):
lights = []
for j in range(n+1):
if ((i >> j) & 1):
lights.append(j+1)
for k, l in enumerate(l_list):
if len(set(l[1:]) & set(lights)) % 2 != p[k]:
break
else:
output += 1
print(output) | p03031 |
n, m = list(map(int, input().split()))
bits = '0b' + '1' * n
s = []
for _ in range(m):
i = [int(i) for i in input().split()]
s.append(i[1:])
p = [int(i) for i in input().split()]
c = 0
for i in range(2**n):
l = bin(i)[2:]
b = (n - len(l)) * '0' + l
addable = True
for h, j in enumerate(s):
d = 0
for k in j:
d += int(b[k - 1])
if addable:
addable = d % 2 == p[h]
if addable:
c += 1
print(c) | n, m = list(map(int, input().split()))
s = [[int(i) for i in input().split()[1:]] for _ in range(m)]
p = [int(i) for i in input().split()]
c = 0
for i in range(2**n):
addable = True
for j in range(m):
d = sum(2 ** (k - 1) for k in s[j])
if bin(i & d).count('1') % 2 != p[j]:
addable = False
break
if addable:
c += 1
print(c)
| p03031 |
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(M)]
P = list(map(int, input().split()))
ans = 0
for bit in range(2 ** N):
ons = set([i + 1 for i in range(N) if bit >> i & 1])
flg = True
for i in range(M):
k, *s = X[i]
p = P[i]
flg &= len(set(s) & ons) % 2 == p
ans += int(flg)
print(ans)
|
N, M = list(map(int, input().split()))
K = []
X = []
for _ in range(M):
k, *x = list(map(int, input().split()))
K.append(k)
X.append(x)
P = list(map(int, input().split()))
ans = 0
for bit in range(2 ** N):
light_on = [False] * M
for i in range(M):
tmp = 0
for s in X[i]:
tmp += bit >> (s - 1) & 1
light_on[i] = tmp % 2 == P[i]
ans += all(light_on)
print(ans)
| p03031 |
# -*- coding: utf-8 -*-
"""
Created on Sun May 26 20:56:00 2019
@author: Yamazaki Kenichi
"""
N,M = list(map(int,input().split()))
ks = [list(map(int,input().split())) for i in range(M)]
p = list(map(int,input().split()))
ans = 0
for i in range(2**N):
t = '{:010b}'.format(i)
flg = True
for j in range(M):
tmp = 0
for k in range(ks[j][0]):
tmp += int(t[-ks[j][k+1]])
# print(i,j,t,tmp,ans)
if tmp%2 == p[j]:
continue
else:
flg = False
break
# print(i,j,t,tmp,ans,flg)
if flg:
ans += 1
print(ans) | # -*- coding: utf-8 -*-
"""
Created on Mon May 27 21:28:42 2019
@author: Yamazaki Kenichi
"""
N, M = list(map(int,input().split()))
ks = [list(map(int,input().split())) for i in range(M)]
p = list(map(int,input().split()))
S = [0 for i in range(M)]
for i in range(M):
for j in range(1,ks[i][0]+1):
S[i] += 2**(ks[i][j]-1)
ans = 0
for i in range(2**N):
flg = True
for j in range(M):
if ('{:010b}'.format(S[j]&i)).count('1') % 2 == p[j]:
continue
else:
flg = False
break
if flg:
ans += 1
print(ans) | p03031 |
n, m = list(map(int, input().split()))
lst_sw = []
for _ in range(m):
lst_sw.append(list(map(int, input().split())))
lst_p = list(map(int, input().split()))
ans = 0
for bits in range(2 ** n):
judge = True
for i in range(m):
cnt = 0
for j in range(1, len(lst_sw[i])):
sw = lst_sw[i][j]
if (bits >> (sw - 1)) & 1:
# if (1 << (sw - 1)) & bits: # こちらの判定でも良い
cnt += 1
if cnt%2 != lst_p[i]:
judge = False
if judge:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
lst_sw = []
for _ in range(m):
lst_sw.append(list(map(int, input().split())))
lst_p = list(map(int, input().split()))
ans = 0
for bits in range(2 ** n):
judge = True
for i in range(m):
cnt_sw_on = 0
for j in range(1, len(lst_sw[i])):
sw = lst_sw[i][j]
if (bits >> (sw - 1)) & 1:
cnt_sw_on += 1
if cnt_sw_on % 2 != lst_p[i]:
judge = False
break
if judge:
ans += 1
print(ans)
| p03031 |
n, m = list(map(int, input().split()))
lst_sw = []
for _ in range(m):
lst_sw.append(list(map(int, input().split())))
lst_p = list(map(int, input().split()))
ans = 0
for bits in range(2 ** n):
judge = True
for i in range(m):
cnt_sw_on = 0
for j in range(1, len(lst_sw[i])):
sw = lst_sw[i][j]
if (bits >> (sw - 1)) & 1:
cnt_sw_on += 1
if cnt_sw_on % 2 != lst_p[i]:
judge = False
break
if judge:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
lst_sw = []
for _ in range(m):
lst_sw.append(list(map(int, input().split())))
lst_p = list(map(int, input().split()))
ans = 0
for bits in range(2 ** n):
judge = True
for i in range(m):
cnt_sw_on = 0
for j in range(1, len(lst_sw[i])):
sw = lst_sw[i][j]
if (1 << (sw - 1)) & bits:
cnt_sw_on += 1
if cnt_sw_on % 2 != lst_p[i]:
judge = False
break
if judge:
ans += 1
print(ans)
| p03031 |
n,m = list(map(int, input().split()))
S = [list(map(int, input().split())) for i in range(m)]
P = list(map(int, input().split()))
c = 0
a = 0
for a in range(2**n):
a2 = format(a, 'b').zfill(n)
d = 0
for i in range(m):
o = 0
for j in range(S[i][0]):
o += int(a2[S[i][j+1]-1])
if o % 2 == P[i]:
d += 1
if d == m:
c += 1
print(c) | N,M = list(map(int,input().split()))
B = [tuple(map(int,input().split())) for _ in range(M)]
P = tuple(map(int,input().split()))
ans = 0
for i in range(2**N):
flag = True
for k in range(M):
on = 0
for j in range(B[k][0]):
if i>>(B[k][j+1]-1) & 1:
on += 1
if on%2 != P[k]:
flag = False
if flag:
ans += 1
print(ans) | p03031 |
# ABC128C - Switches
from itertools import product
n, m = list(map(int, input().rstrip().split()))
lst = [list(map(int, input().rstrip().split())) for _ in range(m)]
con = list(map(int, input().rstrip().split()))
ans = 0
for i in product(list(range(2)), repeat=n):
cnt = 0
for j in range(m):
ons = 0
for k in lst[j][1:]:
if i[k - 1] == 1:
ons += 1
if ons % 2 == con[j]:
cnt += 1
if cnt == m:
ans += 1
print(ans) | # ABC128C - Switches
import sys
from itertools import product
input = sys.stdin.readline
n, m = list(map(int, input().rstrip().split()))
lst = [list(map(int, input().rstrip().split())) for _ in range(m)]
con = list(map(int, input().rstrip().split()))
ans = 0
for i in product(list(range(2)), repeat=n):
cnt = 0
for j in range(m):
ons = 0
for k in lst[j][1:]:
if i[k - 1] == 1:
ons += 1
if ons % 2 == con[j]:
cnt += 1
if cnt == m:
ans += 1
print(ans) | p03031 |
n,m=list(map(int,input().split()))
light=[]
ans=0
for i in range(m):
List=list(map(int,input().split()))
light.append(List)
p=list(map(int,input().split()))
for i in range(2**n):
l=[0]*n
for j in range(n):
if (i>>j&1):
l[j]=1
on=0
for k in range(m):
cnt=0
for o in range(1,len(light[k])):
if (l[light[k][o]-1]==1):
cnt+=1
if cnt%2==p[k]:
on+=1
if on==m:
ans+=1
print(ans) | n,m=list(map(int,input().split()))
light=[list(map(int,input().split())) for _ in range(m)]
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
state=[0]*n
for j in range(n):
if (i>>j&1):
state[j]=1
light_num=0
for k in range(m):
switch_num=0
for l in range(1,light[k][0]+1):
if state[light[k][l]-1]==1:
switch_num+=1
if switch_num%2==p[k]:
light_num+=1
if light_num==m:
ans+=1
print(ans) | p03031 |
def main():
import itertools
n,m=list(map(int,input().split()))
li=[list(map(int,input().split()))[1:] for _ in range(m)]
p=tuple(map(int,input().split()))
q=set(sum(li,[]))
r=set(range(1,n+1))
v=r-q
ans=0
for i in range(0,len(q)+1):
for s in itertools.combinations(q,i):
s=set(s)
for j,t in enumerate(li):
u=s&set(t)
if len(u)%2==p[j]:
continue
else:
break
else:
ans+=2**(len(v))
print(ans)
if __name__=="__main__":
main() | def main():
import itertools
n,m=list(map(int,input().split()))
li=[list(map(int,input().split()))[1:] for _ in range(m)]
p=tuple(map(int,input().split()))
q=set(sum(li,[]))
r=set(range(1,n+1))
v=r-q
ans=0
for i in range(0,len(q)+1):
for s in itertools.combinations(q,i):
s=set(s)
t=all(len(s&set(u))%2==w for u,w in zip(li,p))
if t==True:
ans+=2**(len(v))
print(ans)
if __name__=="__main__":
main() | p03031 |
f = lambda : list(map(int, input().split()))
n, m = f()
ll = [[0]*n for i in range(m)]
for i in range(m):
k, *t = f()
for j in range(k):
ll[i][t[j]-1] = 1
lp = list(f())
import itertools as it
lt = [p for p in it.product([0,1], repeat=n)]
ans = 0
for p in lt:
lj = []
for l in ll:
lj.append(sum(a*b for a, b in zip(p,l))%2)
if lp == lj:
ans += 1
print(ans) | f = lambda : list(map(int, input().split()))
n, m = f()
ll = [[0]*n for i in range(m)]
for i in range(m):
k, *t = f()
for j in range(k):
ll[i][t[j]-1] = 1
lp = list(f())
import itertools as it
ans = 0
for p in it.product([0,1], repeat=n):
if lp == [sum(a*b for a, b in zip(p,l))%2 for l in ll]:
ans += 1
print(ans) | p03031 |
f = lambda : list(map(int, input().split()))
n, m = f()
ll = [[0]*n for i in range(m)]
for i in range(m):
_, *t = f()
for j in t:
ll[i][j-1] = 1
lp = list(f())
import itertools as it
ans = 0
for p in it.product([0,1], repeat=n):
if lp == [sum(a*b for a, b in zip(p,l))%2 for l in ll]:
ans += 1
print(ans) | f=lambda:list(map(int,input().split()))
n,m=f()
ll=[[0]*n for _ in range(m)]
for l in ll:
k,*s=f()
for i in s: l[i-1]=1
p=list(f())
import itertools as it
print((sum(all(sum(a*b for a,b in zip(l,t))%2==p[i] for i,l in enumerate(ll)) for t in it.product([0,1],repeat=n)))) | p03031 |
N, M = list(map(int, input().split()))
int_switch_repr = 2**N
light_bulbs_switches = []
for i in range(M):
k_s = [int(x) for x in input().split()]
k_i = k_s[0]
light_bulbs_switches.append(k_s[1:]) # i-th light bulb
P = [int(x) for x in input().split()] # p_i
ans = 0
for itg in range(int_switch_repr):
binary_switch_repr = "{w:{fill}{width}b}".format(w=itg, fill='0', width=N)
all_on = True
for lbs_i, p_i in zip(light_bulbs_switches, P):
is_light_on = sum([1 for sw in lbs_i if binary_switch_repr[int(sw)-1]=='1'])%2 == p_i
if not is_light_on:
all_on = False
if all_on:
ans+=1
print(ans) | N, M = list(map(int, input().split()))
int_switch_repr = 2**N
light_bulbs_switches = []
for i in range(M):
k_s = [int(x) for x in input().split()]
k_i = k_s[0]
light_bulbs_switches.append(k_s[1:]) # i-th light bulb
P = [int(x) for x in input().split()] # p_i
ans = 0
for itg in range(int_switch_repr):
binary_switch_repr = "{w:{fill}{width}b}".format(w=itg, fill='0', width=N)
all_on = True
for lbs_i, p_i in zip(light_bulbs_switches, P):
is_light_on = sum([1 for sw in lbs_i if binary_switch_repr[int(sw)-1]=='1'])%2 == p_i
if not is_light_on:
all_on = False
break
if all_on:
ans+=1
print(ans) | p03031 |
n,m = list(map(int,input().split()))
S = [list(map(int,input().split()))[1:] for i in range(m)]
P = list(map(int,input().split()))
ans = 0
#bit全探索
for bit in range(1<<n):
on = []
ok = True #全部の電球が光る
for i in range(n):
if (bit & (1<<i)):
on.append(i+1)
for i in range(m):
p = P[i]
c = 0
for s in S[i]:
if s in on: c+=1
if c%2!=p: ok=False
if ok:ans+=1
print(ans) | n,m = list(map(int,input().split()))
d = []
for i in range(m):
d.append(list(map(int,input().split())))
p = list(map(int,input().split()))
ans = 0
def search(x):
global ans
cnt = 0
for i in range(m):
c = 0
for j in d[i][1:]:
if x[j-1]==1:
c += 1
if c%2==p[i]:
cnt += 1
if cnt==m:ans+=1
from itertools import product
o = product(list(range(2)),repeat=n)
for i in o:
search(i)
print(ans)
| p03031 |
n,m = list(map(int,input().split()))
s = [0] * m
ans = 0
for i in range(m):
s[i] = list(map(int,input().split()))
s[i] = s[i][1:]
p = list(map(int,input().split()))
for k in range(2**n):
a = format(k,'0'+str(n)+'b')
t = True
for i in range(m):
if sum(a[j-1] == '1' for j in s[i])%2 != p[i]:
t = False
break
ans += t
print(ans)
| n,m = list(map(int,input().split()))
s = [0] * m
k = [0] * m
for i in range(m):
s[i] = list(map(int,input().split()))
k[i] = s[0]
s[i] = s[i][1:]
p = list(map(int,input().split()))
ans = 0
b = '0' + str(n) + 'b'
for i in range(1 << n):
sw = format(i,b)
if all(sum(sw[g-1] == '1' for g in s[j])%2 == p[j] for j in range(m)):
ans += 1
print(ans)
| p03031 |
n, m = list(map(int, input().split()))
k = []
s = []
for i in range(m):
l = list(map(int, input().split()))
k.append(l[0])
s.append(l[1:])
p = list(map(int, input().split()))
ans = 0
for bit in range(2 ** n):
q = 1
for i in range(m):
sum = 0
for j in range(k[i]):
if (bit >> (s[i][j] - 1)) & 1:
sum += 1
if sum % 2 != p[i]:
q = 0
if q == 1:
ans += 1
print(ans)
| N, M = list(map(int, input().split()))
s = [list(map(int, input().split())) for i in range(M)]
p = list(map(int, input().split()))
ans = 0
for i in range(2 ** N): # all comb
for j in range(M): # k loop
c = 0
for k in range(N): # s loop
if ((i >> k) & 1) and (k + 1) in s[j][1:]:
c += 1
if c % 2 != p[j]:
break
elif j == M - 1:
ans += 1
print(ans)
| p03031 |
n,m=list(map(int,input().split()))
s=[]
k=[]
for i in range(m):
ss=list(map(int,input().split()))
k.append(ss[0])
s.append(ss[1:])
p=list(map(int,input().split()))
def cntbin(num):
bin_num = bin(num)[2:]
count = 0
for i in bin_num:
count += int(i)
return count
ans=0
for bit in range(2**n):
ok=True
for mm in range(m):
on=0
for i in s[mm]:
if bit & 2**(i-1)!=0:
on+=1
if on%2==p[mm]:
pass
else:
ok=False
if ok:ans+=1
print(ans) | n,m=list(map(int,input().split()))
k=[]
s=[]
def cntbin(num):
bin_num = bin(num)[2:]
count = 0
for i in bin_num:
count += int(i)
return count
for i in range(m):
kk,*ss=list(map(int,input().split()))
k.append(kk)
s.append(ss)
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
ok=True
for mm in range(m):
if not ok:break
mask=0
for ss in s[mm]:
mask+=1 << ss-1
on=cntbin(i&mask)
if p[mm]!=on%2:
ok=False
if ok:ans+=1
print(ans) | p03031 |
# https://atcoder.jp/contests/abc128/tasks/abc128_c
# なんかかすかに解いた記憶あるな？
# load data
N, M = list(map(int, input().split()))
S = []
for _ in range(M):
S.append(list(map(int, input().split()))[1:])
P = list(map(int, input().split()))
def is_on(i, S, p):
# bit表現 i のときSのスイッチの個数とpでonか返す
cnt = 0
for j in S:
if (i >> (j - 1)) % 2: # j番目のスイッチオン
cnt += 1
return cnt % 2 == p
ans = 0
# bit 全探索
for i in range(1 << N): # N桁のbit全探索
# 以下iの全パターンについて
flg = True
for s, p in zip(S, P):
flg *= is_on(i, s, p)
ans += flg
print(ans)
| # https://atcoder.jp/contests/abc128/tasks/abc128_c
# なんかかすかに解いた記憶あるな？
# load data
N, M = list(map(int, input().split()))
S = []
for _ in range(M):
S.append(list(map(int, input().split()))[1:])
P = list(map(int, input().split()))
def is_on(i, S, p):
# bit表現 i のときSのスイッチの個数とpでonか返す
cnt = 0
for j in S:
if (i >> (j - 1)) % 2: # j番目のスイッチオン
cnt += 1
return cnt % 2 == p
ans = 0
# bit 全探索
for i in range(1 << N): # N桁のbit全探索
# 以下iの全パターンについて
flg = True
for s, p in zip(S, P):
if not is_on(i, s, p):
flg = False
break
ans += flg
print(ans)
| p03031 |
N, M = list(map(int, input().split()))
K = []; S = []
for _ in range(M):
k, *s = list(map(int, input().split()))
K.append(k); S.append(s)
P = list(map(int,input().split()))
ans = 0
for i in range(2**N):
flag = 0
stat = str(bin(i)[2:])
stat = stat.rjust(N, "0")
for j in range(M):
p = 0
for l in S[j]:
p += int(stat[l-1])
if p % 2 != P[j]:
flag = 1
if flag == 0:
ans += 1
print(ans)
| N, M = list(map(int, input().split()))
lightList = []
for _ in range(M):
lightList.append(list(map(int, input().split())))
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
flag = True
for a in range(M):
cnt = 0
for b in lightList[a][1:]:
if not (i & (1<<b-1)):
cnt += 1
if cnt % 2 != P[a]:
flag = False
if flag:
ans += 1
print(ans)
| p03031 |
#N = int(input())
n, m = list(map(int, input().split()))
#hl = list(map(int, input().split()))
l = [list(map(int, input().split())) for i in range(m)]
pl = list(map(int, input().split()))
count=0
for i in range(2**n):
b = bin(i)
switch = [False for i in range(n)]
boollist=[]
for j in range(n):
if ((i >> j) & 1):
switch[j] = True
for j in range(m):
k = l[j][0]
sl = l[j][1:]
total=0
for sij in sl:
if switch[sij-1]:
total+=1
if total % 2 == pl[j]:
boollist.append(True)
else:
boollist.append(False)
if all(boollist):
count += 1
print(count)
| #m = int(input())
n, m = list(map(int, input().split()))
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]
switch = []
kl = []
for i in range(m):
temp = list(map(int, input().split()))
kl.append(temp[0])
switch.append(temp[1:])
pl = list(map(int, input().split()))
# print(switch)
pattern = [[0 for _ in range(n)] for _1 in range(2**n)]
for i in range(2**n):
for j in range(n):
if ((i >> j) & 1): # 二進数iの下から数えてj桁目が1か否か
pattern[i][j] = 1
ans = 0
for ptnum, spt in enumerate(pattern):
islit = True
for lightnum in range(m):
count = 0
for s in switch[lightnum]:
if spt[s-1] == 1:
count += 1
if count % 2 != pl[lightnum]:
islit = False
break
if islit:
ans += 1
print(ans)
| p03031 |
n, m = [int(i) for i in input().split()]
ks = [[int(i) for i in input().split()] for _ in range(m)]
p = [int(i) for i in input().split()]
cnt = 0
for i in range(2**n):
on = set(j + 1 for j in range(n) if i >> j & 1 == 1)
flag = True
for j in range(m):
_, *s = ks[j]
flag &= len(on & set(s)) % 2 == p[j]
cnt += flag
print(cnt)
| from itertools import product
n, m = list(map(int, input().split()))
l = [[int(i) for i in input().split()] for _ in range(m)]
p = [int(i) for i in input().split()]
c = 0
for sw in product((0, 1), repeat=n):
for i in range(m):
if sum(sw[si - 1] for si in l[i][1:]) % 2 != p[i]:
break
else:
c += 1
print(c)
| p03031 |
# 2019-11-13 21:06:16(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n, m = [int(x) for x in sys.stdin.readline().split()]
on_off_patterns = [''.join(pattern) for pattern in itertools.product('01', repeat=n)]
bulbs = [[int(x) for x in sys.stdin.readline()[1:].split()] for _ in range(m)]
p = [int(x) for x in sys.stdin.readline().split()]
combinations = 0
for i in range(2**n):
pattern = on_off_patterns[i]
for j in range(m):
switches = bulbs[j]
on_count = 0
for switch in switches:
if pattern[switch-1] == '1':
on_count += 1
if on_count % 2 == p[j]:
continue
else:
break
else:
combinations += 1
print(combinations)
# enumerate on/off-patters by using binary number.
if __name__ == "__main__":
main()
| import sys
n, m = list(map(int, sys.stdin.readline().split()))
s = [set(map(int, sys.stdin.readline().split()[1:])) for _ in range(m)]
*p, = list(map(int, sys.stdin.readline().split()))
def main():
combs = 0
for i in range(2 ** n):
t = set([j + 1 for j in range(n) if i >> j & 1])
for k in range(m):
if len(s[k] & t) & 1 != p[k]:
break
else:
combs += 1
return combs
if __name__ == '__main__':
ans = main()
print(ans) | p03031 |
N, M = list(map(int,input().split()))
state = []
for _ in range(M):
lst = list(map(int, input().split()))
state.append(lst[1:])#switch numbers each denkyu
p = list(map(int, input().split()))#numbers switches on %2 == pi
ans = 0
for i in range(2**N):
total = 0
for j in range(M):
cnt = 0
for s in state[j]:
s -= 1
if (i >> s) & 1:#全スイッチのパターン一つ一つについて、各電球の各スイッチがオンになっているか
cnt += 1
cnt %= 2
if cnt == p[j]:
total += 1
if total == M:
ans += 1
print(ans) | N, M = list(map(int,input().split()))
state = []
for _ in range(M):
lst = list(map(int, input().split()))
state.append(lst[1:])#switch numbers each denkyu
p = list(map(int, input().split()))#numbers switches on %2 == pi
ans = 0
for i in range(2**N):
total = 0
for j in range(M):
cnt = 0
for s in state[j]:
s -= 1
if (i >> s) & 1:#全スイッチのパターン一つ一つについて、各電球の各スイッチがオンになっているか
cnt += 1
cnt %= 2
if cnt == p[j]:
total += 1
else:
break
if total == M:
ans += 1
print(ans) | p03031 |
#入力
N, M = list(map(int, input().split()))
#入力: 電球iについての情報
lst = []
for i in range(M):
a = list(map(int, input().split()))
lst += [a]
#入力: どのような情報であればOKかのリスト
p = list(map(int, input().split()))
# print ('lst', lst)
#計算部分
ans = 0 #全探索用の答え
for i in range(2 ** N): #1をon, 0をoffとする2bit
#最大でもスイッチは10桁＋2進数であることを表す部分2桁
a = format(i, '012b')
#2進数をリストとして保存, 前2桁は2進数であることを表す部分のため不要
lst2 = list(a[2:]) #右からスイッチ1, 2, ... Nと逆順になっていることに注意
# print ('lst2', lst2)
#あるスイッチの付け方が題意を満たしているか判断するフラグ
flag = True
l = 0 #電球番号-1(リストのため)
for j in lst: #i番目のスイッチの繋がっていることの情報
# print ('j[1:]', j[1:])
count = 0 #ONのスイッチの個数を数える
for k in j[1:]: #s_i番目のスイッチの状態を読み出す、最初の一桁はスイッチの数
# print ('k', k)
if lst2[9-k+1] == '1': #ONの時、カウントを増やす
count += 1
# print ('B')
# print ('count', count)
# print ('p[l]', p[l])
if count%2 != p[l]: #ONになっているスイッチの数//2が題意を満たしているかを判断
flag = False #題意を満たしていなかったらフラグをFalseにする
# print ('C')
l += 1 #電球番号を一つ増やす
if flag: #全ての電球を確認して、フラグがまだTrueなら答えを+1
ans += 1
# print ('A')
print (ans) | N, M = list(map(int, input().split()))
lst = [list(map(int, input().split())) for i in range(M)]
p = list(map(int, input().split()))
count = 0
#bit全探索
for i in range(2**N): #スイッチの状態をbit-全探索
c = [0] * M
for j in range(N): #j桁目を確認
if (i >> j) & 1: #j桁目 = j個目のスイッチがONの時
for k in range(M): #M個の電球に対して確認
if j+1 in lst[k][1:]:
c[k] += 1
flag = True
for l in range(M):
if c[l]%2 != p[l]:
flag = False
if flag:
count += 1
print (count)
| p03031 |
N, M = list(map(int, input().split()))
bulbs = []
for m in range(M):
ks = list(map(int, input().split()))
bulbs.append(list(ks)[1:])
P = list(map(int, input().split()))
result = 0
for m in range(2**N):
switches = list(map(int, list(str(bin(m))[2:])))
switches = [0]*(N-len(switches)) + switches
flag = True
for idx, bulb in enumerate(bulbs):
count = 0
for switch in bulb:
count += switches[switch-1]
if count % 2 != P[idx]:
flag = False
break
if flag:
result += 1
print(result)
| N, M = list(map(int, input().split()))
bulbs = []
for m in range(M):
ks = list(map(int, input().split()))
bulbs.append(list(ks)[1:])
P = list(map(int, input().split()))
result = 0
for m in range(2**N):
flag = True
for idx, bulb in enumerate(bulbs):
count = 0
for switch in bulb:
count += (m >> (switch-1)) & 1
if count % 2 != P[idx]:
flag = False
break
if flag:
result += 1
print(result)
| p03031 |
from collections import deque
n, m = list(map(int, input().split()))
s = [0] * m
k = [0] * m
for i in range(m):
s[i] = deque(list(map(int, input().split())))
k[i] = deque.popleft(s[i])
s[i] = list(s[i])
p = list(map(int, input().split()))
cnt = 0
for i in range(2 ** n):
l = [0] * n
for j in range(n):
if (i >> j) & 1:
l[j] = 1
for k in range(m):
total = 0
ans = True
for num in s[k]:
idx = num - 1
if l[idx] == 1:
total += 1
if total % 2 != p[k]:
ans = False
break
if ans:
cnt += 1
print(cnt) | n, m = list(map(int, input().split()))
s = [0] * m
for i in range(m):
s[i] = list(map(int, input().split()))[1:]
p = list(map(int, input().split()))
ans = 0
for bit in range(2 << (n-1)):
l = [0] * n
for i in range(n):
if bit >> i & 1:
l[i] += 1
for i in range(m):
cnt = 0
flag = True
for j in s[i]:
if l[j-1] == 1:
cnt += 1
if cnt % 2 != p[i]:
flag = False
break
if flag:
ans += 1
print(ans)
| p03031 |
n,m = list(map(int,input().split()))
res = 0
Q = []
for i in range(m):
Q.append(list(map(int,input().split()))[1:])
P = list(map(int,input().split()))
for s in range(1<<n):
tmp = 0
for i in range(len(Q)):
cnt = 0
for t in Q[i]:
if s>>(t-1) &1 == 1:
cnt += 1
if cnt % 2 == P[i]:
tmp += 1
if tmp == m:
res += 1
print(res) | N,M = list(map(int,input().split()))
S = []
for _ in range(M):
S.append(list(map(int,input().split()))[1:])
P = list(map(int,input().split()))
res = 0
for i in range(2**N):
tmp = 0
for j in range(M):
ON = 0
for s in S[j]:
if (i >> s-1)&1 == 1:
ON += 1
if ON % 2 == P[j]:
tmp += 1
if tmp == M:
res += 1
print(res) | p03031 |
n, m = list(map(int, input().split(' ')))
k = [0] * m
s = [[]] * m
for i in range(m):
_input = [num for num in map(int, input().split(' '))]
k[i] = _input[0]
s[i] = _input[1:]
p = [num for num in map(int, input().split(' '))]
# print(n, m)
# print(k)
# print(s)
# print(p)
# スイッチのパターンデータ作成
s_pattern = [''] * (2**n)
str_format = '{:0' + str(n) + 'b}'
for i in range(2**n):
s_pattern[i] = str_format.format(i)
# print(s_pattern)
ans = 0
for i in range(2**n):
pattern = s_pattern[i]
for j in range(m):
need_switches = s[j]
on_count = 0
for switch in need_switches:
if pattern[switch-1] == '1':
on_count += 1
# print(on_count, p[j])
# 電球が点灯するか
if on_count % 2 == p[j]:
continue
else:
break
else:
# break で抜けていなければ場合はすべての電球が点灯する
ans += 1
print(ans) | n , m = list(map(int, input().split()))
sl = [[]] * m
for i in range(m):
s = [num for num in map(int, input().split())]
sl[i] = s
p = [num for num in map(int, input().split())]
# print(p, sl)
ans = 0
# すべてのスイッチの状態を bit全探索 (各bit 1: on, 0: off)
for i in range(1 << n):
# print('i: ', i)
# そのスイッチの状態で各電球が光るか
for j in range(m):
s = sl[j]
ons = 0
# 光ってる数を数える
for k in range(1, s[0]+1):
# bit桁 = スイッチ番号 - 1 なので、現在のスイッチの状態はこの電球の対象か
if i & (1 << (s[k]-1)):
ons += 1
# 1つでも光っていないと break
if ons % 2 != p[j]:
break
else:
# すべての処理でbreakしない == すべての電球が光っている
ans += 1
print(ans) | p03031 |
ks=[]
n,m=list(map(int,input().split()))
for i in range(m):
ks.append(list(map(int,input().split())))
p=list(map(int,input().split()))
ans_ans=0
for i in range(2**n):
num="0"*10+bin(i)
ans=0
for j in range(m):
cnt=0
for k in range(n):
if num[-k-1]=="1" and k+1 in ks[j][1:]:
cnt+=1
if cnt%2==p[j]:
ans+=1
if ans==m:
ans_ans+=1
print(ans_ans)
| n,m=list(map(int,input().split()))
ks=[]
for _ in range(m):
rr=list(map(int,input().split()))
ks.append(rr)
p=list(map(int,input().split()))
def two(x):
return "0"*(n-len(bin(x)[2:]))+bin(x)[2:]
ans=0
for i in range(2**n):
r=two(i)
f=1
for j in range(m):
cnt=0
for k in range(ks[j][0]):
if r[ks[j][k+1]-1]=="1":
cnt+=1
if cnt%2!=p[j]:
f=0
break
ans+=f
print(ans)
| p03031 |
from itertools import product
N, M = list(map(int, input().split()))
sss = []
for _ in range(M):
k, *ss = list(map(int, input().split()))
sss.append(ss)
ps = list(map(int, input().split()))
ans = 0
for ptn in product(list(range(2)), repeat=N):
numL = 0
for ss, p in zip(sss, ps):
numON = 0
for s in ss:
numON += ptn[s-1]
if numON%2 == p:
numL += 1
if numL == M:
ans += 1
print(ans)
| N, M = list(map(int, input().split()))
switchss = []
for _ in range(M):
k, *sws = list(map(int, input().split()))
switchss.append([sw-1 for sw in sws])
ps = list(map(int, input().split()))
ans = 0
for S in range(1<<N):
for i in range(M):
num = 0
for sw in switchss[i]:
if (S>>sw) & 1:
num += 1
if num%2 != ps[i]:
break
else:
ans += 1
print(ans)
| p03031 |
N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
blst = []
cnt = 0
for i in range(2 ** N):
slst = []
for j in range(N):
if i >> j & 1:
slst.append(j)
blst.append(slst)
for i in blst:
ansF = False
for j in range(M):
ctmp1 = 0
for k in i:
if ks[j][1:].count(k + 1) == 1:
ctmp1 += 1
if ctmp1 % 2 == p[j]:
ansF = True
else:
ansF = False
break
if ansF:
cnt += 1
print(cnt) |
def dfs(cnt):
global ans
if cnt == N:
onF = True
for i in range(M):
tmp = 0
for j in range(ks[i][0]):
if bit[ks[i][j + 1] - 1] == 1:
tmp += 1
if tmp % 2 != p[i]:
onF = False
break
if onF:
ans += 1
return
for i in range(2):
bit[cnt] = i
dfs(cnt + 1)
N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
bit = [0] * N
ans = 0
dfs(0)
print(ans) | p03031 |
n, m = list(map(int,input().split()))
k = []
s = []
for i in range(m):
temp = list(map(int, input().split()))
temp_k = temp[0]
temp_s = temp[1:]
k.append(temp_k)
s.append(temp_s)
p = list(map(int, input().split()))
ans = 0
for i in range(2**n):
on = bin(i)[2:].rjust(n,"0")
cond = 0
for j in range(m):
cnt = sum(list(map(int,[on[k] for k in range(n) if k+1 in s[j]])))
if cnt % 2 == p[j]:
cond += 1
if cond == m:
ans += 1
print(ans) |
N, M = list(map(int, input().split()))
K = []
S = []
for _ in range(M):
tmp = list(map(int ,input().split()))
K.append(tmp[0])
tmp.pop(0)
S.append(tmp)
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
flg = [0 for _ in range(M)]
for j in range(N):
if i & (1 << j):
for k in range(M):
if j+1 in S[k]:
flg[k] += 1
cond = 1
for l in range(M):
if P[l] != (flg[l] % 2):
cond = 0
break
if cond:
ans += 1
print(ans) | p03031 |
N, M = list(map(int, input().split()))
kss = []
for i in range(M):
tmp = list(map(int, input().split()))
k = tmp[0]
s = tmp[1:]
kss.append([k, s])
ps = list(map(int, input().split()))
def check_on(s_all, s, p):
oncnt = 0
for i in s:
if s_all[i]:
oncnt += 1
if oncnt % 2 == p:
return True
else:
return False
def check_all_on(s_all, kss, ps):
for i in range(M):
s = kss[i][1]
p = ps[i]
if not check_on(s_all, s, p):
return False
return True
def rec(s_all, kss, ps, cnt):
if len(s_all) == N+1:
if check_all_on(s_all, kss, ps):
cnt[0] += 1
return
else:
s_all.append(0)
rec(s_all, kss, ps, cnt)
s_all.pop()
s_all.append(1)
rec(s_all, kss, ps, cnt)
s_all.pop()
s_all = [0]
cnt = [0]
rec(s_all, kss, ps, cnt)
print((cnt[0]))
| N, M = list(map(int, input().split()))
onptns = []
for i in range(M):
k, *s= list(map(int, input().split()))
onptn = 0
for i in s:
onptn += 1 << (i - 1)
onptns.append(onptn)
ps = list(map(int, input().split()))
ans = 0
s = 0
while s < (1 << N):
ans += 1
for onptn, p in zip(onptns, ps):
if bin(s & onptn).count('1') % 2 != p:
ans -= 1
break
s += 1
print(ans)
| p03031 |
N, M = list(map(int,input().split()))
K = []
S = []
for i in range(M):
k = 0
s = []
k, *s = list(map(int,input().split()))
K.append(k)
S.append(s)
P = list(map(int,input().split()))
res = 0
for bit in range(1 << N):
judge = True
for i in range(M):
cnt = 0
for s in S[i]:
cnt += (bit >> s-1) & 1
if cnt % 2 != P[i]:
judge = False
if judge:
res += 1
print(res) | N, M = list(map(int,input().split()))
K = []
S = []
for i in range(M):
k = 0
s = []
k, *s = list(map(int,input().split()))
K.append(k)
S.append(s)
P = list(map(int,input().split()))
res = 0
for bit in range(1 << N):
judge = True
for i in range(M):
cnt = 0
for s in S[i]:
cnt += (bit >> s-1) & 1
if cnt % 2 != P[i]:
judge = False
break
if judge:
res += 1
print(res) | p03031 |
n, m = list(map(int, input().split()))
s = []
k = []
for i in range(m):
s.append(list(map(int, input().split())))
k.append(s[i].pop(0))
p = list(map(int, input().split()))
# 全点灯パターンの個数
ans = 0
# 点灯している電球の数
cnt_s_on = 0
# 電球jに繋がるONのスイッチの数
cnt_switch = 0
for i in range(2**n):
# print(bin(i))
# print(bin(i>>1))
# print("----")
# print("i: "+str(bin(i)))
tmpS=[0]*m
cnt_s_on = 0
# すべての電球に対して調べる
for j in range(m):
cnt_switch = 0
# 電球jに繋がるすべてのスイッチに対してON/OFFを調べる
for K in range(k[j]):
if ((i >> (s[j][K]-1)) & 1):
# スイッチがONならONカウントに＋する
cnt_switch += 1
# print("cnt_switch: " + str(cnt_switch))
# print("cnt_switch%2: " + str(cnt_switch%2))
# print("p[j]: " + str(p[j]))
if cnt_switch%2 == p[j]:
# 電球jは点灯している
cnt_s_on += 1
tmpS[j] = 1
# print("電球状況："+str(tmpS))
# print("cnt_s_on: " + str(cnt_s_on))
if cnt_s_on == m:
ans += 1
# print("----------")
print(ans)
| n, m = list(map(int, input().split()))
s = []
k = []
for i in range(m):
s.append(list(map(int, input().split())))
k.append(s[i].pop(0))
p = list(map(int, input().split()))
# 全点灯パターンの個数
ans = 0
# 点灯している電球の数
cnt_s_on = 0
# 電球jに繋がるONのスイッチの数
cnt_switch = 0
for i in range(2**n):
cnt_s_on = 0
# すべての電球に対して調べる
for j in range(m):
cnt_switch = 0
# 電球jに繋がるすべてのスイッチに対してON/OFFを調べる
for K in range(k[j]):
if ((i >> (s[j][K]-1)) & 1):
# スイッチがONならONカウントに＋する
cnt_switch += 1
if cnt_switch%2 == p[j]:
# 電球jは点灯している
cnt_s_on += 1
if cnt_s_on == m:
ans += 1
print(ans)
| p03031 |
n,m=list(map(int,input().split()))
sw=[list(map(int,input().split())) for _ in range(m)]
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
f=1
for j in range(m):
c=0
for x in sw[j][1:]:
x-=1
c+=(i>>x)&1
if c%2!=p[j]:
f=0
ans+=1 if f else 0
print(ans)
| n,m=list(map(int,input().split()))
s=[list(map(int,input().split())) for _ in range(m)]
p=list(map(int,input().split()))
ans=0
for i in range(2**n):
ss=[0]*n
cc=0
for j in range(n):
if i>>j&1:
ss[j]=1
for j in range(m):
c=0
k=s[j][0]
for l in range(1,k+1):
c+=ss[s[j][l]-1]
if c%2==p[j]:
cc+=1
if cc==m:
ans+=1
print(ans)
| p03031 |
N, M = list(map(int, input().split()))
S = [list(map(int, input().split()))[1:] for _ in range(M)]
P = list(map(int, input().split()))
count = 0
for i in range(2 ** N):
state = ''.join(list(reversed(str(bin(i))[2:].zfill(N))))
flg = True
for m in range(M):
on = 0
for s in S[m]:
if state[s - 1] == '1':
on += 1
if on % 2 != P[m]:
flg = False
break
if flg:
count += 1
print(count)
| # コンテスト中は無理やりなビット全探索[alias bit全探索]をしたが、正しく書き換えた
N, M = list(map(int, input().split()))
S = [list(map(int, input().split()))[1:] for _ in range(M)]
P = list(map(int, input().split()))
count = 0
for i in range(2 ** N):
flg = True
for m in range(M):
on = 0
for s in S[m]:
if (i >> s - 1) & 1:
on += 1
if on % 2 != P[m]:
flg = False
break
if flg:
count += 1
print(count)
| p03031 |
#!/usr/bin/env python3
MOD = 2 # type: int
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
# Failed to predict input format
N,M = list(map(int,input().split()))
from collections import defaultdict
d = defaultdict()
for i in range(M):
l = list(map(int,input().split()))
d[i] = l[1:]
# for k,v in d.items():
# print(k,v)
p = list(map(int,input().split()))
ans = 0
import itertools
s = ('on', 'off')
for i in itertools.product(s, repeat=N):
anst = 0
for k,v in list(d.items()):
if(len([x for x in v if(i[x-1] == 'on')])%2 == p[k]):
anst += 1
if(anst == M):
ans += 1
print(ans)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
MOD = 2 # type: int
def main():
N, M = list(map(int, input().split()))
k = []
s = []
for i in range(M):
l = input().split()
k.append(l[0])
s.append(list(map(int, l[1:])))
p = list(map(int, input().split()))
ans = 0
for i in range(1<<N):
t = [0] * M
for j in range(N):
if i>>j & 1:
for r in range(M):
# print(j+1, s[r])
if j+1 in s[r]:
t[r] += 1
f = True
for j in range(M):
if t[j]%2 != p[j]:
f = False
if f:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03031 |
n, m = list(map(int, input().split()))
denq = []
for _ in range(m):
ks = tuple([int(x)-1 for x in input().split()])
denq.append(set(ks[1:]))
P = tuple(map(int, input().split()))
ans = 0
for i in range(2**n):
kk = [0] * m
for j in range(n):
# スイッチjがonの場合
if (i>>j)&1:
for idq, dq in enumerate(denq):
# すべての電球に対して
# スイッチjが電球に紐付けられていれば、onをカウント
if j in dq:
kk[idq] += 1
for idq in range(m):
if P[idq] != kk[idq]%2:
break
else:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
denq = []
for _ in range(m):
ks = tuple([int(x)-1 for x in input().split()])
denq.append(ks[1:])
P = tuple(map(int, input().split()))
ans = 0
for i in range(2**n):
kk = [0] * m
switch_states = [(i>>j)&1 for j in range(n)]
for idq, dq in enumerate(denq):
counts = 0
for s in dq:
counts += switch_states[s]
if counts%2 != P[idq]:
break
else:
ans += 1
print(ans)
| p03031 |
n, m = list(map(int, input().split()))
denq = []
for _ in range(m):
ks = tuple([int(x)-1 for x in input().split()])
denq.append(ks[1:])
P = tuple(map(int, input().split()))
ans = 0
for i in range(2**n):
kk = [0] * m
switch_states = [(i>>j)&1 for j in range(n)]
for idq, dq in enumerate(denq):
counts = 0
for s in dq:
counts += switch_states[s]
if counts%2 != P[idq]:
break
else:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
denq = []
for _ in range(m):
ks = tuple([int(x)-1 for x in input().split()])
denq.append(ks[1:])
P = tuple(map(int, input().split()))
ans = 0
for i in range(2**n):
kk = [0] * m
# switch_states = [(i>>j)&1 for j in range(n)]
for idq, dq in enumerate(denq):
counts = 0
for s in dq:
counts += (i>>s)&1
if counts%2 != P[idq]:
break
else:
ans += 1
print(ans)
| p03031 |
n, m = list(map(int, input().split()))
denq = []
for _ in range(m):
ks = tuple([int(x)-1 for x in input().split()])
denq.append(ks[1:])
P = tuple(map(int, input().split()))
ans = 0
for i in range(2**n):
# switch_states = [(i>>j)&1 for j in range(n)]
for idq, dq in enumerate(denq):
counts = 0
for s in dq:
counts += (i>>s)&1
if counts%2 != P[idq]:
break
else:
ans += 1
print(ans) | n, m = list(map(int, input().split()))
denq = []
for _ in range(m):
ks = tuple([int(x)-1 for x in input().split()])
denq.append(ks[1:])
P = tuple(map(int, input().split()))
ans = 0
for i in range(2**n):
switch_states = [(i>>j)&1 for j in range(n)]
for idq, dq in enumerate(denq):
counts = 0
for s in dq:
counts += switch_states[s]
if counts%2 != P[idq]:
break
else:
ans += 1
print(ans)
| p03031 |
from itertools import product
n,m = list(map(int,(input().split())))
sw =[list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for bit in product([0, 1], repeat=n):
ele = True
for i in range(m):
cnt = 0
for j in sw[i][1:]:
cnt += bit[j-1]
if cnt % 2 != p[i]:
ele = False
break
if ele:
ans += 1
print(ans) | from itertools import product
n,m = list(map(int,(input().split())))
sw =[list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
ans = 0
for bit in product([0, 1], repeat=n):
ele = True #全部点灯ならtrue
for i in range(m): #電球1～mに対するループ
cnt = 0
for j in sw[i][1:]: #switch1～nに対するループ
#print(j)
cnt += bit[j-1]
if cnt % 2 != p[i]:
ele = False
break
if ele:
ans += 1
print(ans) | p03031 |
N, M = list(map(int, input().split()))
lights = []
for _ in range(M):
S = list(map(int, input().split()))
mask = 0
for a in S[1:]:
mask |= (1 << (a - 1))
lights.append(mask)
P = list(map(int, input().split()))
ans = 0
for mask in range(1 << N):
for state, p in zip(lights, P):
cnt = 0
for d in range(N):
if ((1 << d) & state) > 0 and ((1 << d) & mask) > 0:
cnt += 1
if cnt % 2 != p:
break
else:
ans += 1
print(ans)
| N, M = list(map(int, input().split()))
S = []
for _ in range(M):
s = tuple([int(a) - 1 for a in input().split()])[1:]
S.append(s)
P = tuple(map(int, input().split()))
ans = 0
for state in range(1 << N):
for p, s in zip(P, S):
cnt = 0
for i in s:
cnt += 1 if (state & (1 << i)) > 0 else 0
if cnt % 2 != p:
break
else:
ans += 1
print(ans)
| p03031 |
#ABC 128C
def main():
import sys
import itertools as ite
N, M = list(map(int, sys.stdin.readline().split()))
Light = [tuple(map(int, sys.stdin.readline().split())) for _ in range(M)]
P = list(map(int, sys.stdin.readline().split()))
S = list(ite.product([0,1], repeat=N)) #スイッチの状態
ans = 0
for s_state in S:
L_result = [0 for _ in range(M)]
for m in range(M):
for s_no in Light[m][1:]:
L_result[m] += s_state[s_no-1]
L_result = list([x%2 for x in L_result])
if P == L_result:
ans +=1
print(ans)
if __name__=='__main__':
main()
| #ABC128C
def main():
import sys, itertools as ite
N, M = list(map(int, sys.stdin.readline().split()))
KS = [tuple(map(int, sys.stdin.readline().split())) for _ in range(M)]
P = tuple(map(int, sys.stdin.readline().split()))
#print(KS)
#bit全探索
SWS = tuple(ite.product([0,1], repeat=N))
def judge(on_off):
for i in range(M):
on_cnt = 0
for s in KS[i][1:]:
on_cnt += on_off[s-1]
if on_cnt %2 !=P[i]:
return 0
else:
return 1
ans = 0
for on_off in SWS:
ans +=judge(on_off)
print(ans)
if __name__=='__main__':
main()
| p03031 |
# C - Switches
#bit全探索の練習問題
import copy
N,M = input().split()
N = int(N)
M = int(M)
ks = []
for l in range(M):
s = input().split()
ks.append(s)
p = list(map(int, input().split()))
KS = []
for m in range(M):#列の数はМ
box = list()
for n in range(len(ks[m])):#M列の要素を数字に直す処理
ks[m][n] = int(ks[m][n])
box.append(ks[m][n])
KS.append(box)
swich = []
for o in range(M):#列の数はМ
swi = list()
for r in range(1,len(KS[o])):#k以外を取り出す
swi.append(ks[o][r])
swich.append(swi)
ans = 0
for i in range(1<<N):#全パターンは2**(スイッチの総数)
SWICH = copy.deepcopy(swich)
light_on = 0
for j in range(N):
mask = 1<< j#1をj個左にずらした2進数
if i & mask != 0:#スイッチjがonの時
continue
else:#スイッチjがoffの時
for y in range(M):#電球iごとに繰り返し
if (j+1 in SWICH[y]) == True:#スイッチsiが電球iに接続されているとき
SWICH[y].remove(j+1)
#onのみがSWICHに入っている
flat_SWICH = []
for a in range(len(SWICH)):
for b in range(len(SWICH[a])):
flat_SWICH.append(SWICH[a][b])
for x in range(M):
if (len(SWICH[x]) % 2) == p[x]:#onのスイッチの数を2で割った余りがPの値と等しい時
light_on += 1
if light_on == M:#onの電球の個数がMと等しい(全てon)時
ans += 1
print(ans) | # 93 C - Switches
N,M = list(map(int,input().split()))
K = []
S = []
for _ in range(M):
s = list(map(int,input().split()))
K.append(s[0])
# 0-indexed
s = [i-1 for i in s]
S.append(s[1:])
P = list(map(int,input().split()))
ans = 0
for i in range(1<<N):
swiches = [0]*N
for j in range(N):
mask = 1<<j
# j 番目のスイッチが on のとき
if i & mask != 0:
swiches[j] = 1
# j 番目のスイッチが off のとき
else:
continue
# on の電球をカウント
cnt_light = 0
for m in range(M):
cnt_swich = 0
for s in S[m]:
if swiches[s] == 1:
cnt_swich += 1
if cnt_swich%2 == P[m]:
cnt_light += 1
if cnt_light == M:
ans += 1
print(ans) | p03031 |
# -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
# 標準入力を取得
N, M = list(map(int, input().split()))
k, s = [], []
for m in range(M):
l = list(map(int, input().split()))
k_m, s_m = l[0], l[1:]
k.append(k_m)
s.append(s_m)
p = list(map(int, input().split()))
return N, M, k, s, p
def lights_on(M: int, s: list, p: list, switches: int) -> bool:
"""
電球がすべて点灯しているかどうかを確認する.
Args:\n
M (int): 電球の数
s (list): 電球に対応するスイッチ
p (list): スイッチと電球の点灯の関係
switches (int): スイッチの状態
Returns:\n
bool: 電球がすべて点灯していれば真、そうでなければ偽
"""
result = True
for m in range(M):
switch_on_count = 0
for s_m_km in s[m]:
if switches & (1 << (s_m_km - 1)):
switch_on_count += 1
if switch_on_count % 2 != p[m]:
result = False
return result
def main(N: int, M: int, s: list, p: list) -> None:
"""
メイン処理.
Args:\n
N (int): スイッチの数
M (int): 電球の数
s (list): 電球に対応するスイッチ
p (list): スイッチと電球の点灯の関係
"""
# 求解処理
ans = 0
for switches in range(1 << N):
if lights_on(M, s, p, switches):
ans += 1
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, M, k, s, p = get_input()
# メイン処理
main(N, M, s, p)
| # -*- coding: utf-8 -*-
# 標準入力を取得
N, M = list(map(int, input().split()))
k, s = [], []
for m in range(M):
l = list(map(int, input().split()))
k.append(l[0])
s.append(l[1:])
p = list(map(int, input().split()))
# 求解処理
ans = 0
for bit in range(1 << N):
is_light_on = True
for m in range(M):
on_count = 0
for s_i in s[m]:
if ((bit >> (s_i - 1)) & 1):
on_count += 1
if on_count % 2 != p[m]:
is_light_on = False
break
if is_light_on:
ans += 1
# 結果出力
print(ans)
| p03031 |
import sys
input = sys.stdin.readline
v = []
p = []
count = 0
m = 0
def rec(l, n):
global count
if len(l) == n:
c = 0
for k, sw in enumerate(v):
st = set()
for i in range(n):
if l[i] == 1:
st.add(i + 1)
# print(st)
if len(sw.intersection(st)) % 2 == p[k]:
c += 1
# print("c: {}".format(c))
if c == m:
count += 1
# print(l)
return
l.append(0)
rec(list(l), n)
l.pop()
l.append(1)
rec(list(l), n)
def main():
global v
global p
global m
n, m = list(map(int, input().strip().split()))
for i in range(m):
tmp = list(map(int, input().strip().split()))
v.append(set(tmp[1:]))
p = list(map(int, input().strip().split()))
rec([], n)
print(count)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
v = []
p = []
count = 0
m = 0
def rec(l, n):
global count
if len(l) == n:
c = 0
for k, sw in enumerate(v):
st = set()
for i in range(n):
if l[i] == 1:
st.add(i + 1)
# print(st)
if len(sw.intersection(st)) % 2 != p[k]:
return
# print("c: {}".format(c))
count += 1
# print(l)
return
l.append(0)
rec(list(l), n)
l.pop()
l.append(1)
rec(list(l), n)
def main():
global v
global p
global m
n, m = list(map(int, input().strip().split()))
for i in range(m):
tmp = list(map(int, input().strip().split()))
v.append(set(tmp[1:]))
p = list(map(int, input().strip().split()))
rec([], n)
print(count)
if __name__ == '__main__':
main()
| p03031 |
import sys
input = sys.stdin.readline
v = []
p = []
count = 0
m = 0
def rec(l, n):
global count
if len(l) == n:
c = 0
st = set()
for i in range(n):
if l[i] == 1:
st.add(i + 1)
for k, sw in enumerate(v):
# print(st)
if len(sw.intersection(st)) % 2 != p[k]:
return
# print("c: {}".format(c))
count += 1
# print(l)
return
l.append(0)
rec(list(l), n)
l.pop()
l.append(1)
rec(list(l), n)
def main():
global v
global p
global m
n, m = list(map(int, input().strip().split()))
for i in range(m):
tmp = list(map(int, input().strip().split()))
v.append(set(tmp[1:]))
p = list(map(int, input().strip().split()))
rec([], n)
print(count)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
n, m = list(map(int, input().strip().split()))
A = [0] * n
for i in range(m):
sw = list(map(int, input().strip().split()))[1:]
for e in sw:
e -= 1
A[e] |= 1 << i
pl = list(map(int, input().strip().split()))
p = 0
for i, e in enumerate(pl):
p |= e << i
# p = p << i
j = 0
ans = 0
while j < (1 << n):
t = 0
for i in range(n):
if j >> i & 1:
t ^= A[i]
if t == p:
ans += 1
j += 1
print(ans)
if __name__ == '__main__':
main()
| p03031 |
N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
ans = 0
B = 1 << N
for i in range(B):
L = [0] * M
for j in range(M):
for k in ks[j][1:]:
if i >> (k - 1) & 1:
L[j] = (L[j] + 1) % 2
for j in range(M):
if L[j] != p[j]:
break
else:
ans += 1
print(ans) | N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
ans = 0
for i in range(1 << N):
for j in range(M):
t = 0
for k in range(1, ks[j][0] + 1):
if i >> (ks[j][k] - 1) & 1:
t += 1
if t % 2 != p[j]:
break
else:
ans += 1
print(ans)
| p03031 |
N,M = list(map(int,input().split()))
ls = []
for i in range(M):
s = list(map(int,input().split()))
ls.append(s[1:])
p = list(map(int,input().split()))
#greedy O(2^N)(MN) : (all set of switch N) = 2^10 * M 10 10^4 OK
ans = 0
for i in range(2**N): # all set of N 2**N == 1 << N (shif operator N right shift)
for j in range(M): # i_th lump consider
cnt = 0
for k in ls[j]:
if i&(1<<(k-1)): # if switch k is ON, then return non-zero(True)
cnt += 1
if cnt%2 != p[j]:
break
else:
ans +=1
print(ans)
| n,m = list(map(int,input().split()))
light = []
for i in range(m):
light.append(list(map(int,input().split())))
p = list(map(int,input().split()))
# bit全探索 nで スイッチのパターンを全てためす
#
ans = 0
for i in range(2**n):
ng = 0
for j in range(m):
ans_j = 0
for k in range(n):
if i >> k & 1 and k+1 in light[j][1:]:#電球on かつk[i]の電球がついているなら+=1
#print(light[j][1:],k)
ans_j += 1
#print(ans_j,i,p[j],ng)
if ans_j % 2 != p[j]:
ng = 1
if ng == 0:
ans += 1
print(ans)
| p03031 |
N,M = list(map(int,input().split(" ")))
switch = []
for i in range(M):
tmp = list(map(int,input().split(" ")))
switch.append(tmp)
p = list(map(int,input().split(" ")))
light = [0 for i in range(N)]
def search(N,M,switch,p,l,light):
if l<N:
l += 1
a=search(N,M,switch,p,l,light)
light[l-1]+=1
b = search(N,M,switch,p,l,light)
return a+b
else:
flag = 0
for i in range(M):
a = 0
for j in range(switch[i][0]):
a +=light[switch[i][j+1]-1]
if a%2 == p[i]:
continue
else:
flag = 1
break
if flag == 0:
return 1
else:
return 0
ans = search(N,M,switch,p,0,light)
print(ans) | N,M = list(map(int,input().split(" ")))
light = []
for i in range(M):
tmp = list(map(int,input().split(" ")))
light.append(tmp)
p = list(map(int,input().split(" ")))
switch = [0 for i in range(N)]
def search(N,M,light,p,l,switch):
if l<N:
l += 1
a=search(N,M,light,p,l,switch)
switch[l-1]+=1
b = search(N,M,light,p,l,switch)
return a+b
else:
flag = 0
for i in range(M):
a = 0
for j in range(light[i][0]):
a +=switch[light[i][j+1]-1]
if a%2 == p[i]:
continue
else:
flag = 1
break
if flag == 0:
return 1
else:
return 0
ans = search(N,M,light,p,0,switch)
print(ans) | p03031 |
#
# abc128 c
#
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """2 2
2 1 2
1 2
0 1"""
output = """1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2 3
2 1 2
1 1
1 2
0 0 1"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """5 2
3 1 2 5
2 2 3
1 0"""
output = """8"""
self.assertIO(input, output)
def resolve():
N, M = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(M)]
P = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
m = 0
for i in range(M):
t = 0
for j in range(1, S[i][0]+1):
if bit & (1 << (S[i][j]-1)) != 0:
t += 1
if t % 2 != P[i]:
break
else:
m += 1
if m == M:
ans += 1
print(ans)
if __name__ == "__main__":
# unittest.main()
resolve()
| #
# abc128 c
#
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """2 2
2 1 2
1 2
0 1"""
output = """1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2 3
2 1 2
1 1
1 2
0 0 1"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """5 2
3 1 2 5
2 2 3
1 0"""
output = """8"""
self.assertIO(input, output)
def resolve():
N, M = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(M)]
P = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
m = 0
for i in range(M):
t = 0
for j in range(1, S[i][0]+1):
if bit & (1 << (S[i][j]-1)):
t += 1
if t % 2 != P[i]:
break
else:
m += 1
if m == M:
ans += 1
print(ans)
if __name__ == "__main__":
# unittest.main()
resolve()
| p03031 |
# pythonで青くなるブログ
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, M = list(map(int, input().split()))
lamps = [list([int(x)-1 for x in input().split()])[1:]
#1個目は繋がっているスイッチの個数
#2個目以降が繋がっているスイッチの番号
for _ in range(M)]
p = list(map(int, input().split()))
# on になっているスイッチの個数を2で割った余りがpiに等しい時に点灯
ans = 0
# bit全探索(スイッチの入れ方を全探索する)
for i in range(1 << N):
for r in range(M): # 全てのランプがついてるかチェック
on_sum = 0 # ランプrにおいて、onのスイッチの数
for j in range(N): # スイッチのj番目について
if i >> j & 1 and j in lamps[r]:
on_sum += 1
# スイッチjがランプrに繋がってて、onならon_sum+=1
if on_sum % 2 != p[r]: # on_off check
break # 一つでもoffなら次のbitに
else:
ans += 1
print(ans) | # pythonで青くなるブログ
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, M = list(map(int, input().split()))
lamps = [list([int(x)-1 for x in input().split()])[1:]
#1個目は繋がっているスイッチの個数
#2個目以降が繋がっているスイッチの番号、0始まりに
for _ in range(M)]
p = list(map(int, input().split()))
# on になっているスイッチの個数を2で割った余りがpiに等しい時に点灯
ans = 0
# bit全探索(スイッチの入れ方を全探索する)
for i in range(1 << N):#2^N分、Bit検索
for r in range(M): # 全てのランプがついてるかチェック
on_sum = 0 # ランプrにおいて、onのスイッチの数。電球はM個。
for j in range(N): # スイッチのj番目について
if i >> j & 1 and j in lamps[r]:
#j番目のフラグが立って、電球rのj番目のスイッチが入っていれば
on_sum += 1
# スイッチjがランプrに繋がってて、onならon_sum+=1
if on_sum % 2 != p[r]: # on_off check
break # 一つでもoffなら次のbitに
else:
ans += 1
print(ans) | p03031 |
"""
n,m<=10
"""
n,m = list(map(int, input().split( )))
s = []
for i in range(m):
sij = list(map(int, input().split( )))
s.append(sij[1:])
p = list(map(int, input().split( )))
ans = 0
for i in range(2**n):
flag = True
for k in range(m):
tst = 0
for sm in s[k]:
tst ^= i>>(sm-1)&1
if tst^p[k]:###
flag = False
break
if flag:
ans += 1
print(ans) | n,m = list(map(int, input().split( )))
sw = [0 for _ in range(m)]#でんきゅがつながってるスイッチ
for i in range(m):
s = list(map(int, input().split( )))
s = [si-1 for si in s[1:]]
bt = 0
for sj in s:#電球
bt += 1<<sj
sw[i] = bt
p = list(map(int, input().split( )))
#スイッチ
bit = 1<<n
ans = 0
for i in range(bit):#スイッチつけ方
flag = True
for j in range(m):#電球
cnt = 0
for k in range(n):#スイッチチェック
cnt += (i&sw[j])>>k
if cnt%2!=p[j]:
flag = False
if flag:
ans += 1
print(ans)
| p03031 |
import itertools
N, M = list(map(int, input().split()))
target_switches = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
answer_count = 0
for switches in itertools.product((0, 1), repeat=N):
on_count = 0
for j in range(M):
count = 0
for i in range(N):
if (switches[i] == 1) and (i + 1 in target_switches[j][1:]):
count += 1
if count % 2 == p[j]:
on_count += 1
if on_count == M:
answer_count += 1
print(answer_count) | N, M = list(map(int, input().split())) # Nはスイッチの数、Mは電球の数
lights = [[0] * N for _ in range(M)]
for i in range(M):
temp = list(map(int, input().split())) # 0番目はスイッチの個数、1番目以降はスイッチを示す
k = temp[0]
switches = temp[1:]
for j in range(k):
lights[i][switches[j]-1] = 1
P = list(map(int, input().split())) # 個数を2で割ったあまりが要素と等しい場合に点灯する
answer_count = 0
for i in range(2**N):
flag = True
for k in range(M):
count = 0
for j in range(N):
if (i >> j) & 1:
count += lights[k][j]
if count % 2 != P[k]:
flag = False
break
if flag:
answer_count += 1
print(answer_count) | p03031 |
N, M = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
ans = 0
temp = [0]*N
for i in range(2**N):
for j in range(N):
if((i >> j) & 1):
temp[j] = 1
for k in range(M):
count = 0
for l in range(1, len(S[k])):
if temp[S[k][l] - 1] == 1:
count += 1
if count % 2 != p[k]:
break
else:
ans += 1
temp = [0]*N
print(ans)
| import itertools
N, M = list(map(int, input().split()))
data = [list(map(int, input().split())) for _ in range(M)]
P = list(map(int, input().split()))
# スイッチが付いているか付いていないかを表す集合
ans = 0
for bit in itertools.product([0, 1], repeat=N):
for d, p in zip(data, P):
cnt = 0
for i in d[1:]:
if bit[i - 1] == 1:
cnt += 1
if cnt % 2 != p:
break
else:
ans += 1
print(ans) | p03031 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n, m = na()
ks = nan(m)
p = na()
ans = 0
for i in range(2 ** n):
on = dict()
for j in range(n):
if (i >> j) & 1:
on[j + 1] = True
l = 0
for j in range(m):
k, s = ks[j][0], ks[j][1:]
sum_on = 0
for a in range(k):
if on.get(s[a], False):
sum_on += 1
if sum_on % 2 == p[j]:
l += 1
if l == m:
ans += 1
print(ans) | import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n, m = na()
ks = nan(m)
p = na()
ans = 0
for i in range(2 ** n):
ok = True
for j in range(m):
k, s = ks[j][0], ks[j][1:]
sum_on = 0
for a in range(k):
if (i >> (s[a] - 1)) & 1:
sum_on += 1
if sum_on % 2 != p[j]:
ok = False
if ok:
ans += 1
print(ans) | p03031 |
n,m=list(map(int,input().split()))
l=[list(map(int,input().split()))[1:] for i in range(m)]
p=list(map(int,input().split()))
form = "0" + str(n) + "b"
ans=0
for i in range(2**n):
ptr = format(i,form)
flg = True
for j in range(m):
s= sum(int(ptr[k-1]) for k in l[j])
if s%2 != p[j]:
flg = False
if flg == True:
ans+=1
print(ans) | n,m=list(map(int,input().split()))
k=[0]*m
s=[set() for i in range(m)]
for i in range(m):
k[i],*t=list(map(int,input().split()))
for j in range(k[i]):
s[i].add(t[j]-1)
ans=0
p=list(map(int,input().split()))
for i in range(2**n):
switch=[0]*n
flag=True
for j in range(n):
if i>>j&1:
switch[j]=1
for j in range(m):
on_cnt=0
for k in range(n):
if switch[k]==1 and k in s[j]:
on_cnt+=1
if on_cnt%2!=p[j]:
flag=False
break
if flag:
ans+=1
print(ans) | p03031 |
N, M = list(map(int, input().split()))
s = []
for _ in range(M):
kss = list(map(int, input().split()))
s.append(set([x - 1 for x in kss[1:]]))
p = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
on_counts = [0] * M
for i in range(N):
if bit & (1 << i):
for m in range(M):
if i in s[m]:
on_counts[m] += 1
if [x % 2 for x in on_counts] == p:
ans += 1
print(ans) | N, M = list(map(int, input().split()))
B = [None] * M
for i in range(M):
ks = list(map(int, input().split()))
B[i] = [s - 1 for s in ks[1:]]
p = list(map(int, input().split()))
ans = 0
bit = 0
for bit in range(1 << N):
for i, b in enumerate(B):
if p[i] != (len([1 for s in b if bit & (1 << s)]) % 2):
break
else:
ans += 1
print(ans) | p03031 |
N,M = list(map(int,input().split()))
k = [0] * M
s = [0] * M
for i in range(M):
ks = list(map(int,input().split()))
for j,x in enumerate(ks):
if j == 0:
k[i] = x
continue
s[i] += 1 << x-1
p = [int(i) for i in input().split()]
answer = 0
for i in range(2**N):
count = [0] * M
for j in range(M):
tmp = s[j] & i
while tmp:
if tmp & 1:
count[j] += 1
tmp >>= 1
# j番目の電球が光る場合 count[j] = 1
if count[j] % 2 == p[j]:
count[j] = 1
else:
count[j] = 0
# 全ての電球が点灯する場合
if not 0 in count:
answer += 1
print(answer) | N,M = list(map(int,input().split()))
S = []
for _ in range(M):
INPUT = tuple(map(int,input().split()))
S.append(INPUT[1:])
P = [int(i) for i in input().split()]
ans = 0
for i in range(2**N):
# state[i]: スイッチiがon
state = [False] * N
for j in range(N):
if 1 & (i >> j):
state[j] = True
# 全ての電球が点灯するか判定
flag = True
for j in range(M):
cnt = 0
for s in S[j]:
if state[s-1]:
cnt += 1
if cnt % 2 != P[j]:
flag = False
if flag:
ans += 1
print(ans) | p03031 |
from itertools import product
N, M = list(map(int, input().split()))
k = []
s = []
for _ in range(M):
t = list(map(int, input().split()))
k.append(t[0])
s.append(t[1:])
p = list(map(int, input().split()))
ans = sum(
all(
sum(
t[j - 1]
for j in s[i]
) % 2 == p[i]
for i in range(M)
)
for t in product(list(range(2)), repeat=N)
)
print(ans)
| from itertools import product
# 入力
N, M = list(map(int, input().split()))
k, s = list(zip(
*(
(int(k), list(map(int, s.split())))
for _ in range(M)
for k, s in [input().split(maxsplit=1)]
)
))
p = list(map(int, input().split()))
# 全探索で解を求める
ans = sum(
all(
sum(t[j - 1] for j in S) % 2 == P
for S, P in zip(s, p)
)
for t in product(list(range(2)), repeat=N)
)
# 出力
print(ans)
| p03031 |
def fbit(k,n):
t=[]
kk=k
for i in range(n):
t.append(kk%2)
kk=int(kk/2)
return t
n,m=list(map(int,input().split()))
s=[]
for i in range(m):
si=[]
for j in range(n):
si.append(0)
s.append(si)
for j in range(m):
str=input().split()
k_m=int(str[0])
for k in range(k_m):
ii=int(str[k+1])-1
s[j][ii]=1
str=input().split()
p=[]
for k in range(m):
p.append(int(str[k]))
icnt=0
for k in range(2**n):
icnt2=0
bit=fbit(k,n)
for im in range(m):
icnt3=0
for kn in range(n):
icnt3=icnt3+bit[kn]*s[im][kn]
if icnt3%2==p[im]:
icnt2=icnt2+1
if icnt2==m:
icnt=icnt+1
print(icnt) |
import itertools
n,m=list(map(int,input().split()))
ks=[]
for i in range(m):
ksi=list(map(int,input().split()))
ks.append(ksi)
p=list(map(int,input().split()))
icnt=0
for i in itertools.product([0,1], repeat=n):
yn=""
mcnt=0
for j in range(m):
ksum=0
for k in range(ks[j][0]):
if i[ks[j][k+1]-1]==1:
ksum+=1
if ksum%2==p[j]:
mcnt+=1
if mcnt==m:
icnt+=1
# print(icnt,mcnt,i)
print(icnt)
| p03031 |
# coding: utf-8
N, M = list(map(int, input().split()))
K, S = [], []
for i in range(M):
tmp = list(map(int, input().split()))
K.append(tmp[0])
S.append(tmp[1:])
P = list(map(int, input().split()))
ans = 0
for bit in range(2**N):
lamp = 0
switch = [0] * N
# インデックスに対応したランプがついてる(1, 0)ように変換
for j in range(N):
if (bit >> j) & 1 == 1:
switch[j] = 1
# 各電球ごとに確認
for i in range(M):
cnt = 0
for k in range(N):
if k+1 in S[i] and switch[k] == 1:
cnt += 1
# print("cnt", cnt)
if cnt % 2 == P[i]:
lamp += 1
if lamp == M:
ans += 1
print(ans) | # coding: utf-8
N, M = list(map(int, input().split()))
S = []
for i in range(M):
tmp = list(map(int, input().split()))
S.append(tmp[1:])
P = list(map(int, input().split()))
ans = 0
# print(S)
for bit in range(2**N):
l = []
for j in range(N):
if bit >> j & 1 == 1:
l.append(1)
else:
l.append(0)
flag = True
for j in range(M):
t = S[j]
cnt = 0
for k in range(len(S[j])):
if l[t[k]-1] == 1:
cnt += 1
# else:
# flag = False
if cnt % 2 != P[j]:
flag = False
if flag:
# print(bin(bit))
ans += 1
print(ans) | p03031 |
#!/usr/bin/env python
def main():
N, M = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(M)]
P = list(map(int, input().split()))
ans = 0
# all possible switch patterns
for i in range(2 ** N):
light_on = 0
# all switch conditions
for j in range(M):
switch_on = 0
# all connected switch
for k in S[j][1:]:
# convert integer to binary
if (i >> k-1) & 1:
switch_on += 1
if switch_on %2 == P[j]:
light_on += 1
if light_on == M:
ans += 1
return ans
if __name__ == '__main__':
print((main()))
| #!/usr/bin/env python
def main():
N, M = list(map(int, input().split()))
ks = [list(map(int, input().split())) for _ in range(M)]
p = list(map(int, input().split()))
ans = 0
for i in range(1<<N):
isConflict = False
for j in range(M):
tmp = 0
for k in ks[j][1:]:
k -= 1
tmp += (i>>k)
if tmp%2 != p[j]:
break
else:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03031 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.