input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N,K = MI()
A = LI()
A.sort()
def f(n): # Anが必要か否か
B = [0] + [A[i] for i in range(N) if i != n]
dp = [[0]*K for _ in range(2)] # dp[i][j] = B1~Biを用いてjを作れるか(メモリ節約のため工夫してる)
dp[0][0] = 1
for i in range(1,N):
b = B[i]
if i % 2 == 1:
for j in range(K):
dp[1][j] = dp[0][j]
if dp[1][j] == 0 and j >= b:
dp[1][j] = dp[0][j-b]
else:
for j in range(K):
dp[0][j] = dp[1][j]
if dp[0][j] == 0 and j >= b:
dp[0][j] = dp[1][j-b]
if sum(dp[(N-1) % 2 == 1][j] for j in range(max(K-A[n],0),K)) != 0:
return True
else:
return False
left = -1 # 不必要
right = N # 必要
while left + 1 < right:
mid = (left + right)//2
if f(mid):
right = mid
else:
left = mid
print(right)
|
import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N,K = MI()
A = LI()
A.sort()
def f(n): # Anが必要か否か
B = [0] + [A[i] for i in range(N) if i != n]
dp = [[0]*K for _ in range(2)] # dp[i][j] = B1~Biを用いてjを作れるか(メモリ節約のため工夫してる)
dp[0][0] = 1
for i in range(1,N):
b = B[i]
for j in range(K):
if j >= b:
dp[i%2][j] = dp[1-i%2][j] | dp[1-i%2][j-b]
else:
dp[i%2][j] = dp[1-i%2][j]
if sum(dp[(N-1) % 2][j] for j in range(max(K-A[n],0),K)) != 0:
return True
else:
return False
left = -1 # 不必要
right = N # 必要
while left + 1 < right:
mid = (left + right)//2
if f(mid):
right = mid
else:
left = mid
print(right)
|
p03780
|
import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N,K = MI()
A = LI()
A.sort()
def f(n): # Anが必要か否か
B = [0] + [A[i] for i in range(N) if i != n]
dp = [[0]*K for _ in range(2)] # dp[i][j] = B1~Biを用いてjを作れるか(メモリ節約のため工夫してる)
dp[0][0] = 1
for i in range(1,N):
b = B[i]
for j in range(K):
if j >= b:
dp[i%2][j] = dp[1-i%2][j] | dp[1-i%2][j-b]
else:
dp[i%2][j] = dp[1-i%2][j]
if sum(dp[(N-1) % 2][j] for j in range(max(K-A[n],0),K)) != 0:
return True
else:
return False
left = -1 # 不必要
right = N # 必要
while left + 1 < right:
mid = (left + right)//2
if f(mid):
right = mid
else:
left = mid
print(right)
|
import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N,K = MI()
A = LI()
A.sort()
def f(n): # Anが必要か否か
B = [0] + [A[i] for i in range(N) if i != n]
dp = [0]*K # dp[i][j] = B1~Biを用いてjを作れるか(メモリ節約のため工夫してる)
dp[0] = 1
for i in range(1,N):
b = B[i]
for j in range(K-1,-1,-1):
if j >= b:
dp[j] |= dp[j-b]
else:
dp[j] = dp[j]
if sum(dp[j] for j in range(max(K-A[n],0),K)) != 0:
return True
else:
return False
left = -1 # 不必要
right = N # 必要
while left + 1 < right:
mid = (left + right)//2
if f(mid):
right = mid
else:
left = mid
print(right)
|
p03780
|
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def check(x):
dp = [0] * (K + 1)
dp[0] = 1
for i in range(N):
for j in range(K - 1, -1, -1):
if i == x: continue
if dp[j]:
dp[min(K, j + a[i])] = dp[j]
for j in range(max(0, K - a[x]), K):
if dp[j]: return True
return False
#for i in range(N): print(check(i))
if check(0):
print((0))
exit(0)
ok = N
ng = 0
while ok - ng > 1:
m = (ok + ng) // 2
if check(m): ok = m
else: ng = m
print(ok)
|
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse = True)
t = 0
res = -1
for i in range(N):
if t + a[i] < K: t += a[i]
else: res = i
print((N - res - 1))
|
p03780
|
N,K = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
if a[0] >= K:
print((0))
exit()
a = [a[i] for i in range(N) if a[i]<K]
N = len(a)
ans = N
dp = [False]*K
dp[0] = True
Smax = 0
for i,a_ in reversed(list(enumerate(a))):
if Smax + a_ >= K:
ans = i
updated = True
for j in range(min(Smax,K-a_-1),-1,-1):
if dp[j]:
dp[j+a_]=True
if updated:
Smax = max(Smax,j+a_)
updated = False
print(ans)
|
N,K = list(map(int,input().split()))
a = list(map(int,input().split()))
def f(N,K,a):
a.sort()
if a[0] >= K:
print((0))
exit()
a = [a[i] for i in range(N) if a[i]<K]
N = len(a)
ans = N
dp = [False]*K
dp[0] = True
Smax = 0
for i,a_ in reversed(list(enumerate(a))):
if Smax + a_ >= K:
ans = i
updated = True
for j in range(min(Smax,K-a_-1),-1,-1):
if dp[j]:
dp[j+a_]=True
if updated:
Smax = max(Smax,j+a_)
updated = False
return ans
print((f(N,K,a)))
|
p03780
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
import bisect
idx=bisect.bisect_left(A,K)
ans=0
A=A[:idx]
N=idx
from collections import defaultdict
def search(i):
dp=defaultdict(int)
dp[0]=1
ai=A[i]
for j in range(N):
dpc=dp.copy()
if i==j:continue
for k in list(dpc.keys()):
if k+A[j]>=K or dpc[k]==0:
continue
if k+A[j]>=K-ai:
return True
dp[k+A[j]]=1
return False
MinTrue=N
MaxFalse=-1
check=(1,2)
while MinTrue-MaxFalse>1:
idx=N*check[0]//check[1]
if search(idx):
MinTrue=min(MinTrue,idx)
check=(check[0]*2-1,check[1]*2)
else:
MaxFalse=max(MaxFalse,idx)
check=(check[0]*2+1,check[1]*2)
print(MinTrue)
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort(reverse=True)
S=0
ans=0
for a in A:
if S+a<K:
S+=a
ans+=1
else:ans=0
print(ans)
|
p03780
|
n, k = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
# print(A)
le = -1
ri = len(A)
mid = (le + ri) // 2
while ri - le > 1:
# print(le,ri,mid)
DP = [0 for i in range(k)]
DP[0] = 1
for i in range(n):
#print(DP)
if i != mid:
for p in range(k-1, A[i]-1, -1):
DP[p] = int(DP[p-A[i]] or DP[p])
# print(j)
need = 0
#print(DP)
for p in range(max(0, k-A[mid]), k):
if DP[p] == 1:
need = 1
break
if need == 1:
ri = mid
else:
le = mid
mid = (le + ri) // 2
print((le + 1))
|
n, k = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
# print(A)
A_set = list(set(A))
A_set = [int(i) for i in A_set]
A_set.sort()
#print(A_set)
le = -1
ri = len(A_set)
mid = (le + ri) // 2
while ri - le > 1:
need = 0
# print(le,ri,mid)
DP = [0 for i in range(k)]
DP[0] = 1
jogai = 0
for i in range(n):
#print(DP)
if jogai == 0 and A[i] == A_set[mid]:
jogai = 1
else:
for p in range(k-1, A[i]-1, -1):
DP[p] = int(DP[p-A[i]] or DP[p])
# print(j)
#print(DP)
for p in range(max(0, k-A_set[mid]), k):
if DP[p] == 1:
need = 1
break
if need == 1:
break
if need == 1:
ri = mid
else:
le = mid
mid = (le + ri) // 2
ans = 0
if le != -1:
jougen = A_set[le]
for i in range(n):
if A[i] <= jougen:
ans += 1
print(ans)
|
p03780
|
N,K = list(map(int,input().split()))
a = list(map(int,input().split()))
dp1 = [[False]*K for _ in range(N)]
dp2 = [[False]*K for _ in range(N)]
# dp[x][y] x枚目まで使った時にyに出来るか
# K-ai <= ai < K となる部分集合を探す
dp1[0][0] = True
if a[0] < K:
dp1[0][a[0]] = True
for i in range(1,N):
for j in range(K):
dp1[i][j] = dp1[i-1][j] or (j-a[i] >= 0 and dp1[i-1][j-a[i]])
dp2[0][0] = True
if a[N-1] < K:
dp2[0][a[N-1]] = True
for i in range(1,N):
for j in range(K):
dp2[i][j] = dp2[i-1][j] or (j-a[N-i-1] >= 0 and dp2[i-1][j-a[N-i-1]])
count = 0
for i in range(N):
if K-a[i] <= 0:
count += 1
continue
for j in range(K-a[i],K):
f = False
if i == 0:
if dp2[N-2][j]:
count += 1
break
else:
continue
elif i == N-1:
if dp1[N-2][j]:
count += 1
break
else:
continue
for k in range(j+1):
if dp1[i-1][k] and dp2[N-i-2][j-k]:
count += 1
f = True
break
if f:
break
print((N-count))
|
N,K = list(map(int,input().split()))
a = sorted(map(int,input().split()))
count = N
s = 0
for i in range(N-1,-1,-1):
if s + a[i] < K:
s += a[i]
else:
count = min(i,count)
print(count)
|
p03780
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from pprint import pprint
from collections import Counter, defaultdict, deque
import queue
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def Prim(g):
V = list(g.keys())
for v in g.values():
V.extend(list(v.keys()))
V = list(set(V))
used = set([])
q = []
heapq.heappush(q, (0, V[0]))
ret = 0
while q:
c, v = heapq.heappop(q)
if v in used:
continue
used.add(v)
ret += c
for u in g[v]:
heapq.heappush(q, (g[v][u], u))
return ret
@mt
def slv2(N, K, A):
@lru_cache(maxsize=None)
def f(w):
if K - A[w] < 0:
return True
dp = [0] * (K)
for i, a in enumerate(A):
if i == w:
continue
tdp = dp[:]
for j in range(K):
if dp[j] and j + a < K:
tdp[j+a] = 1
if a < K:
tdp[a] = 1
dp = tdp
if sum(dp[K-A[w]:]) > 0:
return True
return False
ans = 0
for i in range(N):
if not f(i):
ans += 1
return ans
@mt
def slv(N, K, A):
@lru_cache(maxsize=None)
def f(w):
if K - A[w] <= 0:
return True
dp = [0] * (K)
tdp = [0] * (K)
for i, a in enumerate(A):
if i == w:
continue
for j in range(K):
tdp[j] += dp[j]
if dp[j] and j + a < K:
tdp[j+a] = 1
if a < K:
tdp[a] = 1
dp, tdp = tdp, dp
if sum(dp[K-A[w]:]) > 0:
return True
return False
A.sort()
l = 0
r = N-1
while r-l > 1:
c = (l+r)//2
if f(c):
r = c
else:
l = c
if f(l):
return l
return r + 1 if not f(r) else l + 1
def main():
N, K = read_int_n()
A = read_int_n()
print(slv(N, K, A))
# for i in range(10000):
# N = random.randint(1, 50)
# K = random.randint(1, 50)
# A = [random.randint(1, 10) for _ in range(N)]
# x = slv(N, K, A[:])
# y = slv2(N, K, A[:])
# print(x, y)
# if x != y:
# print(N, K)
# print(' '.join(map(str, A)))
# return
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from pprint import pprint
from collections import Counter, defaultdict, deque
import queue
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, K, A):
A.sort()
s = 0
ans = N
for i in range(N-1, -1, -1):
if s + A[i] < K:
s += A[i]
else:
ans = min(ans, i)
return ans
def main():
N, K = read_int_n()
A = read_int_n()
print(slv(N, K, A))
if __name__ == '__main__':
main()
|
p03780
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
l=N
for i in range(0,N):
if A[i]>=K:
l=i
break
A=A[:l]
N=l
#A[num]が必要な数か判定
def condition(num):
if N-1>num:
test=A[:num]+A[num+1:]
else:
test=A[:num]
if A[num]>=K:
return True
else:
dp=[False for i in range(0,K)]
for i in range(K-A[num],K):
dp[i]=True
for i in range(1,N):
for j in range(0,K-test[i-1]):
dp[j]=dp[j] or dp[j+test[i-1]]
return dp[0]
#必要な数のうち最小のもの
if N==0:
print((0))
elif N==1:
if A[0]>=K:
print((0))
else:
print((1))
else:
start=0
end=N-1
while end-start>1:
t=(end+start)//2
if condition(t):
end=t
else:
start=t
if condition(start):
print(start)
elif condition(end):
print(end)
else:
print(N)
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
l=N
for i in range(0,N):
if A[i]>=K:
l=i
break
A=A[:l]
N=l
#A[num]が必要な数か判定
def condition(num):
if N-1>num:
test=A[:num]+A[num+1:]
else:
test=A[:num]
if A[num]>=K:
return True
else:
check=0
for i in range(K-A[num],K):
check+=pow(2,i)
for i in range(1,N):
check=check|(check>>test[i-1])
return check%2==1
#必要な数のうち最小のもの
if N==0:
print((0))
elif N==1:
if A[0]>=K:
print((0))
else:
print((1))
else:
start=0
end=N-1
while end-start>1:
t=(end+start)//2
if condition(t):
end=t
else:
start=t
if condition(start):
print(start)
elif condition(end):
print(end)
else:
print(N)
|
p03780
|
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N,K = IL()
A = IL()
A.sort(reverse=True)
ans = 0
now = 0
cnt = 0
for i in range(N):
a = A[i]
if now+a>=K:
ans += cnt+1
cnt = 0
else:
now += a
cnt += 1
print((N-ans))
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort(reverse=True)
ans = 0
sum = 0
cnt = 0
for i in range(N):
a = A[i]
if sum+a>=K:
ans += cnt+1
cnt = 0
else:
sum += a
cnt += 1
print((N-ans))
|
p03780
|
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,K=MI()
a=LI()#下位の連続するn枚が不要なはず
a.sort(reverse = True)
#i番目までを使ってjが作れるかどうか
dp=[[False]*K for _ in range(N+1)]
dp[0][0]=1
for i in range(N):
for j in range(K):
if dp[i][j]==1:
dp[i+1][j]=1
jj=j+a[i]
if jj<K:
dp[i+1][jj]=1
#i番目以降を使ってjが作れるかどうか
dp2=[[0]*K for _ in range(N+1)]
dp2[-1][0]=True
for i in range(N):
for j in range(K):
if dp2[-1-i][j]==True:
dp2[-2-i][j]=True
jj=j+a[-1-i]
if jj<K:
dp2[-2-i][jj]=True
#累積和チックに
for i in range(N+1):
for j in range(K-1):
dp[i][j+1]+=dp[i][j]
#x番目の数が必要かどうかの判定
#必要なものだけで構成された集合をもとに考えれば良いわけではない，不必要な分も考えなければならない
def ch(x):
if a[x]>=K:
return True
else:
#dp2でsを作り，dpで，K-s未満，K-a[x]-s以上のものが作れれば良い，
#この範囲内で1が一つでもあれば良いので，累積和の差分が1以上ならok
for s in range(K-a[x]):
if dp2[x+1][s]==True:
if dp[x][K-s-1] - dp[x][K-a[x]-s-1]>=1:
return True
return False
ng=N
ok=-1
while abs(ok-ng)>1:
med=(ok+ng)//2
if ch(med):
ok=med
else:
ng=med
print((N-(ok+1)))
main()
|
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,K=MI()
a=LI()#下位の連続するn枚が不要なはず
a.sort()
#x番目の数が必要かどうかの判定
#必要なものだけで構成された集合をもとに考えれば良いわけではない，不必要な分も考えなければならない
def ch(x):
if a[x]>=K:
return True
else:
#使い回す，i番目まででjが作れるか
dp=[False]*K
dp[0]=True
for i in range(N):
if i==x:
continue
else:
for j in range(K-1,-1,-1):
jj=j-a[i]
if jj>=0:
if dp[jj]:
dp[j]=True
#K未満K-a[x]以上が作れれば良い
for j in range(K-a[x],K):
if dp[j]:
return True
return False
return False
ng=-1
ok=N
while abs(ok-ng)>1:
med=(ok+ng)//2
if ch(med):
ok=med
else:
ng=med
print((ng+1))
main()
|
p03780
|
def main():
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
N,K=MI()
a=LI()#下位の連続するn枚が不要なはず
a.sort()
for i in range(N):#K以上ならば必要
if a[i]>=K:
a=a[:i]
break
N=len(a)
#x番目の数が必要かどうかの判定
#必要なものだけで構成された集合をもとに考えれば良いわけではない，不必要な分も考えなければならない
def ch(x):
#使い回す，i番目まででjが作れるか
dp=[0]*K
dp[0]=1
for i in range(N):
if i==x:
continue
else:
for j in range(K-1,a[i]-1,-1):
dp[j]|=dp[j-a[i]]
#K未満K-a[x]以上が作れれば良い
for j in range(K-a[x],K):
if dp[j]:
return True
return False
ng=-1
ok=N
while abs(ok-ng)>1:
med=(ok+ng)//2
if ch(med):
ok=med
else:
ng=med
print((ng+1))
main()
|
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,K=MI()
a=LI()#下位の連続するn枚が不要なはず
a.sort()
for i in range(N):#K以上ならば必要
if a[i]>=K:
a=a[:i]
break
N=len(a)
#x番目の数が必要かどうかの判定
#必要なものだけで構成された集合をもとに考えれば良いわけではない，不必要な分も考えなければならない
def ch(x):
#使い回す，i番目まででjが作れるか
dp=[0]*K
dp[0]=1
for i in range(N):
if i==x:
continue
else:
for j in range(K-1,a[i]-1,-1):
dp[j]|=dp[j-a[i]]
#K未満K-a[x]以上が作れれば良い
for j in range(K-a[x],K):
if dp[j]:
return True
return False
ng=-1
ok=N
while abs(ok-ng)>1:
med=(ok+ng)//2
if ch(med):
ok=med
else:
ng=med
print((ng+1))
main()
|
p03780
|
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,K=MI()
a=LI()#下位の連続するn枚が不要なはず
a.sort()
for i in range(N):#K以上ならば必要
if a[i]>=K:
a=a[:i]
break
N=len(a)
#x番目の数が必要かどうかの判定
#必要なものだけで構成された集合をもとに考えれば良いわけではない，不必要な分も考えなければならない
def ch(x):
#使い回す，i番目まででjが作れるか
dp=[0]*K
dp[0]=1
for i in range(N):
if i==x:
continue
else:
for j in range(K-1,a[i]-1,-1):
dp[j]|=dp[j-a[i]]
#K未満K-a[x]以上が作れれば良い
for j in range(K-a[x],K):
if dp[j]:
return True
return False
ng=-1
ok=N
while abs(ok-ng)>1:
med=(ok+ng)//2
if ch(med):
ok=med
else:
ng=med
print((ng+1))
main()
|
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
N,K=MI()
a=LI()#下位の連続するn枚が不要なはず
a.sort(reverse=True)
#大きい方から順に足していき，K未満の最大の和を作っておく．これに対して，足してK以上になるのならそれは必要．K未満なら端しておく．
#最終的に必要なもののうち最も小さいものがわかるはず
temp=0
ans=N
for i in range(N):
if temp+a[i]<K:
temp+=a[i]
else:
ans=min(ans,N-i-1)
print(ans)
main()
|
p03780
|
N,K = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A.sort()
def f(n): #aiが必要か不必要か判定
if A[n] >= K:
return True
if n == 0:
L = A[n+1:]
elif n == N-1:
L = A[:n]
else:
L = A[:n] + A[n+1:]
dp0 = [0]*K
dp0[0] = 1
dp1 = [0]*K
for i in range(N-1):
for j in range(K):
if i%2 == 0:
if j < L[i]:
dp1[j] = dp0[j]
continue
dp1[j] = dp0[j] | dp0[j-L[i]]
else:
if j < L[i]:
dp0[j] = dp1[j]
continue
dp0[j] = dp1[j] | dp1[j-L[i]]
res = False
if N%2 == 0:
for j in range(K-A[n], K):
if dp1[j]:
res = True
break
else:
for j in range(K-A[n], K):
if dp0[j]:
res = True
break
return res
l = -1
r = N
while r-l > 1:
m = (l+r)//2
if f(m):
r = m
else:
l = m
print(r)
|
N,K = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A.sort()
for i in range(N):
if A[i] >= K:
A = A[:i]
break
N = len(A)
def f(n): #aiが必要か不必要か判定
dp = [0]*K
dp[0] = 1
for i in range(N):
if i == n:
continue
for j in range(K-1, A[i]-1, -1):
dp[j] |= dp[j-A[i]]
res = False
for j in range(K-A[n], K):
if dp[j]:
res = True
break
return res
l = -1
r = N
while r-l > 1:
m = (l+r)//2
if f(m):
r = m
else:
l = m
print(r)
|
p03780
|
n,k=list(map(int,input().split()))
a=[int(i) for i in input().split()]
a.sort()
def check(d):#そいつが必要か
global a,n,k
dp=[0]*(k)#k-1まで
if a[d]>=k:
return True
for i in range(n):
if i!=d:
dp_sub=[0]*(k)
for j in range(k-1):
if j==0 or dp[j]!=0:
if j+a[i]<k:
dp_sub[j+a[i]]=1
else:
break
for j in range(k):
if dp_sub[j]==1:
dp[j]=1
if j+a[d]>=k:
return True
return False
l,r=0,n-1
while l+1<r:
d=(l+r)//2
if check(d):#必要か
r=d
else:
l=d
if check(l):
print(l)
else:
if check(r):
print(r)
else:
print((r+1))
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
ans = N
t = 0
for i in range(N-1, -1, -1) :
if t+a[i] < K :
t += a[i]
else :
ans = min(ans, i)
print(ans)
|
p03780
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def sub(ii):
dp = 1
for i in range(n):
if i==ii:
continue
dp |= dp<<a[i]
# for j in range(k-1, a[i]-1, -1):
# dp[j] += dp[j-a[i]]
val = max(i for i in range(k) if (dp>>i)&1)
return val+a[ii]>=k
if sub(0):
ans = 0
elif not sub(n-1):
ans = n
else:
l = 0
r = n-1
while l<r-1:
m = (l+r)//2
if sub(m):
r = m
else:
l = m
ans = l+1
print(ans)
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def sub(ii):
dp = 1
mask = (1<<(k+1)) - 1
for i in range(n):
if i==ii:
continue
dp |= dp<<a[i]
dp &= mask
# for j in range(k-1, a[i]-1, -1):
# dp[j] += dp[j-a[i]]
val = max(i for i in range(k) if (dp>>i)&1)
return val+a[ii]>=k
if sub(0):
ans = 0
elif not sub(n-1):
ans = n
else:
l = 0
r = n-1
while l<r-1:
m = (l+r)//2
if sub(m):
r = m
else:
l = m
ans = l+1
print(ans)
|
p03780
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
mask = (1<<(k+1)) - 1
def sub(ii):
dp = 1
for i in range(n):
if i==ii:
continue
dp |= (dp<<a[i]) & mask
# for j in range(k-1, a[i]-1, -1):
# dp[j] += dp[j-a[i]]
val = max(i for i in range(k) if (dp>>i)&1)
return val+a[ii]>=k
if sub(0):
ans = 0
elif not sub(n-1):
ans = n
else:
l = 0
r = n-1
while l<r-1:
m = (l+r)//2
if sub(m):
r = m
else:
l = m
ans = l+1
print(ans)
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
a = list([min(int(x), k+1) for x in input().split()])
a.sort()
mask = (1<<(k+1)) - 1
def sub(ii):
dp = 1
for i in range(n):
if i==ii:
continue
dp |= (dp<<a[i]) & mask
# for j in range(k-1, a[i]-1, -1):
# dp[j] += dp[j-a[i]]
val = max(i for i in range(k) if (dp>>i)&1)
return val+a[ii]>=k
if sub(0):
ans = 0
elif not sub(n-1):
ans = n
else:
l = 0
r = n-1
while l<r-1:
m = (l+r)//2
if sub(m):
r = m
else:
l = m
ans = l+1
print(ans)
|
p03780
|
# -*- coding: utf-8 -*-
import sys
from collections import defaultdict
from bisect import bisect_left
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
A = LIST()
# 部分和DPを変形させて、その値になるのに使われた値の集合を持っておく
dp = defaultdict(list)
dp[0].append(0)
for i in range(N):
for j in range(K-1, -1, -1):
if len(dp[j]):
dp[j+A[i]] += dp[j]
dp[j+A[i]].append(A[i])
# 和がK未満の集合はこの後のチェックで使わないので削る
dp = sorted(dp.items())
keys, lists = list(zip(*dp))
idx = bisect_left(keys, K)
keys = keys[idx:]
lists = lists[idx:]
sets = [set() for i in range(len(lists))]
for i, li in enumerate(lists):
sets[i] = set(li)
ans = 0
for i in range(N):
for k, s in zip(keys, sets):
# A[i]減らしたらK未満になる状況で、一度でもA[i]が使われていれば必要
if k-A[i] < K and A[i] in s:
break
else:
# 該当するどの集合でも、一度も使われていなければ不要
ans += 1
print(ans)
|
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
def bisearch_min(mn, mx, func):
""" 条件を満たす最小値を見つける二分探索 """
ok = mx
ng = mn
while ng+1 < ok:
mid = (ok+ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
N, K = MAP()
A = LIST()
def check(omit):
# 部分和DP
dp = [0] * K
dp[0] = 1
for i in range(1, N+1):
for j in range(K-1, -1, -1):
if i-1 != omit and j-A[i-1] >= 0:
dp[j] |= dp[j-A[i-1]]
# 今回の値A[omit]を足してKに到達できるような部分和があれば、これは必要
for j in range(max(0, K-A[omit]), K):
if dp[j]:
return True
# なければ不要
return False
A.sort()
print((bisearch_min(-1, N, check)))
|
p03780
|
import itertools
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
need = []
iranaiko = []
for a in A:
if a >= K:
need.append(a)
elif a in need:
need.append(a)
elif a in iranaiko:
pass
else:
z = 0
B = A[:]
B.remove(a)
fusoku = [K - i - 1 for i in range(a)]
for bi,b in enumerate(B):
if b >= K:
break
B = B[:bi + 1]
for i in range(1,len(B) + 1):
C = list(itertools.combinations(B,i))
p = 0
for c in C:
if sum(c) in fusoku:
need.append(a)
z = 1
break
if sum(c) >= K:
p = p + 1
if p == len(C):
iranaiko.append(a)
z = 1
break
if z == 1:
break
if z == 0:
iranaiko.append(a)
print((N - len(need)))
|
import itertools
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
need = []
iranaiko = []
for a in A:
if a >= K:
need.append(a)
elif a in need:
need.append(a)
elif a in iranaiko:
pass
else:
z = 0
B = A[:]
B.remove(a)
fusoku = [K - i - 1 for i in range(a)]
for bi,b in enumerate(B):
if b >= K:
break
B = B[:bi + 1]
B.reverse()
C = [0]
for b in B:
D = []
for c in C:
if b + c < K:
if b + c in fusoku:
z = 1
need.append(a)
break
D.append(b + c)
D.append(0)
C = D[:]
if z == 1:
break
print((N - len(need)))
|
p03780
|
import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
from collections import Counter
n,k = li()
a = li()
a_ltk = [ai for ai in a if ai < k]
a_ltk.sort(reverse=True)
need = {ai:False for ai in a_ltk}
# 貪欲に足していく
for i in range(len(a_ltk)):
cur = 0
stack = []
for j in range(i,len(a_ltk)):
cur += a_ltk[j]
stack.append(a_ltk[j])
if cur >= k:
for key in stack:
need[key] = True
stack.pop()
cur -= a_ltk[j]
cnt = Counter(a_ltk)
ans = 0
for k,v in list(need.items()):
if not v:
ans += cnt[k]
print(ans)
|
import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
from collections import Counter
n,k = li()
a = li()
a_ltk = [ai for ai in a if ai < k]
a_ltk.sort(reverse=True)
need = {ai:False for ai in a_ltk}
# 貪欲に足していく
for i in range(len(a_ltk)):
cur = 0
stack = []
for j in range(i,len(a_ltk)):
cur += a_ltk[j]
stack.append(a_ltk[j])
if cur >= k:
for key in set(stack):
if need[key]:
continue
else:
need[key] = True
stack.pop()
cur -= a_ltk[j]
cnt = Counter(a_ltk)
ans = 0
for k,v in list(need.items()):
if not v:
ans += cnt[k]
print(ans)
|
p03780
|
#import numpy as np
MAX_INT = int(10e10)
N,K = list(map(int,input().split()))
cards = list(map(int,input().split()))
cards.sort()
cards += [MAX_INT]
#print(cards)
left = -1
right = N
while right - left > 1:
middle = (left+right)//2
#print(left,right,middle,cards[middle])
dp = [[0]*K for i in range(N+2)]
for i in range(N+1):
for j in range(K):
if i == middle:
dp[i+1][j] = dp[i][j]
else:
if cards[i] <= j:
dp[i+1][j] = max(dp[i][j],dp[i][j-cards[i]]+cards[i])
else:
dp[i+1][j] = dp[i][j]
if dp[N][K-1] + cards[middle] >= K:
right = middle
#print(True)
else:
left = middle
#print(False)
print(right)
|
#import numpy as np
MAX_INT = int(10e10)
N,K = list(map(int,input().split()))
cards = list(map(int,input().split()))
cards.sort()
cards += [MAX_INT]
#print(cards)
dp = [[0]*K for i in range(N+2)]
left = -1
right = N
while right - left > 1:
middle = (left+right)//2
#print(left,right,middle,cards[middle])
for i in range(N+1):
for j in range(K):
if i == middle:
dp[i+1][j] = dp[i][j]
else:
if cards[i] <= j:
dp[i+1][j] = max(dp[i][j],dp[i][j-cards[i]]+cards[i])
else:
dp[i+1][j] = dp[i][j]
#print(dp)
if dp[N][K-1] + cards[middle] >= K:
right = middle
#print(True)
else:
left = middle
#print(False)
print(right)
|
p03780
|
def examA():
N = DI()/dec(7)
ans = N
print(N)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
N, K = LI()
A = LI()
A.sort()
mask = (1 << K) - 1
noneed = -1; need = N
while(need-noneed>1):
#print(noneed,need)
i = (need+noneed)//2
if A[i]>=K:
is_need = True
else:
dp = 1
for j in range(N):
a = A[j]
if i == j:
continue
dp |= ((dp << a) & mask)
# print(dp,mask)
val = max(i for i in range(K) if (dp >> i) & 1)
is_need = (val+A[i]>=K)
# print(is_need,i)
if is_need:
need = i
else:
noneed = i
ans = noneed + 1
print(ans)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""
|
def examA():
N = DI()/dec(7)
ans = N
print(N)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
N, K = LI()
A = LI()
A.sort()
mask = (1 << K) - 1
noneed = -1; need = N
while(need-noneed>1):
#print(noneed,need)
i = (need+noneed)//2
if A[i]>=K:
is_need = True
else:
dp = 1
for j in range(N):
a = A[j]
if a>K:
break
if i == j:
continue
dp |= ((dp << a) & mask)
# print(dp,mask)
is_need = (dp > mask>>A[i])
# print(is_need,i)
if is_need:
need = i
else:
noneed = i
ans = noneed + 1
print(ans)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""
|
p03780
|
import sys
N,K=list(map(int, input().split()))
a=list(map(int, input().split()))
sum=0
for i in range(0,N):
sum+=a[i]
if sum<K:#全部不必要
print(N)
sys.exit()
if sum==K:#全部必要
print((0))
sys.exit()
a.sort()
a.reverse()
#K未満の最大の数字のラベルはどこ？
l=N
for i in range(N-1,-1,-1):
if a[i]<K:
l=i
else:
break
if l==N:
print((0))
sys.exit()
count=N
#lまでの要素が必要か不要かチェック(使いまわし可能)
sum=0
for j in range(l,N):
if sum+a[j]<K:
sum+=a[j]
for i in range(0,l):
if sum+a[i]>=K:#必要ってことだ
count-=1
#lからの要素は自分のことを抜かないといけないことに注意
for i in range(l,N):
sum=0
b=a[:]
C=b.pop(i)
for j in range(l-1,N-1):
if sum+b[j]<K:
sum+=b[j]
if sum+C>=K:#必要ってことだ
count-=1
print(count)
|
import sys
N,K=list(map(int, input().split()))
a=list(map(int, input().split()))
sum=0
for i in range(0,N):
sum+=a[i]
if sum<K:#全部不必要
print(N)
sys.exit()
if sum==K:#全部必要
print((0))
sys.exit()
a.sort()
a.reverse()
#K未満の最大の数字のラベルはどこ？
l=N
for i in range(N-1,-1,-1):
if a[i]<K:
l=i
else:
break
if l==N:
print((0))
sys.exit()
count=N
#lまでの要素が必要か不要かチェック(使いまわし可能)
sum=0
l_list=[]
for j in range(l,N):
if sum+a[j]<K:
sum+=a[j]
l_list.append(a[j])
for i in range(0,l):
if sum+a[i]>=K:#必要ってことだ
count-=1
#lからの要素は自分のことを抜かないといけないことに注意
for i in range(l,N):
if a[i] in l_list:
sum=0
b=a[:]
C=b.pop(i)
for j in range(l-1,N-1):
if sum+b[j]<K:
sum+=b[j]
if sum+C>=K:#必要ってことだ
count-=1
else:
count-=1
print(count)
|
p03780
|
import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
dp1 = [set() for _ in range(N)]
dp1[0].add(0)
for n in range(N-1):
for pm in dp1[n]:
dp1[n+1].add(pm)
if pm + A[n] < K:
dp1[n+1].add(pm+A[n])
dp2 = [set() for _ in range(N)]
dp2[N-1].add(0)
for n in reversed(list(range(1, N))):
for pm in dp2[n]:
dp2[n-1].add(pm)
if pm+A[n] < K:
dp2[n-1].add(pm+A[n])
ans = 0
for n, a in enumerate(A):
b = K - a
if b <= 0: continue
need = False
B1 = sorted(dp1[n])
B2 = sorted(dp2[n], reverse=True)
i2 = 0
for b1 in B1:
while B2[i2] + b1 >= K:
i2 += 1
if i2 == len(B2): break
if i2 == len(B2): break
if b1+B2[i2] < b:
continue
else:
need = True
break
if not need: ans += 1
print(ans)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
dp1 = [[0]*K for _ in range(N)]
dp1[0][0] = 1
for n in range(N-1):
for k in range(K):
if k < A[n]:
dp1[n+1][k] = dp1[n][k]
else:
dp1[n+1][k] = dp1[n][k] | dp1[n][k-A[n]]
dp2 = [[0]*K for _ in range(N)]
dp2[N-1][0] = 1
for n in reversed(list(range(1, N))):
for k in range(K):
if k < A[n]:
dp2[n-1][k] = dp2[n][k]
else:
dp2[n-1][k] = dp2[n][k] | dp2[n][k-A[n]]
ans = 0
for n, a in enumerate(A):
b = K - a
if b <= 0: continue
need = False
k2 = K-1
for k1 in range(K):
if not dp1[n][k1]: continue
while not dp2[n][k2] or k1+k2 >= K:
k2 -= 1
if k1+k2 < b:
continue
else:
need = True
break
if not need: ans += 1
print(ans)
if __name__ == "__main__":
main()
|
p03780
|
# -*- coding:utf-8 -*-
from itertools import combinations
n,k = list(map(int,input().split()))
a = list(map(int, input().split()))
a=sorted(a)
o=0
discard = []
hold = []
checked = []
# 再帰関数をつくる
if sum(a) < k:
o = n
else:
for i in range(n,-1,-1):
b = list(combinations(a, i+1))
# 組み合わせ全通り
for c in b:
# それぞれの組み合わせ検証
s = sum(c)
if s >= k:
# 良い集合だけを検証、なければそれ以下の集合は検証しない
c = reversed(c)
for d in c:
if (s-d) >=k:
discard.append(d)
discard=list(set(discard))
else:
# 未満になれば、その数値は必要、それ以後の取り出しは無意味なのでbreak
hold.append(d)
hold=list(set(hold))
checked.append(d)
else:
pass
ans = list(set(discard)-set(hold))
o = len(ans)
print(o)
|
# -*- coding:utf-8 -*-
n,k = list(map(int,input().split()))
a = list(map(int, input().split()))
a = list(reversed(sorted(a)))
nec = 0
for i in range(n):
s = 0
for j in range(i,n):
s += a[j]
if s >= k:
nec = max(nec,j+1)
s -= a[j]
print((n-nec))
|
p03780
|
def solve(n):
global N, K
dp = [[0] * (K + 1) for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
a = 0 if i == n else A[i]
for j in range(max(0, K - a + 1)):
here = dp[i][j]
dp[i + 1][j + a] |= here
dp[i + 1][j] |= here
rst = any(dp[N][k] for k in range(max(0, K - A[n]), K))
return rst
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
# [ok, ng) - Maximum
# (ng, ok] - Minimum
# ok が 最終的な答え
ok = N
ng = -1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
n = mid
dp = [[0] * (K + 1) for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
a = 0 if i == n else A[i]
for j in range(K + 1):
here = dp[i][j]
dp[i + 1][min(K, j + a)] |= here
dp[i + 1][j] |= here
rst = any(dp[N][k] for k in range(max(0, K - A[n]), K))
if rst:
ok = mid
else:
ng = mid
print(ok)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
# [ok, ng) - Maximum
# (ng, ok] - Minimum
# ok が 最終的な答え
ok = N
ng = -1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
n = mid
dp = [0] * (K + 1)
dp[0] = 1
for i in range(N):
a = 0 if i == n else A[i]
for j in range(K, -1, -1):
dp[min(K, j + a)] |= dp[j]
rst = any(dp[k] for k in range(max(0, K - A[n]), K))
if rst:
ok = mid
else:
ng = mid
print(ok)
|
p03780
|
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
# [ok, ng) - Maximum
# (ng, ok] - Minimum
# ok が 最終的な答え
ok = N
ng = -1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
n = mid
dp = [0] * (K + 1)
dp[0] = 1
for i in range(N):
a = A[i]
if i == n or a >= K:
continue
for j in range(K, -1, -1):
dp[min(K, j + a)] |= dp[j]
rst = any(dp[k] for k in range(max(0, K - A[n]), K))
if rst:
ok = mid
else:
ng = mid
print(ok)
main()
|
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
# [ok, ng) - Maximum
# (ng, ok] - Minimum
# ok が 最終的な答え
ok = N
ng = -1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
n = mid
dp = [0] * (K + 1)
dp[0] = 1
for i in range(N):
a = A[i]
if i == n or a >= K:
continue
for j in range(K, a - 1, -1):
dp[j] |= dp[j - a]
rst = any(dp[k] for k in range(max(0, K - A[n]), K))
if rst:
ok = mid
else:
ng = mid
print(ok)
main()
|
p03780
|
import sys
sys.setrecursionlimit(4100000)
def biser(lst,func):
n=len(lst)
nh=n//2
if n==1:
if func(lst[0]):
return lst[0]
else:
return -1
if func(lst[nh]):
return biser(lst[nh:],func)
else:
return biser(lst[:nh],func)
def findminsum(lst,K,N):
inf=10**6
dp=[[inf]*N for s in range(K+1)]
for s in range(K+1):
for j in range(N):
if j==0 and s<=lst[j]:
dp[s][j]=lst[0]
elif s>lst[j] and j>0:
dp[s][j]=min(dp[s-lst[j]][j-1]+lst[j], dp[s][j-1])
elif s<=lst[j] and j>0:
dp[s][j]=min(lst[j],dp[s][j-1])
# print(lst)
# print(dp[0][:])
# print(dp[1][:])
# print(dp[K][:])
return dp[K][N-1]
def main():
N,K=list(map(int,sys.stdin.readline().strip().split()))
cards=list(map(int,sys.stdin.readline().strip().split()))
# cards=list(filter(lambda x:x<K,cards))
# N=len(cards)
cards.sort()
ci=list(range(N))
def inneccesity(h):
if cards[h]>=K:
return False
else:
c=cards[h]
cards[h]=0
ret=findminsum(cards,K-c,N)>=K
cards[h]=c
return ret
#nn=0
nn=biser(ci,inneccesity)
# for i in range(N):
# if cards[i]<K:
# c=cards[i]
# cards[i]=0
# if findminsum(cards,K-c,N)>=K:
# nn+=1
# cards[i]=c
# else:
# break
print((nn+1))
if __name__=='__main__':
main()
|
#4 9
#1 3 5 6
#の時に1（正解は0）と出力されるがACになる
N, K = list(map(int, input().split()))
a=list(map(int, input().split()))
a.sort()
ans = N
t = 0
for i in range(N-1, -1, -1) :
if t+a[i] < K:
t += a[i]
else:
ans = min(ans, i)
print(ans)
|
p03780
|
import sys
def biser(lst,func):
n=len(lst)
nh=n//2
if n==1:
if func(lst[0]):
return lst[0]
else:
return -1
if func(lst[nh]):
return biser(lst[nh:],func)
else:
return biser(lst[:nh],func)
def mkns(a,s,m):
if a==0:
return s
else:
return (((s+1)<<a)|s) & m
def main():
N,K=list(map(int,sys.stdin.readline().strip().split()))
a=list(map(int,sys.stdin.readline().strip().split()))
a.sort()
ss=[0]*(N+1)
pm=(1<<K)-1
mask=lambda c:(1<<K)-(1<<c)
nn=0
def isunnec(i):
if a[i]>=K:
return False
for j in range(i+1,N):
if a[j]>=K:
break
ss[i]=mkns(a[j],ss[i],pm)
# print(bin(ss[i]), bin(mask(K-c)),ss[i]&mask(K-c))
if ss[i]&mask(K-a[i])==0:
return True
return False
for i in range(N):
if a[i]>=K:
break
ss[i+1]=mkns(a[i],ss[i],pm)
if isunnec(i):
nn+=1
# for j in range(i+1,N):
# if a[j]>=K:
# break
# ss[i]=mkns(a[j],ss[i],pm)
# # print(bin(ss[i]), bin(mask(K-c)),ss[i]&mask(K-c))
# if ss[i]&mask(K-a[i])==0:
# nn+=1
# nn=biser(list(range(N)),isunnec)+1
# print(list(map(bin,ss)))
print(nn)
if __name__=='__main__':
main()
|
import sys
def biser(lst,func):
n=len(lst)
nh=n//2
if n==1:
if func(lst[0]):
return lst[0]
else:
return -1
if func(lst[nh]):
return biser(lst[nh:],func)
else:
return biser(lst[:nh],func)
def mkns(a,s,m):
if a==0:
return s
else:
return (((s+1)<<a)|s) & m
def main():
N,K=list(map(int,sys.stdin.readline().strip().split()))
a=list(map(int,sys.stdin.readline().strip().split()))
a.sort()
ss=[0]*(N+1)
pm=(1<<K)-1
mask=lambda c:(1<<K)-(1<<c)
nn=0
def isunnec(i):
if a[i]>=K:
return False
for j in range(i+1,N):
if a[j]>=K:
break
ss[i]=(((ss[i]+1)<<a[j])|ss[i]) & pm
# print(bin(ss[i]), bin(mask(K-c)),ss[i]&mask(K-c))
if ss[i]&mask(K-a[i])==0:
return True
return False
for i in range(N):
if a[i]>=K:
break
ss[i+1]=(((ss[i]+1)<<a[i])|ss[i]) & pm
#if isunnec(i):
# nn+=1
#for j in range(i+1,N):
# if a[j]>=K:
# break
# ss[i]=mkns(a[j],ss[i],pm)
##print(bin(ss[i]), bin(mask(K-c)),ss[i]&mask(K-c))
#if ss[i]&mask(K-a[i])==0:
# nn+=1
#m=len(list(filter(lambda x:x<K, a)))
nn=biser(list(range(N)),isunnec)+1
#print(list(map(bin,ss)))
print(nn)
if __name__=='__main__':
main()
|
p03780
|
from itertools import accumulate
def main():
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
dp = [0] * (K+1)
dp[0] = 1
nonzeros = [1]
for a in As:
ndp = []
nonzero = 0
for i in range(K+1):
t = dp[i] if i < a else dp[i] + dp[i-a]
if t == 0:
ndp.append(0)
else:
nonzero |= 1 << i
ndp.append(1)
nonzeros.append(nonzero)
dp = ndp
dp = [0] * (K+1)
dp[0] = 1
acc = list(accumulate(dp)) + [0]
ans = 0
for i in range(N, 0, -1):
a = As[i-1]
ndp = []
for j in range(K+1):
t = dp[j] if j < a else dp[j] + dp[j-a]
ndp.append(0 if t == 0 else 1)
dp = ndp
if a < K:
nonzero = nonzeros[i-1]
for y in range(K+1):
if nonzero & 1:
t = K-y-a-1
if acc[K-y-1] > acc[t if t >= 0 else -1]:
break
nonzero >>= 1
else:
ans += 1
acc = list(accumulate(dp)) + [0]
print(ans)
main()
|
from itertools import accumulate
def main():
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
nonzeros = [1]
for a in As:
ndp = nonzeros[-1]
if a <= K:
ndp |= (nonzeros[-1] % (1 << (K-a))) << a
nonzeros.append(ndp)
dp = [0] * (K+1)
dp[0] = 1
acc = list(accumulate(dp)) + [0]
ans = 0
for i in range(N, 0, -1):
a = As[i-1]
ndp = []
for j in range(K+1):
t = dp[j] if j < a else dp[j] + dp[j-a]
ndp.append(0 if t == 0 else 1)
dp = ndp
if a < K:
nonzero = nonzeros[i-1]
for y in range(K+1):
if nonzero & 1:
t = K-y-a-1
if acc[K-y-1] > acc[t if t >= 0 else -1]:
break
nonzero >>= 1
else:
ans += 1
acc = list(accumulate(dp)) + [0]
print(ans)
main()
|
p03780
|
import bisect
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
end = bisect.bisect_right(a, k)
a = a[0:end]
n = len(a)
#rightの部分和の集合を予め求めておく
right_subset_sum = [None] * (n+1)
right_subset_sum[-1] = set([0])
for i in range(n)[::-1]:
a_i = a[i]
tmp_set = set([])
if a_i <= k:
tmp_set.add(a_i)
for j in right_subset_sum[i+1]:
if j + a_i <= k:
tmp_set.add(j + a_i)
right_subset_sum[i] = right_subset_sum[i+1] | tmp_set
ans = 0
left_subset_sum = set([0])
for i in range(n):
a_i= a[i]
li = sorted(list(right_subset_sum[i+1]))
for num in left_subset_sum:
left = k - a_i - num
right = k - num
if bisect.bisect_left(li, right) - bisect.bisect_left(li, left) > 0:
break
else:
ans += 1
#leftの集合にa_iを含めた部分和を追加する
tmp_set = set([])
if a_i <= k:
tmp_set.add(a_i)
for j in left_subset_sum:
if j + a_i <= k:
tmp_set.add(j + a_i)
left_subset_sum = left_subset_sum | tmp_set
print(ans)
|
import bisect
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
end = bisect.bisect_right(a, k)
a = a[0:end]
n = len(a)
def subset_sum(mid):
if a[mid] >= k:
return True
dp = [False]*k
dp[0] = True
for i in range(n):
if i == mid:
continue
for j in range(k)[::-1]:
if j - a[i] < 0:
break
else:
dp[j] |= dp[j - a[i]]
return sum(dp[k-a[mid]:])
ok = -1
ng = n
while abs(ng - ok) > 1:
mid = (ok + ng) // 2
if subset_sum(mid):
ng = mid
else:
ok = mid
print(ng)
|
p03780
|
import sys
input = sys.stdin.buffer.readline
def solve(mid):
"""のぞいてもいいカードならTrueを返す"""
dp = [False] * (k + 1)
dp[0] = True
if k <= a[mid]:
return False
for i, weight in enumerate(a):
if i == mid:
continue
for w in range(k + 1)[::-1]:
if w - weight < 0:
continue
dp[w] |= dp[w - weight]
return True not in dp[k - a[mid]:k]
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ok = 0
ng = n
if not solve(ok):
print((0))
exit()
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if solve(mid):
ok = mid
else:
ng = mid
print((ok + 1))
|
import sys
input = sys.stdin.buffer.readline
def solve(mid):
"""のぞいてもいいカードならTrueを返す"""
dp = 1
mask = (1 << k) - 1
if k <= a[mid]:
return False
for i, weight in enumerate(a):
if i == mid:
continue
dp |= dp << min(weight, k + 10)
dp &= mask
return dp >> (k - a[mid]) == 0
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ok = 0
ng = n
if not solve(ok):
print((0))
exit()
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if solve(mid):
ok = mid
else:
ng = mid
print((ok + 1))
|
p03780
|
def main():
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [i for i in a if i <k]
a.sort()
n = len(a)
DP1 = [[False]*(k+1)]
DP1[0][0] = True
DP2 = [[False]*(k+1)]
DP2[0][0] = True
b = a[::-1]
for i in range(n):
DP1.append(DP1[i][:])
DP2.append(DP2[i][:])
for j in range(k+1):
if DP1[i][j] and a[i]+j <= k:
DP1[i+1][a[i]+j] = True
if DP2[i][j] and b[i]+j <= k:
DP2[i+1][b[i]+j] = True
for i in range(n+1):
q = [0]
for j in range(k+1):
q.append(q[-1]+int(DP2[i][j]))
DP2[i] = q
ans = 0
for i in range(n):
use = False
for j in range(k+1):
if not DP1[i][j]:
continue
left = max(0, k-a[i]-j)
right = k-j
if DP2[n-i-1][right] - DP2[n-i-1][left]:
use = True
break
if not use:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
def main():
def check(m):
DP = [False]*(k+1)
DP[0] = True
for i in range(n):
if i == m:
continue
for j in reversed(list(range(k+1-a[i]))):
DP[a[i]+j] = DP[a[i]+j] or DP[j]
return any(DP[i] for i in range(k-a[m], k))
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [i for i in a if i <k]
a.sort()
n = len(a)
left = -1
right = n
while right-left > 1:
mid = (right+left)//2
if check(mid):
right = mid
else:
left = mid
print(right)
main()
|
p03780
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
ans = N
for i in range(N-1, -1, -1) :
psum = 0
for j in range(i, -1, -1) :
if psum+a[j] < K :
psum += a[j]
else :
ans = min(ans, j)
print(ans)
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
ans = N
psum = 0
for i in range(N-1, -1, -1) :
if psum+a[i] < K :
psum += a[i]
else :
ans = min(ans, i)
print(ans)
|
p03780
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
l = 0
r = n
while l < r:
m = (l + r) // 2
if a[m] >= k:
r = m
continue
dp = [[0 for _ in range(k)] for _ in range(n)]
dp[0][0] = 1
t = 1
check = 0
for i in range(n):
if i == m:
continue
for j in range(k - a[i]):
if dp[t - 1][j] == 1:
dp[t][j] = 1
temp = j + a[i]
if k - a[m] <= temp < k:
check = 1
break
elif temp < k - a[m]:
dp[t][temp] = 1
if check == 1:
break
t += 1
if check == 0:
l = m + 1
else:
r = m
print(l)
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
l = 0
r = n
while l < r:
m = (l + r) // 2
if a[m] >= k:
r = m
continue
dp = set()
dp.add(0)
check = 0
for i in range(n):
next = set()
if i == m:
continue
for x in dp:
temp = x + a[i]
if k - a[m] <= temp < k:
check = 1
break
elif temp < k - a[m]:
next.add(temp)
if check == 1:
break
else:
dp = dp | next
if check == 0:
l = m + 1
else:
r = m
print(l)
|
p03780
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
l = 0
r = n
while l < r:
m = (l + r) // 2
if a[m] >= k:
r = m
continue
dp = [set() for _ in range(n + 1)]
dp[0].add(0)
check = 0
for i in range(n):
if i == m:
dp[i + 1] = dp[i]
continue
for x in dp[i]:
dp[i + 1].add(x)
temp = x + a[i]
if k - a[m] <= temp < k:
check = 1
break
elif temp < k - a[m]:
dp[i + 1].add(temp)
if check == 1:
break
if check == 0:
l = m + 1
else:
r = m
print(l)
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
temp = 0
ans = 0
for x in a:
if temp + x < k:
temp += x
ans += 1
else:
ans = 0
print(ans)
|
p03780
|
from itertools import accumulate
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
acc = list(accumulate(a))
def maxsum(ls,k):
l = len(ls)
if l==0:
return 0
dp = [0 for i in range(l+1)]
dp[0] = 1
for i in range(1,l+1):
dp[i] = dp[i-1]|(dp[i-1]<<ls[i-1])
for b in range(k-1,-1,-1):
if dp[l] & 1<<b:
return b
for i in range(n):
if a[i]>=k:
a = a[:i]
break
n = len(a)
if acc[n-1] < k:
print(n)
exit()
sepa=[]
for i in range(n-1):
if acc[i]<a[i+1]:
sepa.append(i)
m=len(sepa)
if m==0:
print((0))
exit()
lf = 0
r = m-1
while lf<r:
mid = (lf+r)//2
x=sepa[mid]
sumx = acc[x]
if maxsum(a[x+1:],k)+sumx >= k:
r = mid
else:
lf = mid+1
if r==0:
t=sepa[0]
if maxsum(a[t+1:],k)+acc[t]>=k:
print((0))
else:
print((sepa[r]+1))
else:
print((sepa[r]+1))
|
from itertools import accumulate
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
acc = list(accumulate(a))
def maxsum(ls,k):
l = len(ls)
if l==0:
return 0
dp = [0 for i in range(l+1)]
dp[0] = 1
for i in range(1,l+1):
dp[i] = (dp[i-1]|(dp[i-1]<<ls[i-1]))&((1<<k)-1)
for b in range(k-1,-1,-1):
if dp[l] & 1<<b:
return b
for i in range(n):
if a[i]>=k:
a = a[:i]
break
n = len(a)
if acc[n-1] < k:
print(n)
exit()
sepa=[]
for i in range(n-1):
if acc[i]<a[i+1]:
sepa.append(i)
m=len(sepa)
if m==0:
print((0))
exit()
lf = 0
r = m-1
while lf<r:
mid = (lf+r)//2
x=sepa[mid]
sumx = acc[x]
if maxsum(a[x+1:],k)+sumx >= k:
r = mid
else:
lf = mid+1
if r==0:
t=sepa[0]
if maxsum(a[t+1:],k)+acc[t]>=k:
print((0))
else:
print((sepa[r]+1))
else:
print((sepa[r]+1))
|
p03780
|
import sys
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
#A = [i for i in range(1,2)] + [i for i in range(2,1001)] * 4
A.sort()
DP = [0 for k in range(K+1)] #和がkとなる部分集合の数
DP[0] = 1
for a in A:
for k in range(K-a,-1,-1):
DP[k+a] += DP[k]
"""
for k in range(1,2*K+1): #累積和へ変換
DP[k] += DP[k-1]
print(DP)
"""
"""
if sum(DP[0:K]) == 2**N:
print(N)
sys.exit()
"""
#print(DP)
ans = 0
DP_rev = [0 for _ in range(K)] #戻すDP!!!
flag = True
for a in A:
if not flag: break
for i in range(K):
DP_rev[i] = DP[i]
if i-a >= 0:
DP_rev[i] -= DP_rev[i-a]
if i >= K-a and DP_rev[i] > 0:
flag = False
break
if flag:
ans += 1
#print(a, DP_rev)
print(ans)
|
import sys
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
#A = [i for i in range(1,2)] + [i for i in range(2,1001)] * 4
A.sort()
DP = [0 for k in range(K+1)] #和がkとなる部分集合の数
DP[0] = 1
for a in A:
for k in range(K-a,-1,-1):
DP[k+a] += DP[k]
"""
for k in range(1,2*K+1): #累積和へ変換
DP[k] += DP[k-1]
print(DP)
"""
"""
if sum(DP[0:K]) == 2**N:
print(N)
sys.exit()
"""
#print(DP)
def det(t):
a = A[t]
if a >= K:
return False
DP_rev = [0 for _ in range(K)] #戻すDP!!!
ans = True
for i in range(K):
DP_rev[i] = DP[i]
if i-a >= 0:
DP_rev[i] -= DP_rev[i-a]
if i >= K-a and DP_rev[i] > 0:
ans = False
break
del DP_rev
return ans
lt = 0
rt = N-1
if not det(lt):
print((0))
sys.exit()
if det(rt):
print((rt+1))
sys.exit()
while rt - lt > 1:
ct = (lt + rt) // 2
if det(ct):
lt = ct
else:
rt = ct
print(rt)
|
p03780
|
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, K: int, a: "List[int]"):
a.sort()
if a[0] >= K:
print((0))
return
a = [x for x in a if x < K]
N = len(a)
ng = -1
ok = N
while abs(ok - ng) > 1:
j = (ok + ng) // 2
# print(A)
DP = [[False]*K for _ in range(N)]
DP[0][a[0 if j != 0 else 1]] = True
for i in range(1, N):
for k in range(K):
DP[i][k] = DP[i-1][k] or DP[i][k]
if i != j and k < K-a[i]:
DP[i][k+a[i]] = DP[i-1][k]
if any(DP[-1][max(K-a[j], 0):]):
ok = j
else:
ng = j
print(ok)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, K, a)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, K: int, a: "List[int]"):
a.sort()
if a[0] >= K:
print((0))
return
a = [x for x in a if x < K]
N = len(a)
ng = -1
ok = N
while abs(ok - ng) > 1:
j = (ok + ng) // 2
# print(A)
DP = [False]*K
DP[a[not j]] = True
for i in range(1, N):
if i == j:
continue
for k in range(K-a[i]-1, -1, -1):
DP[k+a[i]] = DP[k] or DP[k+a[i]]
if any(DP[max(K-a[j], 0):]):
ok = j
else:
ng = j
print(ok)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, K, a)
if __name__ == '__main__':
main()
|
p03780
|
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
import math
sys.setrecursionlimit(1000000)
MOD = 10 ** 30 + 7
N, M = list(map(int, input().split()))
s = input()
p27 = [1 for i in range(500000)]
for i in range(1, 500000):
p27[i] = p27[i - 1] * 27
p27[i] %= MOD
m = {}
P = (ord(s[0]) - ord('a') + 1)
l = 0
r = 0
for loop in range(M):
S = input()
if S == 'L++':
P -= (ord(s[l]) - ord('a') + 1) * p27[r - l]
P %= MOD
l += 1
elif S == 'L--':
l -= 1
P += (ord(s[l]) - ord('a') + 1) * p27[r - l]
P %= MOD
elif S == 'R++':
r += 1
P *= 27
P += (ord(s[r]) - ord('a') + 1)
P %= MOD
elif S == 'R--':
P -= (ord(s[r]) - ord('a') + 1)
P %= MOD
for i in range(27):
if (P + MOD * i) % 27 == 0:
P = (P + MOD * i) / 27
break
r -= 1
#print s[l:r + 1], P
m[P] = 1
print(len(m))
|
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
import math
sys.setrecursionlimit(1000000)
MOD = 10 ** 30 + 7
N, M = list(map(int, input().split()))
s = input()
p27 = [1 for i in range(500000)]
for i in range(1, 500000):
p27[i] = p27[i - 1] * 27
p27[i] %= MOD
m = {}
P = (ord(s[0]) - ord('a') + 1)
l = 0
r = 0
for loop in range(M):
S = input()
if S == 'L++':
P -= (ord(s[l]) - ord('a') + 1) * p27[r - l]
P %= MOD
l += 1
elif S == 'L--':
l -= 1
P += (ord(s[l]) - ord('a') + 1) * p27[r - l]
P %= MOD
elif S == 'R++':
r += 1
P *= 27
P += (ord(s[r]) - ord('a') + 1)
P %= MOD
elif S == 'R--':
P -= (ord(s[r]) - ord('a') + 1)
P %= MOD
for i in range(27):
if (P + MOD * i) % 27 == 0:
P = (P + MOD * i) / 27
break
r -= 1
m[P] = 1
print(len(m))
|
p01558
|
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
n,d=nii()
print(((n+d*2+1-1)//(d*2+1)))
|
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
n,d=nii()
num=d*2+1
print(((n+num-1)//num))
|
p02970
|
import math
n,d=list(map(int,input().split()))
a=n/(2*d+1)
print((math.ceil(a)))
|
n,d=list(map(int,input().split()))
a=n/(2*d+1)
import math
b=math.ceil(a)
print(b)
|
p02970
|
n,d=list(map(int,input().split()))
p=0
while n>0:
n-=(d*2+1)
p+=1
print((str(p)))
|
def people(n):
p=0
while n>0:
n-=(d*2+1)
p+=1
return p
def main():
print((people(n)))
if __name__=='__main__':
n,d=list(map(int,input().split()))
main()
|
p02970
|
a,b=list(map(int,input().split()))
print(((a-1)//(2*b+1)+1))
|
n,d=list(map(int,input().split()))
d=2*d+1
print((0--n//d))
|
p02970
|
# 2019-11-15 14:12:24(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, d = [int(x) for x in sys.stdin.readline().split()]
ran = 1 + d * 2
number = math.ceil(n / ran)
print(number)
if __name__ == "__main__":
main()
|
import sys
n, d = list(map(int, sys.stdin.readline().split()))
def main():
c = 2*d + 1
return (n + c - 1) // c
if __name__ == '__main__':
ans = main()
print(ans)
|
p02970
|
N, D = list(map(int, input().split()))
print(((N + 2 * D)//(2 *D + 1)))
|
N, D = list(map(int, input().split()))
tmp = 2 * D + 1
print(((N + tmp - 1) // tmp))
|
p02970
|
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N, D = MI()
ans = 0
while N > 0:
N -= 1 + 2 * D
ans += 1
print(ans)
if __name__ == '__main__':
solve()
|
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N, D = MI()
print(((N+2*D)//(1+2*D)))
if __name__ == '__main__':
solve()
|
p02970
|
import math
n,d=list(map(int,input().split()))
print((math.ceil(n/(d*2+1))))
|
n,d=list(map(int,input().split()))
if n%(d*2+1):
print((n//(d*2+1)+1))
else:
print((n//(d*2+1)))
|
p02970
|
n, d = list(map(int, input().split()))
x = 2*d+1 #監視可能範囲
if n%x == 0:
print((n//x))
else:
print((n//x + 1))
|
n, d = list(map(int, input().split()))
dist = 2 * d + 1
if n%dist != 0:
print((n//dist + 1))
else:
print((n//dist))
|
p02970
|
n, d = list(map(int, input().split()))
ans = 0
n -= (d+1) # 一人目の立つ場所
ans += 1
if n <= 0:
print(ans)
exit()
while True:
if (n - d) <= 0:
break
else:
n -= (2*d + 1)
ans += 1
if n <= 0:
break
print(ans)
|
import math
N, D = list(map(int, input().split()))
print((math.ceil(N/(2*D+1))))
|
p02970
|
n,d=list(map(int,input().split()))
l=d+1
r=n-d
if l==r:
print((1))
else:
ans=1
k=l
while k<r:
k+=2*d+1
ans+=1
print(ans)
|
n,d=list(map(int,input().split()))
print(((n+2*d)//(2*d+1)))
|
p02970
|
import math
n, d = list(map(int, input().split()))
cnt = 0
print((math.ceil(n/(2*d+1))))
|
import math
n, d = list(map(int, input().split()))
print((math.ceil(n/(2*d+1))))
|
p02970
|
n,d=list(map(int,input().split()))
print((n//(2*d+1)+(n%(2*d+1)>0)))
|
n,d=list(map(int,input().split()))
print((n//(d+d+1)+(n%(d+d+1)>0)))
|
p02970
|
from decimal import Decimal,ROUND_HALF_UP
n,d = list(map(int,input().split()))
x = (n+d*2)//(d*2+1)
print(x)
|
n,d = list(map(int,input().split()))
x = (n+d*2)//(d*2+1)
print(x)
|
p02970
|
N, D = list(map(int, input().split()))
ans = 0
i = D+1
while True:
ans += 1
if D+i >= N:
break
i += 2*D + 1
print(ans)
|
N, D = list(map(int, input().split()))
if N % (2*D+1) == 0:
print((N // (2*D+1)))
else:
print((int(N // (2*D+1)) + 1))
|
p02970
|
# B - Golden Apple
from math import ceil
N, D = list(map(int, input().split()))
print((ceil(N/(2*D+1))))
|
# B - Golden Apple
N, D = list(map(int, input().split()))
# print(int((N+2*D)/(2*D+1)))
print(((N+2*D)//(2*D+1)))
|
p02970
|
import math
N, D = list(map(int, input().split()))
ob_range = 2 * D + 1
print((math.ceil(N / ob_range)))
|
import math
N, D = list(map(int, input().split()))
print((math.ceil(N / (2 * D + 1))))
|
p02970
|
N, Z, W = list(map(int, input().split()))
*A, = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**6)
memo = {}
def dfs(i, turn):
if (i, turn) in memo:
return memo[i, turn]
if turn == 0:
# X
if i == 0:
res = abs(W - A[-1])
else:
res = abs(A[i-1] - A[-1])
for j in range(i+1, N):
res = max(res, dfs(j, 1))
else:
# Y
if i == 0:
res = abs(Z - A[-1])
else:
res = abs(A[i-1] - A[-1])
for j in range(i+1, N):
res = min(res, dfs(j, 0))
memo[i, turn] = res
return res
print((dfs(0, 0)))
|
N, Z, W = list(map(int, input().split()))
*A, = list(map(int, input().split()))
if N == 1:
print((abs(A[0] - W)))
else:
print((max(abs(A[-1] - W), abs(A[-2] - A[-1]))))
|
p03552
|
# どちらか必ずa_Nのカードを持つ
import sys
from functools import lru_cache
sys.setrecursionlimit(4000)
N,Z,W = list(map(int,input().split()))
A = list(map(int,input().split()))
A.reverse()
# turn: true->X, false->Y
BOTTOM = A[0]
@lru_cache(maxsize=2000000)
def rec_X(i,y):
return max(abs(BOTTOM-y),max((rec_Y(j,A[j]) for j in range(1,i)), default=0))
@lru_cache(maxsize=2000000)
def rec_Y(i,x):
return min(abs(BOTTOM-x),min((rec_X(j,A[j]) for j in range(1,i)), default=float('inf')))
print((rec_X(N,W)))
|
# どちらか必ずa_Nのカードを持つ
N,Z,W = list(map(int,input().split()))
A = list(map(int,input().split()))
A.reverse()
A.append(W)
BOTTOM = A[0]
M = float('inf')
m = 0
for a in A[1:]:
x = abs(BOTTOM-a)
t = max(x,m)
s = min(x,M)
M = min(M,t)
m = max(m,s)
print(t)
|
p03552
|
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def score(i,x,y,turn):
if i==n-1:
return abs(x-y)
if (i,x,y,turn) in memo:
return memo[(i,x,y,turn)]
if turn:
res=0
for j in range(i+1,n):
res=max(res,score(j,aa[j],y,not turn))
else:
res=10**16
for j in range(i+1,n):
res=min(res,score(j,x,aa[j],not turn))
memo[(i,x,y,turn)]=res
return res
n,z,w=map(int, input().split())
aa=list(map(int, input().split()))
memo={}
print(score(-1,z,w,True))
main()
|
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
n, z, w = MI()
aa = LI()
if n - 2 >= 0:
print(max(abs(aa[n - 1] - aa[n - 2]), abs(aa[n - 1] - w)))
else:
print(abs(aa[n - 1] - w))
main()
|
p03552
|
import sys
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
inf = 10 ** 9 + 7
sys.setrecursionlimit(inf)
def calc(a, b):
return abs(a - b)
def alphaBeta(X, Y, turn, depth, alpha, beta):
if depth == N:
return calc(X, Y)
if turn:
for i in range(depth, N):
alpha = max(alpha, alphaBeta(A[i], Y, False, i+1, alpha, beta))
if alpha >= beta:
break
return alpha
else:
for i in range(depth, N):
beta = min(beta, alphaBeta(X, A[i], True, i+1, alpha, beta))
if alpha >= beta:
break
return beta
print((alphaBeta(Z, W, True, 0, -1, inf)))
|
import sys
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = abs(A[-1] - W)
if N != 1:
ans = max(ans, abs(A[-1] - A[-2]))
print(ans)
|
p03552
|
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
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
#A
def A():
n,k = LI()
a = LI()
d = defaultdict(lambda:0)
for i in a:
d[i] += 1
d = list(d.values())
d.sort()
ans = 0
for i in range(len(d)-k):
ans += d[i]
print(ans)
return
#B
def B():
n,z,w = LI()
a = LI()
if n == 1:
print((abs(a[0]-w)))
return
ans = max(abs(a[-1]-w),abs(a[-2]-a[-1]))
print(ans)
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#Solve
if __name__ == "__main__":
B()
|
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
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(): return list(sys.stdin.readline())[:-1]
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():
n,x,y = LI()
a = LI()
ans = abs(a[-1]-y)
if n > 1:
ans = max(ans,abs(a[-2]-a[-1]))
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
|
p03552
|
import sys
sys.setrecursionlimit(10 ** 6)
def dfs(x, y, memo, A, N, Z, W):
X = Z if x == 0 else A[x - 1]
Y = W if y == 0 else A[y - 1]
if memo[x][y] >= 0:
return memo[x][y]
else:
if x == N or y == N:
rst = abs(X - Y)
else:
if x <= y:
rst = 0
for i in range(y + 1, N + 1):
rst = max(rst, dfs(i, y, memo, A, N, Z, W))
else:
rst = 10 ** 10
for i in range(x + 1, N + 1):
rst = min(rst, dfs(x, i, memo, A, N, Z, W))
memo[x][y] = rst
return rst
def main():
# import sys
# readline = sys.stdin.readline
# readlines = sys.stdin.readlines
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
memo = [[-1] * (N + 1) for _ in range(N + 1)]
ans = dfs(0, 0, memo, A, N, Z, W)
print(ans)
if __name__ == "__main__":
main()
|
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [[-1] * (N + 1) for _ in range(N + 1)]
for x in range(N, -1, -1):
for y in range(N, -1, -1):
if x == y:
continue
X = Z if x == 0 else A[x - 1]
Y = W if y == 0 else A[y - 1]
if x == N or y == N:
rst = abs(X - Y)
elif x - y == 1:
rst = 10 ** 10
for j in range(N, x, -1):
rst = min(rst, dp[x][j])
elif x - y > 1:
rst = dp[x][y + 1]
elif y - x == 1:
rst = 0
for i in range(N, y, -1):
rst = max(rst, dp[i][y])
elif y - x > 1:
rst = dp[x + 1][y]
else:
raise Exception
dp[x][y] = rst
ans = 0
for i in range(N):
ans = max(ans, dp[i + 1][0])
print(ans)
|
p03552
|
N, C = list(map(int, input().split()))
programs = [[0 for _ in range(C)] for _ in range(2*10**5)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
for i in range(2*s-1, 2*t):
programs[i][c-1] = 1
ret = 0
for i in range(2*10**5):
ret = max(ret, sum(programs[i]))
print(ret)
|
N, C = list(map(int, input().split()))
programs = [[0 for _ in range(C)] for _ in range(10**5)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
for i in range(s-1, t):
programs[i][c-1] = 1
ret = 0
for i in range(10**5):
ret = max(ret, sum(programs[i]))
print(ret)
|
p03504
|
def main():
N,C = list(map(int, input().split()))
# 各時間各チャンネルで録画機が動いてるかどうか
R = [[0]*(10**5) for _ in range(C)]
for _ in range(N):
s,t,c = list(map(int, input().split()))
#チャンネルｃをｓからｔまで録画、ｓの0.5秒前から録画機を使うのでs-1始まりにする
R[c-1][s-1:t] = [1] * (t-(s-1))
ans = 0
for t in range(10**5):
cnt = 0
#時刻ごとにそれぞれのチャンネルで録画機を使ってるかどうか数え上げる
for ch in range(C):
if R[ch][t] == 1: cnt += 1
ans = max(ans, cnt)
print(ans)
if __name__ == "__main__":
main()
|
def main():
N,C = list(map(int, input().split()))
# 各時間各チャンネルで録画機が動いてるかどうか
R = [[0]*(10**5) for _ in range(C)]
for _ in range(N):
s,t,c = list(map(int, input().split()))
#チャンネルｃをｓからｔまで録画、ｓの0.5秒前から録画機を使うのでs-1始まりにする
R[c-1][s-1:t] = [1] * (t-(s-1))
ans = max(list(map(sum, list(zip(*R)))))
"""
ans = 0
for t in range(10**5):
cnt = 0
#時刻ごとにそれぞれのチャンネルで録画機を使ってるかどうか数え上げる
for ch in range(C):
if R[ch][t] == 1: cnt += 1
ans = max(ans, cnt)
"""
print(ans)
if __name__ == "__main__":
main()
|
p03504
|
N,C = list(map(int,input().split()))
tv_times = [[int(j) for j in input().split()] for i in range(N)]
channells = {}
for i in range(C+1):
channells[i] = []
max_end = -1
for i in range(N):
s,g,c = tv_times[i]
max_end = max(max_end,g)
channells[c] += [s,g]
tv_times = []
f = [0 for i in range(max_end+1)]
for cha in list(channells.keys()):
remove_list = []
time = channells[cha]
time.sort()
for i in range(1,len(time)-1):
if time[i] == time[i+1]:
remove_list.append(time[i])
for i in range(len(remove_list)):
for j in range(2):
time.remove(remove_list[i])
for i in range(len(time)//2):
f[max(time[2*i]-1,0)] += 1
f[time[2*i+1]] -= 1
ans = -1
for i in range(1,max_end+1):
f[i] += f[i-1]
if ans < f[i]:
ans = f[i]
# print(f)
print(ans)
|
N,C = list(map(int,input().split()))
tv_times = [[int(j) for j in input().split()] for i in range(N)]
channells = {}
for i in range(C+1):
channells[i] = []
max_end = -1
for i in range(N):
s,g,c = tv_times[i]
max_end = max(max_end,g)
channells[c] += [s,g]
tv_times = []
f = [0 for i in range(max_end+1)]
for cha in list(channells.keys()):
remove_list = []
time = channells[cha]
time.sort()
for i in range(1,len(time)-1):
if time[i] == time[i+1]:
remove_list.append(time[i])
time = list(set(time)-set(remove_list))
time.sort()
for i in range(len(time)//2):
f[max(time[2*i]-1,0)] += 1
f[time[2*i+1]] -= 1
ans = -1
for i in range(1,max_end+1):
f[i] += f[i-1]
if ans < f[i]:
ans = f[i]
print(ans)
|
p03504
|
N, C = list(map(int, input().split()))
TV = [[0]*(2*10**5) for i in range(C)]
for i in range(N):
s, t, c = list(map(int, input().split()))
TV[c-1][2*s-2] += 1
TV[c-1][2*t-1] -= 1
for i in range(C):
for j in range(1, 2*10**5):
TV[i][j] = TV[i][j]+TV[i][j-1]
for i in range(C):
for j in range(1, 2*10**5):
TV[i][j] = min(1, TV[i][j])
ans = 0
for i in range(2*10**5):
tmp = 0
for j in range(C):
tmp += TV[j][i]
ans = max(ans, tmp)
print(ans)
|
from itertools import accumulate
N, C = list(map(int, input().split()))
G = [[0] * (10 ** 5 + 1) for i in range(C)]
for i in range(N):
s, t, c = list(map(int, input().split()))
c = c - 1
G[c][s - 1] += 1
G[c][t] -= 1
for i in range(C):
G[i] = list(accumulate(G[i]))
ans = 0
for i in range(10 ** 5 + 1):
tmp = 0
for c in range(C):
tmp += min(1, G[c][i])
ans = max(ans, tmp)
print(ans)
|
p03504
|
n, c = list(map(int, input().split()))
stc = []
for _ in range(n):
stc.append(tuple(map(int, input().split())))
sm = [0 for _ in range(2 * (pow(10, 5) + 1))]
for _c in range(c):
tt = [0 for _ in range(2 * (pow(10, 5) + 1))]
for s, t, c in stc:
if c == _c + 1:
tt[s * 2 - 1] += 1
tt[t * 2] -= 1
for i in range(1, len(tt)):
tt[i] += tt[i-1]
for i in range(len(sm)):
if tt[i] > 0:
sm[i] += 1
print((max(sm)))
|
import sys
input = sys.stdin.readline
from heapq import heappop, heappush
def main():
n, c = list(map(int, input().split()))
stc = []
for _ in range(n):
stc.append(tuple(map(int, input().split())))
stc = list(sorted(stc, key=lambda x: (x[2], x[0])))
restc = []
prev = stc[0]
for _stc in stc[1:]:
if prev[2] == _stc[2] and prev[1] == _stc[0]:
prev = (prev[0], _stc[1], prev[2])
else:
restc.append(prev)
prev = _stc
restc.append(prev)
ans = 0
th = []
for _stc in sorted(restc):
if not th:
heappush(th, _stc[1])
if ans == 0:
ans = 1
else:
_th = heappop(th)
if _th < _stc[0]:
heappush(th, _stc[1])
else:
heappush(th, _th)
heappush(th, _stc[1])
ans = max(ans, len(th))
print(ans)
if __name__ == '__main__':
main()
|
p03504
|
def main():
from itertools import accumulate
n, c, *stc = list(map(int, open(0).read().split()))
table = [0] * 2 * (10 ** 5 + 1)
m = list(zip(stc[::3], stc[1::3], stc[2::3]))
m.sort(key=lambda a: (a[2], a[0], a[1]))
ch_ = 0
t_ = 0
for s, t, ch in m:
if ch != ch_:
ch_ = ch
t_ = 0
if t_ == 2 * s:
table[t_ + 1] += 1
else:
table[2 * s - 1] += 1
table[2 * t + 1] -= 1
t_ = 2 * t
*x, = accumulate(table)
ans = max(x)
print(ans)
if __name__ == '__main__':
main()
|
def main():
from itertools import accumulate
n, c, *stc = list(map(int, open(0).read().split()))
table = [0] * (10 ** 5 + 2)
m = list(zip(stc[::3], stc[1::3], stc[2::3]))
m.sort(key=lambda a: (a[2], a[0], a[1]))
ch_ = 0
t_ = 0
for s, t, ch in m:
if ch != ch_:
ch_ = ch
t_ = 0
if t_ == s:
table[t_ + 1] += 1
else:
table[s] += 1
table[t + 1] -= 1
t_ = t
*x, = accumulate(table)
ans = max(x)
print(ans)
if __name__ == '__main__':
main()
|
p03504
|
def main():
from itertools import accumulate
n, c, *stc = list(map(int, open(0).read().split()))
table = [0] * (10 ** 5 + 2)
m = list(zip(stc[::3], stc[1::3], stc[2::3]))
m.sort(key=lambda a: (a[2], a[0], a[1]))
ch_ = 0
t_ = 0
for s, t, ch in m:
if ch != ch_:
ch_ = ch
t_ = 0
if t_ == s:
table[t_ + 1] += 1
else:
table[s] += 1
table[t + 1] -= 1
t_ = t
*x, = accumulate(table)
ans = max(x)
print(ans)
if __name__ == '__main__':
main()
|
def main():
from itertools import accumulate
n, c, *stc = list(map(int, open(0).read().split()))
table = [0] * (10 ** 5 + 2)
m = sorted(list(zip(*[iter(stc)] * 3)), key=lambda a: (a[2], a[0], a[1]))
ch_ = 0
t_ = 0
for s, t, ch in m:
if ch != ch_:
ch_ = ch
t_ = 0
if t_ == s:
table[t_ + 1] += 1
else:
table[s] += 1
table[t + 1] -= 1
t_ = t
*x, = accumulate(table)
ans = max(x)
print(ans)
if __name__ == '__main__':
main()
|
p03504
|
def main():
from itertools import accumulate
n, c, *stc = list(map(int, open(0).read().split()))
table = [0] * (10 ** 5 + 2)
m = sorted(list(zip(*[iter(stc)] * 3)), key=lambda a: (a[2], a[0], a[1]))
ch_ = 0
t_ = 0
for s, t, ch in m:
if ch != ch_:
ch_ = ch
t_ = 0
if t_ == s:
table[t_ + 1] += 1
else:
table[s] += 1
table[t + 1] -= 1
t_ = t
*x, = accumulate(table)
ans = max(x)
print(ans)
if __name__ == '__main__':
main()
|
def main():
from itertools import accumulate
n, c, *stc = list(map(int, open(0).read().split()))
table = [0] * (10 ** 5 + 2)
m = sorted(list(zip(*[iter(stc)] * 3)), key=lambda a: (a[2], a[0]))
ch_ = 0
t_ = 0
for s, t, ch in m:
if ch != ch_:
ch_ = ch
t_ = 0
if t_ == s:
table[t_ + 1] += 1
else:
table[s] += 1
table[t + 1] -= 1
t_ = t
*x, = accumulate(table)
ans = max(x)
print(ans)
if __name__ == '__main__':
main()
|
p03504
|
n, c = list(map(int, input().split()))
cnt = [[0 for _ in range(c)] for j in range(10 ** 5 + 1)]
cnt_sum = [0] * (10 ** 5 + 1)
for _ in range(n):
s, t, _c = list(map(int, input().split()))
cnt[s - 1][_c - 1] += 1
cnt[t][_c - 1] -= 1
for i in range(1, 10 ** 5 + 1):
for j in range(c):
cnt[i][j] += cnt[i - 1][j]
for i in range(10 ** 5 + 1):
for j in range(c):
cnt_sum[i] += (cnt[i][j] >= 1)
print((max(cnt_sum)))
|
n, c = list(map(int, input().split()))
cnt = [[0 for _ in range(10 ** 5 + 1)] for _ in range(c)]
for _ in range(n):
s, t, _c = list(map(int, input().split()))
for j in range(s, t + 1):
cnt[_c - 1][j] = 1
ans = 0
for i in range(10 ** 5 + 1):
ans = max(ans, sum(cnt[j][i] for j in range(c)))
print(ans)
|
p03504
|
N,C=list(map(int,input().split()))
from collections import defaultdict
cannel={i:[] for i in range(1,1+C)}
check=[tuple(map(int,input().split())) for i in range(N)]
check.sort(key=lambda x:x[0])
for x in check:
s,t,c=x
if cannel[c]==[]:
cannel[c].append((max(0,s-1),t))
elif s-cannel[c][-1][1]<=1:
cannel[c][-1]=(cannel[c][-1][0],t)
else:
cannel[c].append((max(0,s-1),t))
start=defaultdict(int)
end=defaultdict(int)
for c in range(1,1+C):
for x in cannel[c]:
start[x[0]]+=1
end[x[1]]+=1
ans=0
now=0
for i in range(10**5+1):
now+=start[i]-end[i]
ans=max(ans,now)
print(ans)
|
N,C=list(map(int,input().split()))
from collections import defaultdict
Cbef=defaultdict(int)
time=defaultdict(int)
TV=[tuple(map(int,input().split())) for i in range(N)]
TV.sort(key=lambda x:x[0])
for s,t,c in TV:
if Cbef[c]==s:
time[s]+=1
time[t]-=1
Cbef[c]=t
else:
time[s-1]+=1
time[t]-=1
Cbef[c]=t
ans=0
now=time[0]
ans=now
for i in range(1,10**5+1):
now+=time[i]
ans=max(ans,now)
print(ans)
|
p03504
|
n, c = list(map(int, input().split()))
r = [[0 for i in range(c)] for j in range(100000)] # テレビ局の番組表
for dummy in range(n): # 入力
s, t, c = list(map(int, input().split()))
for j in range(s - 1, t):
r[j][c - 1] = 1 # 放送中なら1
ans = 0
for i in range(100000):
if sum(r[i]) > ans:
ans = sum(r[i]) # 同時に放送されている番組の最大数
print(ans)
|
N, C = list(map(int, input().split()))
r = [[0] * C for _ in range(10 ** 5)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
for i in range(s - 1, t):
r[i][c - 1] = 1
ans = 0
for t in r:
sum_t = sum(t)
if sum_t > ans:
ans = sum_t
print(ans)
|
p03504
|
#!/usr/bin/env python3
#ABC80 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
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,C = LI()
stc = [LI() for _ in range(n)]
L = []
for i in range(C):
lst = []
for j in range(n):
s,t,c = stc[j]
if i+1 == c:
lst.append([s,t])
lst.sort(key = itemgetter(0))
lst2 = []
j = 0
while j < len(lst):
if j < len(lst)-1:
if lst[j][1] == lst[j+1][0]:
lst2.append((lst[j][0],lst[j+1][1]))
j += 2
continue
lst2.append(tuple(lst[j]))
j += 1
L.append(lst2)
x = [[0]*100002 for _ in range(C)]
for i in range(C):
for j,k in L[i]:
x[i][j] += 1
x[i][k+1] -= 1
x[i] = list(accumulate(x[i]))
ans = 0
for i in range(1,10**5+1):
s = 0
for j in range(C):
if x[j][i] == 1:
s += 1
ans = max(ans,s)
print(ans)
|
#!/usr/bin/env python3
#ABC80 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
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,C = LI()
cha = [[] for _ in range(C)]
ans = 0
lst = [0]*(10**5+2)
for _ in range(n):
s,t,c = LI()
cha[c-1].append([s,t])
for i in range(C):
if len(cha[i]) == 0:
continue
cha[i].sort(key = itemgetter(0))
s,t = cha[i][0]
tmp = []
for j in range(1,len(cha[i])):
if t == cha[i][j][0]:
t = cha[i][j][1]
else:
tmp.append([s,t])
s,t = cha[i][j]
tmp.append([s,t])
for i,j in tmp:
lst[i] += 1
lst[j+1] -= 1
lst = list(accumulate(lst))
print((max(lst)))
|
p03504
|
import sys
import math
from itertools import accumulate as acc
N,C=list(map(int,input().split()))
a=[[0 for i in range(10**5+1)] for i in range(C+1)]
rec=[0 for i in range(10**5+1)]
for i in range(N):
s,t,c=list(map(int,input().split()))
recs,rect=a[c][s],a[c][t]
if recs==0 and rect==0:
rec[s-1]+=1
rec[t]-=1
elif recs==0 and rect==1:
rec[s-1]+=1
rec[t-1]-=1
elif recs==1 and rect==0:
rec[s]+=1
rec[t]-=1
elif recs==1 and rect==1:
rec[s]+=1
rec[t-1]-=1
a[c][s],a[c][t]=1,1
tmp=0
ans=0
for i in range(10**5):
tmp+=rec[i]
ans=max(tmp,ans)
print(ans)
|
import sys
import math
from itertools import accumulate as acc
input=sys.stdin.readline
N,C=list(map(int,input().split()))
a=[[0 for i in range(10**5+1)] for i in range(C+1)]
rec=[0 for i in range(10**5+1)]
for i in range(N):
s,t,c=list(map(int,input().split()))
recs,rect=a[c][s],a[c][t]
if recs==0 and rect==0:
rec[s-1]+=1
rec[t]-=1
elif recs==0 and rect==1:
rec[s-1]+=1
rec[t-1]-=1
elif recs==1 and rect==0:
rec[s]+=1
rec[t]-=1
elif recs==1 and rect==1:
rec[s]+=1
rec[t-1]-=1
a[c][s],a[c][t]=1,1
tmp=0
ans=0
for i in range(10**5):
tmp+=rec[i]
ans=max(tmp,ans)
print(ans)
|
p03504
|
import sys
import math
from itertools import accumulate as acc
input=sys.stdin.readline
N,C=list(map(int,input().split()))
a=[[0 for i in range(10**5+1)] for i in range(C+1)]
rec=[0 for i in range(10**5+1)]
for i in range(N):
s,t,c=list(map(int,input().split()))
recs,rect=a[c][s],a[c][t]
if recs==0 and rect==0:
rec[s-1]+=1
rec[t]-=1
elif recs==0 and rect==1:
rec[s-1]+=1
rec[t-1]-=1
elif recs==1 and rect==0:
rec[s]+=1
rec[t]-=1
elif recs==1 and rect==1:
rec[s]+=1
rec[t-1]-=1
a[c][s],a[c][t]=1,1
tmp=0
ans=0
for i in range(10**5):
tmp+=rec[i]
ans=max(tmp,ans)
print(ans)
|
import sys
import math
from itertools import accumulate as acc
input=sys.stdin.readline
N,C=list(map(int,input().split()))
a=[[0 for i in range(10**5+1)] for i in range(C+1)]
rec=[0 for i in range(10**5+1)]
for i in range(N):
s,t,c=list(map(int,input().split()))
recs,rect=a[c][s],a[c][t]
if recs==0 and rect==0:
rec[s-1]+=1
rec[t]-=1
elif recs==0 and rect==1:
rec[s-1]+=1
rec[t-1]-=1
elif recs==1 and rect==0:
rec[s]+=1
rec[t]-=1
elif recs==1 and rect==1:
rec[s]+=1
rec[t-1]-=1
a[c][s],a[c][t]=1,1
print((max(list(acc(rec)))))
|
p03504
|
N_C = list(map(int, input().split()))
s_t_c = []
for i in range(N_C[0]):
s_t_c.append(list(map(int, input().split())))
max_number = 0
for j in range(10 ** 5):
number = 0
for k in range(N_C[0]):
if s_t_c[k][0] <= j - 1 and s_t_c[k][1] >= j:
number = number + 1
if s_t_c[k][0] <= j and s_t_c[k][1] >= j + 1:
number = number + 1
if s_t_c[k][0] <= j - 1 and s_t_c[k][1] >= j + 1:
number = number - 1
max_number = max(max_number, number)
print(max_number)
|
n, C = list(map(int, input().split()))
time = 0
stc = []
for i in range(n):
temp = list(map(int, input().split()))
time = max(time, temp[1])
stc.append(temp)
tv = [[0 for i in range(C)] for i in range(time + 1)]
for i in stc:
s, t, c = i[0], i[1], i[2]
for j in range(s, t + 1):
tv[j][c - 1] = 1
ans = 0
for i in tv:
ans = max(ans, sum(i))
print(ans)
|
p03504
|
N, C = list(map(int, input().split()))
M = 10 ** 5 * 2 + 5
T = [[0] * M for i in range(C)]
for i in range(N):
s, t, c = list(map(int, input().split()))
s = 2 * s - 1
t = 2 * t
c -= 1
T[c][s] += 1
T[c][t] -= 1
TT = [[0] * (2 * N) for i in range(C)]
for i in range(C):
for j in range(1, M):
T[i][j] += T[i][j - 1]
num = 0
for j in range(M):
tmp = 0
for i in range(C):
if T[i][j] >= 1:
tmp += 1
num = max(tmp, num)
print(num)
|
N, C = list(map(int, input().split()))
M = 200005
rec = [[0] * M for i in range(C)]
for i in range(N):
s, t, c = list(map(int, input().split()))
rec[c - 1][2 * s - 1] += 1
rec[c - 1][2 * t] -= 1
for j in range(C):
for i in range(1, M):
rec[j][i] += rec[j][i - 1]
num = 0
for j in range(M):
tmp = 0
for i in range(C):
if rec[i][j] >= 1:
tmp += 1
num = max(tmp, num)
print(num)
|
p03504
|
n,c = list(map(int,input().split()))
stc = [[int(i) for i in input().split()] for j in range(n)]
ans = 0
stc.sort(key=lambda x:(x[2],x[1],x[0]))
time = 10**5+3
c_imos = [[0 for i in range(time)] for j in range(c)]
for i in range(n):
c_imos[stc[i][2]-1][stc[i][0]-1] += 1
c_imos[stc[i][2]-1][stc[i][1]] -= 1
nd_v = [[0 for i in range(time)] for j in range(c)]
for i in range(c):
for j in range(time):
if j == 0:
if c_imos[i][j] == 1:
nd_v[i][j] = 1
else:
nd_v[i][j] = nd_v[i][j-1] + c_imos[i][j]
for i in range(c):
for j in range(time):
if nd_v[i][j] >= 2:
nd_v[i][j] = 1
ans = 1
for i in range(time-1):
tmp = 0
for j in range(c):
tmp += nd_v[j][i]
ans = max(tmp,ans)
print(ans)
exit()
c_num = stc[0][2]
t_num = stc[0][1]
idx = 0
print(stc)
for i in range(1,n):
print((t_num,i))
if stc[idx+i][2] == c_num:
if stc[idx+i][0] == t_num:
stc[idx+i-1][1] = stc[idx+i][1]
t_num = stc[idx+i][1]
del stc[idx+i]
idx -= 1
else:
print((t_num,t_num,t_num))
c_num = stc[idx+i][2]
t_num = stc[idx+i][1]
stc.sort(key=lambda x:x[1])
print(stc)
exit()
tmp = stc[0][1]
ans = 1
ans_tmp = 1
for i in range(1,len(stc)):
for j in range(i+1,len(stc)):
if tmp >= stc[j][0]:
ans_tmp += 1
else:
tmp = stc[j][0]
ans = max(ans_tmp,ans)
|
n,c = list(map(int,input().split()))
stc = [[int(i) for i in input().split()] for j in range(n)]
ans = 0
stc.sort(key=lambda x:(x[2],x[1],x[0]))
time = 10**5+1
c_imos = [[0 for i in range(time)] for j in range(c)]
for i in range(n):
for j in range(stc[i][1]-stc[i][0]+1):
c_imos[stc[i][2]-1][stc[i][0]-1+j] = 1
"""
for i in range(n):
c_imos[stc[i][2]-1][stc[i][0]-1] += 1
c_imos[stc[i][2]-1][stc[i][1]] -= 1
"""
#nd_v = [[0 for i in range(time)] for j in range(c)]
"""
for i in range(c):
for j in range(time):
if j == 0:
if c_imos[i][j] == 1:
nd_v[i][j] = 1
else:
nd_v[i][j] = nd_v[i][j-1] + c_imos[i][j]
"""
"""
for i in range(c):
for j in range(time):
if nd_v[i][j] >= 2:
nd_v[i][j] = 1
"""
ans = 1
#print(c_imos)
for i in range(time):
tmp = 0
for j in range(c):
tmp += c_imos[j][i]
#print(i,tmp)
ans = max(tmp,ans)
print(ans)
exit()
c_num = stc[0][2]
t_num = stc[0][1]
idx = 0
print(stc)
for i in range(1,n):
print((t_num,i))
if stc[idx+i][2] == c_num:
if stc[idx+i][0] == t_num:
stc[idx+i-1][1] = stc[idx+i][1]
t_num = stc[idx+i][1]
del stc[idx+i]
idx -= 1
else:
print((t_num,t_num,t_num))
c_num = stc[idx+i][2]
t_num = stc[idx+i][1]
stc.sort(key=lambda x:x[1])
print(stc)
exit()
tmp = stc[0][1]
ans = 1
ans_tmp = 1
for i in range(1,len(stc)):
for j in range(i+1,len(stc)):
if tmp >= stc[j][0]:
ans_tmp += 1
else:
tmp = stc[j][0]
ans = max(ans_tmp,ans)
|
p03504
|
T_MAX = 10**5
n, nc = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(n)]
nrecs = [0]*(2*T_MAX+1)
for c in range(1, nc+1):
rec = [0]*(2*T_MAX+1)
for i in range(n):
if stc[i][2] == c:
rec[stc[i][0]*2-1] += 1
rec[stc[i][1]*2] -= 1
for i in range(1, 2*T_MAX+1):
rec[i] += rec[i-1]
for i in range(2*T_MAX+1):
if rec[i] > 0:
nrecs[i] += 1
print((max(nrecs)))
|
T_MAX = 10**5
n, nc = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(n)]
recs = [[0]*(T_MAX+1) for c in range(nc+1)]
for s, t, c in stc:
recs[c][s-1:t] = [1]*(t-s+1)
ans = max(list(map(sum, list(zip(*recs)))))
print(ans)
|
p03504
|
N,C=list(map(int,input().split()))
Time=[[0]*(10**5+1)]*C
for i in range(N):
s,t,c=list(map(int,input().split()))
T_c=list(Time[c-1])
T_c[s-1:t]=[1]*(t-s+1)
Time[c-1]=list(T_c)
Times=max(list(map(sum,list(zip(*Time)))))
print(Times)
|
N,C=list(map(int,input().split()))
Time=[[0]*(10**5+1) for c in range(C)]
for i in range(N):
s,t,c=list(map(int,input().split()))
Time[c-1][s-1:t] = [1]*(t-s+1)
Times=max(list(map(sum,list(zip(*Time)))))
print(Times)
|
p03504
|
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(10000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
def main():
N, C = li_input()
A = [[0] * 100001 for _ in range(C)]
S = [0] * 100001
for i in range(N):
s, t, c = li_input()
for j in range(s, t):
A[c - 1][j] += 1
for a in A:
for i in range(1, len(a)):
if a[i] == 1 or (i != len(a) - 1 and a[i + 1]) == 1:
S[i] += 1
print((max(S)))
main()
|
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(10000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
def main():
N, C = li_input()
A = [[0] * 100001 for _ in range(C)]
S = [0] * 100001
for i in range(N):
s, t, c = li_input()
for j in range(s - 1, t):
A[c - 1][j] += 1
for a in A:
for i in range(1, len(a)):
if a[i]:
S[i] += 1
print((max(S)))
main()
|
p03504
|
N,C = list(map(int,input().split()))
A = [[0 for _ in range(C)] for j in range(200001)]
for i in range(N):
s,t,c = list(map(int,input().split()))
for j in range(s*2-1,t*2):
A[j][c-1] = 1
R = 0
for i in range(200001):
sumA = sum(A[i])
if R < sumA:
R = sumA
print(R)
|
N,C = list(map(int,input().split()))
A = [[0 for _ in range(C)] for j in range(100001)]
for i in range(N):
s,t,c = list(map(int,input().split()))
for j in range(s-1,t):
A[j][c-1] = 1
R = 0
for i in range(100001):
sumA = sum(A[i])
if R < sumA:
R = sumA
print(R)
|
p03504
|
N,C = list(map(int,input().split()))
STC = [[] for _ in range(C)]
for i in range(N):
s,t,c = list(map(int,input().split()))
STC[c-1].append((s,t))
lenA = 200001
A = [[0]*lenA for _ in range(C)]
for i in range(N):
a = 1
for i in range(C):
for (s,t) in STC[i]:
A[i][s*2-1] += 1
A[i][t*2] -= 1
for i in range(C):
for j in range(lenA-1):
A[i][j+1] += A[i][j]
Ans = [0]*lenA
for i in range(C):
for j in range(lenA):
if A[i][j] > 0:
Ans[j] += 1
print((max(Ans)))
|
N,C = list(map(int,input().split()))
STC = [[] for _ in range(C)]
for i in range(N):
s,t,c = list(map(int,input().split()))
STC[c-1].append((s,t))
lenA = 200001
A = [[0]*lenA for _ in range(C)]
for i in range(C):
for (s,t) in STC[i]:
A[i][s*2-1:t*2] = [1]*(t*2-s*2+1)
Ans = [0]*lenA
for i in range(C):
for j in range(lenA):
if A[i][j] > 0:
Ans[j] += 1
print((max(Ans)))
|
p03504
|
N, C = list(map(int, input().split()))
TVs = [[] for i in range(C)]
for i in range(N):
s, t, c = list(map(int, input().split()))
TVs[c - 1].append((s, t))
periods = [0] * (2 * 10 ** 5)
for c, TVc in enumerate(TVs):
ps = [0] * (2 * 10 ** 5)
for s, t in TVc:
ps[s * 2 - 1: t * 2 - 2 + 1] = list([x + 1 for x in ps[s * 2 - 1: t * 2 - 2 + 1]])
for i in range(len(ps) - 1):
ps[i] = max(ps[i], ps[i + 1])
periods = list(map(sum, list(zip(periods, ps))))
print((max(periods)))
|
import heapq
N, C = list(map(int, input().split()))
TVs = [[] for i in range(C)]
for i in range(N):
s, t, ch = list(map(int, input().split()))
TVs[ch - 1].append((s, t))
pq = []
for ch, TVc in enumerate(TVs):
if not TVc: continue
TVc.sort()
heapq.heappush(pq, (TVc[0][0] - 0.5, ch))
states = [0] * C
iTVs = [0] * C
prev = 0
ans = 0
while pq:
tm, ch = heapq.heappop(pq)
if tm != prev:
ans = max(ans, sum(states))
prev = tm
if states[ch] == 0:
# チャンネルchの番組録画を、時刻tmから開始
states[ch] = 1
heapq.heappush(pq, (TVs[ch][iTVs[ch]][1], ch)) # 終了時刻をpqに追加
else:
# チャンネルchの番組録画を、時刻tmで終了
states[ch] = 0
iTVs[ch] += 1
if iTVs[ch] >= len(TVs[ch]): continue
if tm == TVs[ch][iTVs[ch]][0]:
# 録画範囲が連続しているならば、次の番組録画を開始
states[ch] = 1
heapq.heappush(pq, (TVs[ch][iTVs[ch]][1], ch)) # 終了時刻をpqに追加
else:
heapq.heappush(pq, (TVs[ch][iTVs[ch]][0] - 0.5, ch)) # 次の開始時刻をpqに追加
print(ans)
|
p03504
|
from itertools import accumulate
N, C = list(map(int, input().split()))
STC = [list(map(int, input().split())) for _ in range(N)]
M = 10**5+1
merge = [[0]*(M+1) for _ in range(31)]
for i in range(N):
s, t, c = STC[i]
merge[c][s] += 1
merge[c][t+1] -= 1
for c in range(31):
merge[c] = list([int(bool(x)) for x in accumulate(merge[c])])
ans = []
for i in range(M+1):
res = 0
for j in range(31):
res += merge[j][i]
ans.append(res)
print((max(ans)))
|
from itertools import accumulate
N, C = list(map(int, input().split()))
STC = [list(map(int, input().split())) for _ in range(N)]
M = 10**5+1
merge = [[0]*(M+1) for _ in range(31)]
for i in range(N):
s, t, c = STC[i]
#merge[c][s] += 1
#merge[c][t+1] -= 1
merge[c][s:t+1] = [1]*(t-s+1)
#for c in range(31):
# merge[c] = list(map(lambda x: int(bool(x)), accumulate(merge[c])))
print((max(list(map(sum, list(zip(*merge)))))))
#ans = []
#for i in range(M+1):
# res = 0
# for j in range(31):
# res += merge[j][i]
# ans.append(res)
#print(max(ans))
|
p03504
|
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18
N,C=rl()
st = [[] for _ in range(C)]
TT1 = [0 for _ in range(10**5+2)]
for i in range(N):
s,t,c = rl()
TT1[s] += 1
TT1[t+1] -= 1
st[c-1].append([s,t])
for st_i in range(len(st)):
st_ = st[st_i]
if len(st_) <= 1: continue
st_.sort(key=lambda x:x[0])
l = []
new = 0
lst_ = len(st_)
for i in range(lst_):
if new == 0:
s,t = st_[i]
if i != lst_ -1 and t==st_[i+1][0]:
new = 1
continue
else:
l.append([s,t])
else:
t = st_[i][1]
if i != lst_ -1 and t==st_[i+1][0]:
new = 1
continue
else:
l.append([s,t])
st[st_i] = l
TT2 = [0 for _ in range(10**5+2)]
for st_ in st:
if len(st_) == 0: continue
for i in range(len(st_)):
TT2[st_[i][0]] += 1
TT2[st_[i][1]+1] -= 1
for i in range(1,len(TT1)):
TT1[i] += TT1[i-1]
TT2[i] += TT2[i-1]
print(min(max(TT1),max(TT2)))
|
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18
N,C=rl()
stc = [rl() for _ in range(N)]
stc.sort(key=lambda x:(x[2],x[0]))
nstc = []
for s,t,c in stc:
if len(nstc) != 0 and nstc[-1][2] == c and nstc[-1][1] == s:
nstc[-1][1] = t
else:
nstc.append([s,t,c])
n = len(nstc)
TT=[0]*(2*10**5+5)
for i in range(n):
TT[2*nstc[i][0] - 1] += 1
TT[2*nstc[i][1]] -= 1
for i in range(1,len(TT)):
TT[i] += TT[i-1]
print(max(TT))
|
p03504
|
from collections import defaultdict
from itertools import accumulate
n, v = list(map(int, input().split()))
programs = defaultdict(list)
for _ in range(n):
s, t, c = list(map(int, input().split()))
programs[c].append((s, t))
imos = [0] * (2 * 10 ** 5 + 2)
for c, p in list(programs.items()):
p.sort()
ps, pt = p[0]
for s, t in p[1:]:
if pt == s:
pt = t
else:
imos[2 * ps - 1] += 1
imos[2 * pt + 1] -= 1
ps, pt = s, t
imos[2 * ps - 1] += 1
imos[2 * pt + 1] -= 1
print((max(accumulate(imos))))
|
from collections import defaultdict
from itertools import accumulate
n, v = list(map(int, input().split()))
programs = defaultdict(list)
for _ in range(n):
s, t, c = list(map(int, input().split()))
programs[c].append((s, t))
imos = [0] * (10 ** 5 + 2)
for c, p in list(programs.items()):
p.sort()
ps, pt = p[0]
for s, t in p[1:]:
if pt == s:
pt = t
else:
imos[ps - 1] += 1
imos[pt] -= 1
ps, pt = s, t
imos[ps - 1] += 1
imos[pt] -= 1
print((max(accumulate(imos))))
|
p03504
|
N, C = list(map(int, input().split()))
tt = [[0] * (2 * 10 ** 5 + 1) for _ in range(30)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
ttc = tt[c - 1]
for i in range(s * 2 - 1, t * 2):
ttc[i] = 1
ct = [0] * (2 * 10 ** 5 + 1)
for i in range(30):
tti = tt[i]
for j in range(2 * 10 ** 5 + 1):
ct[j] += tti[j]
print((max(ct)))
|
from operator import itemgetter
N, C = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(N)]
stc.sort(key=itemgetter(2, 0))
cs = [0] * (10 ** 5 * 2 + 1)
pc = -1
for s, t, c in stc:
if pc != c:
pt = -1
pc = c
if pt == s:
cs[s * 2] += 1
else:
cs[s * 2 - 1] += 1
cs[t * 2] -= 1
pt = t
for i in range(1, 10 ** 5 * 2 + 1):
cs[i] += cs[i - 1]
print((max(cs)))
|
p03504
|
N, C = list(map(int, input().split()))
tt = [[0] * (10 ** 5 + 1) for _ in range(30)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
ttc = tt[c - 1]
for i in range(s - 1, t):
ttc[i] = 1
ct = [0] * (10 ** 5 + 1)
for i in range(30):
tti = tt[i]
for j in range(10 ** 5 + 1):
ct[j] += tti[j]
print((max(ct)))
|
# imos 法
from operator import itemgetter
N, C = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(N)]
stc.sort(key=itemgetter(2, 0))
cs = [0] * (10 ** 5 + 1)
pc = -1
for s, t, c in stc:
if pc != c:
pt = -1
pc = c
if pt == s:
cs[s] += 1
else:
cs[s - 1] += 1
cs[t] -= 1
pt = t
for i in range(1, 10 ** 5 + 1):
cs[i] += cs[i - 1]
print((max(cs)))
|
p03504
|
N, C = list(map(int, input().split()))
tt = [[0] * (10 ** 5 + 1) for _ in range(C)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
for i in range(s - 1, t):
tt[c - 1][i] = 1
ct = [0] * (10 ** 5 + 1)
for i in range(C):
for j in range(10 ** 5 + 1):
ct[j] += tt[i][j]
print((max(ct)))
|
# imos 法
from operator import itemgetter
N, C = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(N)]
stc.sort(key=itemgetter(2, 0))
cs = [0] * (10 ** 5 + 1)
pt, pc = -1, -1
for s, t, c in stc:
if pt == s and pc == c:
cs[s] += 1
else:
cs[s - 1] += 1
cs[t] -= 1
pt, pc = t, c
for i in range(1, 10 ** 5 + 1):
cs[i] += cs[i - 1]
print((max(cs)))
|
p03504
|
N, C = list(map(int, input().split()))
prog = []
for _ in range(N):
prog.append(list(map(int, input().split())))
ans = 0
T = 10**5
print((max([len(list([x for x in prog if x[0] <= i <= x[1]]))
for i in range(T+1)])))
|
from itertools import accumulate
# -*- coding: utf-8 -*-
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, C = list(map(int, input().split()))
TV = dict()
programs = [list(map(int, input().split())) for _ in range(N)]
last_time = max([p[1] for p in programs])
for i in range(1, C+1):
TV[i] = [0]*(last_time*2+2)
for s, t, c in programs:
s *= 2
t *= 2
TV[c][s] += 1
TV[c][t+1] -= 1
for c in range(1, C+1):
TV[c] = list(accumulate(TV[c]))
ans = 0
for i in range(last_time*2+1):
tmp = 0
for c in range(1, C+1):
if TV[c][i] > 0:
tmp += 1
ans = max(ans, tmp)
print(ans)
|
p03504
|
N, C = list(map(int, input().split()))
channels = [[] for _ in range(C)]
maxT = 0
for _ in range(N) :
s, t, c = list(map(int, input().split()))
maxT = max(maxT, t)
channels[c - 1].append((s, t))
maxT = maxT * 2 + 10
tvSum = [0 for _ in range(maxT)]
for tv in channels :
imos = [0 for _ in range(maxT)]
for (s, t) in tv :
imos[s * 2 - 1] += 1
imos[t * 2] -= 1
for i in range(1, maxT) :
imos[i] += imos[i - 1]
for i in range(maxT) :
if imos[i] > 0 :
tvSum[i] += 1
ans = 0
for i in range(maxT) :
ans = max(ans, tvSum[i])
print(ans)
|
N, C = list(map(int, input().split()))
channels = [[] for _ in range(C)]
maxT = 0
for _ in range(N) :
s, t, c = list(map(int, input().split()))
maxT = max(maxT, t)
channels[c - 1].append((s, t))
maxT = maxT * 2 + 10
tvSum = [0 for _ in range(maxT)]
for tv in channels :
imos = [0 for _ in range(maxT)]
for (s, t) in tv :
imos[s * 2 - 1] += 1
imos[t * 2] -= 1
for i in range(1, maxT) :
imos[i] += imos[i - 1]
for i in range(maxT) :
if imos[i] > 0 :
tvSum[i] += 1
print((max(tvSum)))
|
p03504
|
import sys
def main():
input = sys.stdin.readline
N, C = list(map(int, input().split()))
dic = [[] for _ in range(C + 1)]
for _ in range(N):
s, t, c = input().split()
dic[int(c)].append([int(s), int(t)])
for c in range(C + 1):
l = len(dic[c])
if l == 1:
continue
dic[c] = sorted(dic[c])
i = 0
while i < l - 1:
if i < l - 1 and dic[c][i][1] == dic[c][i + 1][0]:
dic[c][i + 1][0] = dic[c][i][0]
dic[c].pop(i)
l -= 1
else:
i += 1
f = [0 for _ in range(100002)]
for c in range(C + 1):
for t in dic[c]:
f[t[0]] += 1
f[t[1] + 1] -= 1
ans = 0
for i in range(1, 100001):
f[i] += f[i - 1]
if ans < f[i]:
ans = f[i]
print(ans)
if __name__ == "__main__":
main()
|
import sys
def main():
input = sys.stdin.readline
N, C = list(map(int, input().split()))
dic = [[] for _ in range(C + 1)]
for _ in range(N):
s, t, c = input().split()
dic[int(c)].append([int(s), int(t)])
for c in range(C + 1):
l = len(dic[c])
if l == 1:
continue
dic[c] = sorted(dic[c])
i = 0
while i < l - 1:
if i < l - 1 and dic[c][i][1] == dic[c][i + 1][0]:
dic[c][i + 1][0] += 1
else:
i += 1
f = [0 for _ in range(100002)]
for c in range(C + 1):
for t in dic[c]:
f[t[0]] += 1
f[t[1] + 1] -= 1
ans = 0
for i in range(1, 100001):
f[i] += f[i - 1]
if ans < f[i]:
ans = f[i]
print(ans)
if __name__ == "__main__":
main()
|
p03504
|
n,c = list(map(int,input().split()))
program = [list(map(int,input().split())) for i in range(n)]
time = [0 for i in range(10**5+1)]
program.sort()
program.sort(key = lambda x: x[2])
for i in range(1,n):
if program[i][2]==program[i-1][2] and program[i][0]==program[i-1][1]:
program[i][0] = program[i-1][0]
program[i-1][0] = None
#print(program)
for i in range(n):
if program[i][0] == None:
continue
time[program[i][0]-1] += 1
time[program[i][1]] -= 1
count = 0
max_count = 0
for i in range(10**5+1):
count += time[i]
max_count = max(max_count,count)
print(max_count)
|
n,c = list(map(int,input().split()))
ab = []
for _ in range(n):
s, t, cha = (int(x) for x in input().split())
ab.append([s, t, cha])
ab = sorted(ab, key=lambda x: x[0])
ab = sorted(ab, key=lambda x: x[2])
for i in range(1,n):
if ab[i][0] == ab[i-1][1] and ab[i][2] == ab[i-1][2]:
ab[i][0] = ab[i-1][0]
ab[i-1][0] = -1
time = [0]*(10**5+1)
for i in range(n):
if ab[i][0] == -1:
continue
time[ab[i][0]-1] += 1
time[ab[i][1]] -= 1
ans = 0
memo = 0
for i in time:
memo += i
ans = max(ans,memo)
print(ans)
|
p03504
|
import functools
N, C = list(map(int, input().split()))
T = [[0 for i in range(10 ** 5 + 1)] for j in range(C)]
for i in range(N):
s, t, c = list(map(int, input().split()))
for j in range(s - 1, t):
T[c - 1][j] = 1
ans = 0
for j in range(10 ** 5 + 1):
r = 0
for i in range(C):
r += T[i][j]
ans = max(ans, r)
print(ans)
|
import functools
N, C = list(map(int, input().split()))
P = [[0 for c in range(C)] for i in range(10 ** 5 + 1)]
T = 0
for i in range(N):
s, t, c = list(map(int, input().split()))
T = max(t, T)
for j in range(s - 1, t):
P[j][c - 1] = 1
ans = 0
for p in P[:T + 1]:
ans = max(sum(p), ans)
print(ans)
|
p03504
|
N, C = list(map(int, input().split()))
stc = [[int(x) for x in input().split()] for _ in range(N)]
im = [[0] * (10**5 + 1) for _ in range(C + 1)]
for x in stc:
s,t,c = x
im[c][s] += 1
im[c][t] -= 1
for c in range(1, C + 1):
v = 0
for i in range(1, 10**5 + 1):
n = im[c][i]
v += n
if n > 0:
im[c][i - 1] += 1
im[c][i] = v
print((max([sum(x) for x in zip(*im[1:])])))
|
import operator
N, C = list(map(int, input().split()))
stc = [[int(x) for x in input().split()] for _ in range(N)]
united = []
pc,ps,pt = 0,0,0
for x in sorted(stc, key=operator.itemgetter(2,0,1)):
s, t, c = x
if c == pc and s == pt:
united[-1][1] = t
else:
united.append([s, t, c])
ps, pt, pc = x
cnt = [0] * (10**5 + 1)
for x in united:
s,t,c = x
for i in range(s - 1, t):
cnt[i] += 1
print((max(cnt)))
|
p03504
|
N, C = list(map(int, input().split()))
channel_list = [[0 for _ in range(10**5+1)]for _ in range(C)]
count_list = [0 for _ in range(10**5+1)]
for i in range(N):
s, t, c = list(map(int, input().split()))
channel_list[c-1][s-1] += 1
channel_list[c-1][t] -= 1
for i in range(C):
for t in range(1, 10**5):
if t == 10 ** 5:
continue
channel_list[i][t] += channel_list[i][t-1]
if channel_list[i][t] >= 1:
count_list[t] += 1
x = 0
for t in range(1, 10**5+1):
count = count_list[t]
if count > x:
x = count
print(x)
|
N, C = list(map(int, input().split()))
channel_list = [[0 for _ in range(10**5+1)]for _ in range(C)]
count_list = [0 for _ in range(10**5+1)]
for i in range(N):
s, t, c = list(map(int, input().split()))
channel_list[c-1][s-1] += 1
channel_list[c-1][t] -= 1
for i in range(C):
for t in range(1, 10**5+1):
channel_list[i][t] += channel_list[i][t-1]
if channel_list[i][t] >= 1:
count_list[t] += 1
print((max(count_list)))
|
p03504
|
N, C = list(map(int, input().split()))
channel_list = [[0 for _ in range(10**5+1)]for _ in range(C)]
count_list = [0 for _ in range(10**5+1)]
for i in range(N):
s, t, c = list(map(int, input().split()))
channel_list[c-1][s-1] += 1
channel_list[c-1][t] -= 1
for i in range(C):
for t in range(1, 10**5+1):
channel_list[i][t] += channel_list[i][t-1]
if channel_list[i][t] >= 1:
count_list[t] += 1
print((max(count_list)))
|
N, C = list(map(int, input().split()))
time = 10**5+1
channel_list = [[0 for _ in range(time)]for _ in range(C)]
count_list = [0 for _ in range(time)]
for i in range(N):
s, t, c = list(map(int, input().split()))
channel_list[c-1][s-1] += 1
channel_list[c-1][t] -= 1
for i in range(C):
for t in range(1, time):
channel_list[i][t] += channel_list[i][t-1]
if channel_list[i][t] >= 1:
count_list[t] += 1
print((max(count_list)))
|
p03504
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.