結果

問題 No.2880 Max Sigma Mod
ユーザー hiro1729hiro1729
提出日時 2024-08-24 13:33:37
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 1,419 ms / 3,000 ms
コード長 2,488 bytes
コンパイル時間 273 ms
コンパイル使用メモリ 82,516 KB
実行使用メモリ 76,348 KB
最終ジャッジ日時 2024-08-24 13:34:00
合計ジャッジ時間 21,939 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 36 ms
53,188 KB
testcase_01 AC 44 ms
61,312 KB
testcase_02 AC 52 ms
63,640 KB
testcase_03 AC 51 ms
66,072 KB
testcase_04 AC 43 ms
61,592 KB
testcase_05 AC 1,130 ms
76,348 KB
testcase_06 AC 875 ms
76,096 KB
testcase_07 AC 554 ms
75,944 KB
testcase_08 AC 471 ms
75,940 KB
testcase_09 AC 238 ms
75,916 KB
testcase_10 AC 399 ms
75,892 KB
testcase_11 AC 671 ms
76,128 KB
testcase_12 AC 227 ms
75,956 KB
testcase_13 AC 97 ms
76,132 KB
testcase_14 AC 580 ms
76,064 KB
testcase_15 AC 1,414 ms
76,092 KB
testcase_16 AC 1,407 ms
76,048 KB
testcase_17 AC 1,415 ms
75,948 KB
testcase_18 AC 1,419 ms
76,064 KB
testcase_19 AC 1,419 ms
75,972 KB
testcase_20 AC 55 ms
70,168 KB
testcase_21 AC 324 ms
76,304 KB
testcase_22 AC 627 ms
76,312 KB
testcase_23 AC 55 ms
70,324 KB
testcase_24 AC 367 ms
75,896 KB
testcase_25 AC 1,139 ms
76,128 KB
testcase_26 AC 1,194 ms
76,224 KB
testcase_27 AC 1,164 ms
76,320 KB
testcase_28 AC 1,321 ms
75,896 KB
testcase_29 AC 493 ms
76,048 KB
testcase_30 AC 35 ms
53,248 KB
testcase_31 AC 34 ms
53,532 KB
testcase_32 AC 35 ms
53,204 KB
testcase_33 AC 36 ms
54,040 KB
testcase_34 AC 37 ms
53,468 KB
testcase_35 AC 36 ms
54,332 KB
testcase_36 AC 41 ms
53,420 KB
testcase_37 AC 37 ms
54,292 KB
testcase_38 AC 37 ms
53,464 KB
testcase_39 AC 36 ms
53,352 KB
testcase_40 AC 36 ms
53,232 KB
testcase_41 AC 36 ms
53,788 KB
testcase_42 AC 36 ms
53,808 KB
testcase_43 AC 37 ms
54,216 KB
testcase_44 AC 35 ms
53,256 KB
testcase_45 AC 35 ms
53,120 KB
testcase_46 AC 36 ms
53,268 KB
testcase_47 AC 42 ms
53,420 KB
testcase_48 AC 37 ms
54,624 KB
testcase_49 AC 41 ms
60,788 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

from math import isqrt

from math import gcd

# N≦2^64で素数判定
def is_prime(N: int) -> bool:
	if N <= 1:
		return False
	if N == 2:
		return True
	if N & 1 == 0:
		return False
	s = 0
	d = N - 1
	while d & 1 == 0:
		s += 1
		d >>= 1
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		if a % N == 0:
			return True
		x = pow(a, d, N)
		if x != 1:
			t = 0
			while t < s and x < N - 1:
				t += 1
				x = x * x % N
			if t == s:
				return False
	return True

# N以下の最大の素数を返す
def biggest_prime(N: int) -> int:
	while not is_prime(N):
		N -= 1
	return N

# N以上の最小の素数を返す
def smallest_prime(N: int) -> int:
	while not is_prime(N):
		N += 1
	return N

# エラトステネスの篩 [1, N]
def Eratosthenes_Sieve(N: int) -> list:
	if N < 2:
		return []
	p = [True] * (N + 1)
	p[0] = p[1] = False
	for i in range(2, N + 1):
		if i * i > N:
			break
		if p[i]:
			for j in range(2 * i, N + 1, i):
				p[j] = False
	return p

# エラトステネスの区間篩 [A, B]
def Eratosthenes_Sieve2(A: int, B: int) -> list:
	p = [True] * (B - A + 1)
	for i in range(2, B + 1):
		if i * i > B:
			break
		if i < A:
			for j in range((A + i - 1) // i * i, B + 1, i):
				p[j - A] = False
		elif p[i - A]:
			for j in range(2 * i, B + 1, i):
				p[j - A] = False
	return p

# 約数(ソートする)
def divisor(N: int) -> list:
	d = []
	d2 = []
	for i in range(1, N + 1):
		if i * i > N:
			break
		if N % i == 0:
			d.append(i)
			if i * i < N:
				d2.append(N // i)
	return d + d2[::-1]

# 素因数分解
def factorize(N: int) -> list:
	c = 0
	while N & 1 == 0:
		c += 1
		N >>= 1
	ans = [(2, c)]
	while N > 1:
		n = N
		while not is_prime(n):
			m = int(n ** 0.125) + 1
			for c in range(1, n):
				y = 0
				g = 1
				q = 1
				r = 1
				while g == 1:
					x = y
					for _ in range(r >> 1, (3 * r) >> 2):
						y = (y * y + c) % n
					for k in range((3 * r) >> 2, r, m):
						ys = y
						for _ in range(min(m, r - k)):
							y = (y * y + c) % n
							q = q * (x - y) % n
						g = gcd(q, n)
						if g != 1:
							break
					r <<= 1
				if g == n:
					g = 1
					y = ys
					while g == 1:
						y = (y * y + c) % n
						g = gcd(x - y, n)
				if g != n:
					break
			n = g
		c = 0
		while N % n == 0:
			c += 1
			N //= n
		ans.append((n, c))
	ans.sort()
	return ans

N, M = map(int, input().split())
ans = 0
sm = 0
for x in range(1, N + 1):
	for i in divisor(x):
		if i <= M:
			sm += i
	ans = max(ans, x * M - sm)
print(ans)
0