๋ชฉ๋ก์ ์ฒด ๊ธ (79)
๐ฉ๐ปโ๐พ

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ด๋ค ๋๋ผ์๋ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง์ ๋์์ M๊ฐ์ ๋จ๋ฐฉํฅ ๋๋ก๊ฐ ์กด์ฌํ๋ค. ๋ชจ๋ ๋๋ก์ ๊ฑฐ๋ฆฌ๋ 1์ด๋ค. ์ด ๋ ํน์ ํ ๋์ X๋ก๋ถํฐ ์ถ๋ฐํ์ฌ ๋๋ฌํ ์ ์๋ ๋ชจ๋ ๋์ ์ค์์, ์ต๋จ ๊ฑฐ๋ฆฌ๊ฐ ์ ํํ K์ธ ๋ชจ๋ ๋์๋ค์ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ํ ์ถ๋ฐ ๋์ X์์ ์ถ๋ฐ ๋์ X๋ก ๊ฐ๋ ์ต๋จ ๊ฑฐ๋ฆฌ๋ ํญ์ 0์ด๋ผ๊ณ ๊ฐ์ ํ๋ค. ์๋ฅผ ๋ค์ด N=4, K=2, X=1์ผ ๋ ๋ค์๊ณผ ๊ฐ์ด ๊ทธ๋ํ๊ฐ ๊ตฌ์ฑ๋์ด ์๋ค๊ณ ๊ฐ์ ํ์. ์ด ๋ 1๋ฒ ๋์์์ ์ถ๋ฐํ์ฌ ๋๋ฌํ ์ ์๋ ๋์ ์ค์์, ์ต๋จ ๊ฑฐ๋ฆฌ๊ฐ 2์ธ ๋์๋ 4๋ฒ ๋์ ๋ฟ์ด๋ค. 2๋ฒ๊ณผ 3๋ฒ ๋์์ ๊ฒฝ์ฐ, ์ต๋จ ๊ฑฐ๋ฆฌ๊ฐ 1์ด๊ธฐ ๋๋ฌธ์ ์ถ๋ ฅํ์ง ์๋๋ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ๋์์ ๊ฐ์ N, ๋๋ก์ ๊ฐ์ M, ๊ฑฐ๋ฆฌ ์ ๋ณด K, ์ถ๋ฐ ๋์์ ๋ฒํธ X..

1๏ธโฃ๋ฌธ์ ์ค๋ช august14๋ ์ธ์์์ ๊ฐ์ฅ ๋ง์๋ ์นตํ ์ผ์ด๋ค. ์ด ์นตํ ์ผ์ ๋ง๋๋ ์ ํํ ๋ฐฉ๋ฒ์ ์์ง ์ธ์์ ๊ณต๊ฐ๋์ง ์์์ง๋ง, ๋ค์ด๊ฐ๋ ์ฌ๋ฃ N๊ฐ๋ ๊ณต๊ฐ๋์ด ์๋ค. ๊ฒฝ๊ทผ์ด๋ ์ธํฐ๋ท ๊ฒ์์ ํตํด์ ์ฌ๋ฃ ์ N-1๊ฐ์ ๋น์จ์ ์์๋๊ณ , ์ด ๋น์จ์ ์ด์ฉํด์ ์นตํ ์ผ์ ๋ค์ด๊ฐ๋ ์ ์ฒด ์ฌ๋ฃ์ ๋น์จ์ ์์๋ผ ์ ์๋ค. ์ด ์ฌ๋ฃ ์ N-1๊ฐ์ ๋น์จ์ด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค. ์ด๋, ์นตํ ์ผ์ ๋ง๋๋๋ฐ ํ์ํ ๊ฐ ์ฌ๋ฃ์ ์์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ด๋, ํ์ํ ์ฌ๋ฃ์ ์ง๋์ ๋ชจ๋ ๋ํ ๊ฐ์ด ์ต์๊ฐ ๋์ด์ผ ํ๋ค. ์นตํ ์ผ์ ๋ง๋๋ ์ฌ๋ฃ์ ์์ ์ ์์ด๊ณ , ์ด ์ง๋์ 0๋ณด๋ค ์ปค์ผํ๋ค. ๋น์จ์ "a b p q"์ ๊ฐ์ ํ์์ด๊ณ , a๋ฒ ์ฌ๋ฃ์ ์ง๋์ b๋ฒ ์ฌ๋ฃ์ ์ง๋์ผ๋ก ๋๋ ๊ฐ์ด p/q๋ผ๋ ๋ป์ด๋ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์..

1๏ธโฃ๋ฌธ์ ์ค๋ช ๋ ์์ฐ์ A์ B์ ๋ํด์, A์ ๋ฐฐ์์ด๋ฉด์ B์ ๋ฐฐ์์ธ ์์ฐ์๋ฅผ A์ B์ ๊ณต๋ฐฐ์๋ผ๊ณ ํ๋ค. ์ด๋ฐ ๊ณต๋ฐฐ์ ์ค์์ ๊ฐ์ฅ ์์ ์๋ฅผ ์ต์๊ณต๋ฐฐ์๋ผ๊ณ ํ๋ค. ์๋ฅผ ๋ค์ด, 6๊ณผ 15์ ๊ณต๋ฐฐ์๋ 30, 60, 90๋ฑ์ด ์์ผ๋ฉฐ, ์ต์ ๊ณต๋ฐฐ์๋ 30์ด๋ค. ๋ ์์ฐ์ A์ B๊ฐ ์ฃผ์ด์ก์ ๋, A์ B์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T(1 โค T โค 1,000)๊ฐ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ T๊ฐ์ ์ค์ ๊ฑธ์ณ์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. (1 โค A, B โค 45,000) 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ T๊ฐ์ ์ค์ A์ B์ ์ต์๊ณต๋ฐฐ์๋ฅผ ์ ๋ ฅ๋ฐ์ ์์๋๋ก ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ def GCD(a, b): if b == 0: return a ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ด๋ค ์๊ฐ ์์์ N์ ๊ณฑ(N โฅ 2) ๊ผด์ผ ๋, ๊ทธ ์๋ฅผ ๊ฑฐ์ ์์๋ผ๊ณ ํ๋ค. ๋ ์ ์ A์ B๊ฐ ์ฃผ์ด์ง๋ฉด, A๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , B๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฑฐ์ ์์๊ฐ ๋ช ๊ฐ์ธ์ง ์ถ๋ ฅํ๋ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์ผ์ชฝ ๋ฒ์ A์ ์ค๋ฅธ์ชฝ ๋ฒ์ B๊ฐ ๊ณต๋ฐฑ ํ ์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ด ๋ช ๊ฐ๊ฐ ์๋์ง ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ import math minV, maxV = map(int, input().split())# ์ผ์ชฝ ๋ฒ์, ์ค๋ฅธ์ชฝ ๋ฒ์ prime = [True] * (int(maxV ** 0.5) + 1) # ์์ ํ๋ณ ์ฌ๋ถ ์ ์ฅ prime[1] = False cnt = 0 for i in range(2, int(maxV ** 0.5) + 1): if prime..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์์ฐ์ n์ด ์ฃผ์ด์ก์ ๋, GCD(n, k) = 1์ ๋ง์กฑํ๋ ์์ฐ์ 1 โค k โค n ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ฐ์ n (1 โค n โค 1012)์ด ์ฃผ์ด์ง๋ค. 3๏ธโฃ์ถ๋ ฅ GCD(n, k) = 1์ ๋ง์กฑํ๋ ์์ฐ์ 1 โค k โค n ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ import math n = int(input()) answer = n for i in range(2, int(math.sqrt(n) + 1)): if n % i == 0: # i๊ฐ ์์ธ์์ธ์ง ํ์ธ answer -= answer / i # i์ ๋ฐฐ์ ๊ฐ์๋งํผ ์ญ์ while n % i == 0: # i ๊ฑฐ๋ญ์ ๊ณฑ ์ญ์ n /= i if n > 1: answer -= answer / ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ด๋ค ์์ ๊ทธ ์์ ์ซ์ ์์๋ฅผ ๋ค์ง์ ์๊ฐ ์ผ์นํ๋ ์๋ฅผ ํฐ๋ฆฐ๋๋กฌ์ด๋ผ ๋ถ๋ฅธ๋ค. ์๋ฅผ ๋ค์ด 79,197๊ณผ 324,423 ๋ฑ์ด ํฐ๋ฆฐ๋๋กฌ ์์ด๋ค. ์ด๋ค ์ N (1 โค N โค 1,000,000)์ด ์ฃผ์ด์ก์ ๋, N๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , ์์์ด๋ฉด์ ํฐ๋ฆฐ๋๋กฌ์ธ ์ ์ค์์, ๊ฐ์ฅ ์์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ def Eratos(checkPrime): for i in range(2, int(checkPrime ** 0.5) + 1): if int(checkPrime) % i == 0: return False return True n = int(input())# ์ด๋ค ์ N answ..
ํ(heap)์ด๋? ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์๋น ๋ฅด๊ฒ ์ฐพ๊ธฐ ์ํด ๊ณ ์๋ ์๋ฃ๊ตฌ์กฐ ์์๋ค์ด ํญ์ ์ ๋ ฌ๋ ์ํ๋ก ์ถ๊ฐ๋๊ณ ์ญ์ ์๊ฐ ๋ณต์ก๋ O(N) ํ ํจ์ ํ์ฉํ๊ธฐ heapq.heappush(heap, item) heap์ item์ ์ถ๊ฐ heapq.heappop(heap) heap์์ ๊ฐ์ฅ ์์ ์์๋ฅผ pop ํ์ด ๋น์ด ์๋ ๊ฒฝ์ฐ, IndexError๊ฐ ํธ์ถ๋จ heapq.heapify(x) ๊ธฐ์กด ๋ฆฌ์คํธ๋ฅผ heap์ผ๋ก ๋ณํ ๋ฌธ์ ํ์ด Q . ๋ ๋งต๊ฒ import heapq def solution(scoville, K): answer = 0 heapq.heapify(scoville) # ๊ฐ์ฅ ์์ ๊ฐ์ด K๋ณด๋ค ํด ๋๋ ์์ ํ์ X if scoville[0] >= K: return answer while scovill..

1๏ธโฃ ๋ฌธ์ ์ค๋ช ์ด๋ค ์์ฐ์๋ฅผ ์ ๊ณฑํ์ ๋ ๋์ค๋ ์ ์๋ฅผ ์ ๊ณฑ์๋ผ๊ณ ํฉ๋๋ค. ์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n์ด ์ ๊ณฑ์๋ผ๋ฉด 1์ ์๋๋ผ๋ฉด 2๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. 2๏ธโฃ ์ ํ์ฌํญ 1 โค n โค 1,000,000 3๏ธโฃ ์ ์ถ๋ ฅ ์ ๐ก์ฝ๋ import math def solution(denum1, num1, denum2, num2): denumA = num1 * num2 numA = denum1 * num2 + denum2 * num1 gcdV = math.gcd(denumA, numA)# ์ต๋๊ณต์ฝ์ ๊ตฌํ๋ ํจ์ answer = [numA / gcdV, denumA / gcdV] return answer 1๏ธโฃ ๋ฌธ์ ์ค๋ช ์ด๋ค ์์ฐ์๋ฅผ ์ ๊ณฑํ์ ๋ ๋์ค๋ ์ ์๋ฅผ ์ ๊ณฑ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง N๊ฐ์ ๋จ์ด๊ฐ ๋ค์ด์ค๋ฉด ์๋์ ๊ฐ์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๊ธธ์ด๊ฐ ์งง์ ๊ฒ๋ถํฐ ๊ธธ์ด๊ฐ ๊ฐ์ผ๋ฉด ์ฌ์ ์์ผ๋ก ๋จ, ์ค๋ณต๋ ๋จ์ด๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๊ฑฐํด์ผ ํ๋ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ๋จ์ด์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. (1 โค N โค 20,000) ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฑธ์ณ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋จ์ด๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ 50์ ๋์ง ์๋๋ค. 3๏ธโฃ์ถ๋ ฅ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ ๋ ฌํ์ฌ ๋จ์ด๋ค์ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ import sys input = sys.stdin.readline n = int(input()) # ๋จ์ด ๊ฐ์ A = [0] * n# ์ ๋ ฅ ๋ฐ์ ๋จ์ด๋ค ์ ์ฅ for i in range(n): A[i] = ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ธ์ค์ด๋ ์์์ +, -, ๊ทธ๋ฆฌ๊ณ ๊ดํธ๋ฅผ ๊ฐ์ง๊ณ ์์ ๋ง๋ค์๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ ์ธ์ค์ด๋ ๊ดํธ๋ฅผ ๋ชจ๋ ์ง์ ๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ ์ธ์ค์ด๋ ๊ดํธ๋ฅผ ์ ์ ํ ์ณ์ ์ด ์์ ๊ฐ์ ์ต์๋ก ๋ง๋ค๋ ค๊ณ ํ๋ค. ๊ดํธ๋ฅผ ์ ์ ํ ์ณ์ ์ด ์์ ๊ฐ์ ์ต์๋ก ๋ง๋๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ด ์ฃผ์ด์ง๋ค. ์์ โ0โ~โ9โ, โ+โ, ๊ทธ๋ฆฌ๊ณ โ-โ๋ง์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ๊ฐ์ฅ ์ฒ์๊ณผ ๋ง์ง๋ง ๋ฌธ์๋ ์ซ์์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ์ํด์ ๋ ๊ฐ ์ด์์ ์ฐ์ฐ์๊ฐ ๋ํ๋์ง ์๊ณ , 5์๋ฆฌ๋ณด๋ค ๋ง์ด ์ฐ์๋๋ ์ซ์๋ ์๋ค. ์๋ 0์ผ๋ก ์์ํ ์ ์๋ค. ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ์์ ๊ธธ์ด๋ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ ๋ต์ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ import sys input = sys.stdin.read..