โ 1002 ํฐ๋ โ
for _ in range(int(input())):
x1, y1, r1, x2, y2, r2 = map(int, input().split())
d = (x1-x2)**2 + (y1-y2)**2
if d > (r1+r2)**2: print(0)
elif d == (r1+r2)**2: print(1)
elif (r1+r2)**2 > d > (r1-r2)**2: print(2)
else:
if r1!=r2:
if d == (r1-r2)**2: print(1)
else:print(0)
else:print(-1)
๐คฝ๐ปโ๏ธ ๋ ์์ ์์น ๊ด๊ณ์ ๋ฐ๋ฅธ ๋ ์ ๊ต์ ์ ๊ฐ์
๐คฝ๐ปโ๏ธ ๋ ์์ ์์น ๊ด๊ณ๋ ํฌ๊ฒ 6๊ฐ์ง๋ก ๋๋๋ค.
๐คฝ๐ปโ๏ธ ๋ ์์ ์ค์ฌ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธฐ์ค์ผ๋ก 6๊ฐ์ง๋ฅผ ์์ธํ๊ฒ ๋๋ ์ ์๋ค.
(๋ ์์ ์ค์ฌ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ d๋ผ๊ณ ํ๊ณ , ๋ ์์ ๋ฐ์ง๋ฆ์ ๊ฐ๊ฐ r1, r2๋ผ๊ณ ํ๋ฉด)
โ d > (r1+r2) - ๋ ์์ด ์์ ๋ง๋์ง ์์ - ๊ต์ 0๊ฐ
โก d = (r1+r2) - ๋ ์์ด ์๋ก ์ธ์ ํจ - ๊ต์ 1๊ฐ
โข (r1+r2) > d > |r1-r2| - ๋ ์์ด ๊ฒน์นจ - ๊ต์ 2๊ฐ
→ ์๋ 3๊ฐ์ง |r1-r2| >= d์ธ ๊ฒฝ์ฐ ์ค์์
โฃ r1 = r2 - ๋ ์์ด ์์ ๊ฒน์นจ - ๊ต์ ๋ฌด์ํ ๋ง์
โค r1 ≠ r2์ด๊ณ d = |r1-r2| - ํ ์์ด ๋ค๋ฅธ ์์ ๋ด์ ํจ - ๊ต์ 1๊ฐ
โฅ r1 ≠ r2์ด๊ณ |r1-r2| > d - ํ ์์ด ๋ค๋ฅธ ์์ ๋ค์ด๊ฐ - ๊ต์ 0๊ฐ
โ 13908 ๋น๋ฐ๋ฒํธ โ
from math import factorial
def combination(a,b): #aCb
return factorial(a)//(factorial(b)*factorial(a-b))
n,m=map(int,input().split())
if m>0:input()
ans=10**n
for i in range(1,m+1):
ans+=(((-1)**i)*(combination(m,i))*((10-i)**n))
print(ans)
๐คฝ๐ปโ๏ธ BF๋ก ํ ์ ์์ผ๋, ํฌํจ๊ณผ ๋ฐฐ์ ์ ์๋ฆฌ๋ก ์ ๊ทผํด ํ์ด๋ณด์!
๐คฝ๐ปโ๏ธ n๊ฐ์ ์๋ฆฌ์์์ m๊ฐ์ ์๋ก ๋ค๋ฅธ ์ซ์๊ฐ ํฌํจ๋ ๋น๋ฐ๋ฒํธ์ ์์ธ ์ ๋ต์ A๋ผ๊ณ ํ๋ฉด, ํฌํจ๊ณผ ๋ฐฐ์ ์ ์๋ฆฌ์ ์ํด
A = 10^n - mC1x(9^n) + mC2x(8^n) - mC3x(7^n) + ...
โ ์ ์ฒด ๊ฒฝ์ฐ์์ 10^n
โก m๊ฐ ์ซ์ ์ข ๋ฅ ๊ฐ๊ฐ 1๊ฐ์ฉ๋ง ๋น๋ฐ๋ฒํธ์ ๋ค์ด๊ฐ์ง ์์ ๊ฒฝ์ฐ๋ 9^n์ด๊ณ , ์ด๋ฅผ ์ ์ฒด ๊ฒฝ์ฐ์ ์์์ ๋นผ์ผ ํจ
(๋น๋ฐ๋ฒํธ์๋ ์ด๋ฅผ ํฌํจํด์ผ ํ๋ฏ๋ก) - mC1๋งํผ ๊ฒฝ์ฐ์ ์ ์กด์ฌ
โข ์ฌ๊ธฐ์, ๊ณตํต์ ์ผ๋ก ๋นผ์ง ๋ถ๋ถ์ด ์์ผ๋ฏ๋ก (์๋ฅผ ๋ค๋ฉด 4์๋ฆฌ ์์์ ๊ฐ๊ฐ 3๊ณผ 4๊ฐ ์๋ค์ด๊ฐ ๊ฒฝ์ฐ๋ฅผ ๋บ์ ๋, ์๋ฅผ ๋ค์ด 1256์ ๋ ๋ฒ ๋นผ์ง),
ํฌํจ๊ณผ ๋ฐฐ์ ์ ์๋ฆฌ์ ์ํด ๊ฒน์น ๋ถ๋ถ์ ๋ค์ ๋ํด์ค์ผ ํจ - ์ด๋ mC2๊ฐ์ ๊ฐ์ง์์์, ์ด์ ๋ ๊ฐ๊ฐ ๊ณตํต์ ์ผ๋ก ์๋ค์ด๊ฐ ๊ฒฝ์ฐ 8^n์ ๊ณฑํ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค์ ๋ํด์ค
โฃ ์ด์ , ํฌํจ๊ณผ ๋ฐฐ์ ์ ์๋ฆฌ์ ์ํด ์ธ ๊ฐ์ ์ซ์๊ฐ ๋ค์ ๋ํด์คฌ์ผ๋ฏ๋ก, ๋นผ์ค์ผ ํจ - ์ด๋ ๊ฒ ๋ฐ๋ณต
mCn = (n!)/(r!(m-n)!)
๐คฝ๐ปโ๏ธ ์ A๋ฅผ ๋ค์ ์ ๋ฆฌํด๋ณด์๋ฉด,
โ 2477 ์ฐธ์ธ๋ฐญ โ
def get_area(pos,K,h,w,sh,sw,i):
w = i[pos][1]
h = i[pos-1][1]
if pos==5: sh = h-i[0][1]
else: sh = h-i[pos+1][1]
if 4<=pos: sw = i[pos-4][1]
else: sw = i[pos+2][1]
return (K*(h*w-sh*sw))
K=int(input())
n=0
i=[]
ds=[]
for _ in range(6):
d,l=map(int,input().split())
i.append((d,l))
ds.append(d)
ds.sort()
if ds==[1,1,2,3,3,4]: n=2
elif ds==[1,2,2,3,4,4]: n=1
elif ds==[1,2,2,3,3,4]: n=4
else: n=3
pos = [pair[0] for pair in i].index(n)
print(get_area(pos,K,0,0,0,0,i))
๐คฝ๐ปโ๏ธ ์ด 4๊ฐ์ง ๋ชจ์์ ์ฐธ์ธ๋ฐญ์ด ์ฃผ์ด์ ธ ์๊ณ , ๋์๋จ๋ถ ๋ฐฉํฅ์ ๊ฐ๊ฐ 1234๋ก ํ์ ๋, ๊ฐ ์ฐธ์ธ๋ฐญ์ ๊ธด ๊ฐ๋ก๊ธธ์ด๋ฅผ pos ๋ณ์์ ๋ฃ๊ณ , ์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ค ๋ฐฉํฅ์ ๋ฐ๋ฅธ ๋ณ ๊ธธ์ด๋ฅผ ์ด์ฉํด ํฐ ์ง์ฌ๊ฐํ ๋์ด - ์์ ์ง์ฌ๊ฐํ ๋์ด๋ฅผ ๊ตฌํ๋ค
๐คฝ๐ปโ๏ธ ์ฌ๋ฌ if๋ฌธ์ผ๋ก ์ํฉ์ ๋ฐ๋ผ ์๊ฐํด์ผ ํ๋ ๊ธฐํํ ๋ฌธ์
๐คฝ๐ปโ๏ธ ํฐ ์ง์ฌ๊ฐํ์ ๊ฐ๋ก์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๊ฐ๊ฐ i์ j๋ก index()๋ฅผ ์ด์ฉํด ๊ตฌํ๊ณ , ์ด๋ก๋ถํฐ index ๊ธฐ์ค 3์ฉ ๋จ์ด์ง ๊ฒ ์์ ์ง์ฌ๊ฐํ์ ๊ฐ๋ก์ ์ธ๋ก์์ idea๋ก ์์์ฑ๋ฉด ์๋์ ๊ฐ์ด ๋งค์ฐ ๊ฐ๋จํ๊ฒ ์ฝ๋ฉ ๊ฐ๋ฅ! (์ด ๋ index + 3์ ์ค๋ฅ๊ฐ ๋์ง ์๊ฒ๋ ์ผ๋ถ๋ฌ ๋๊ฐ์ ์ซ์๋ฅผ ๋ถ์ฌ list๋ฅผ 2๋ฐฐ๋ก ํด์ค๋ค. - idea ๊ธฐ์ตํ๊ธฐ)
n=int(input())
x=[int(input().split()[1])for _ in range(6)]*2
i=x.index(max(x))
j=x.index(max(x[i-1],x[i+1]))
print(n*(x[i]*x[j]-x[i+3]*x[j+3]))
โ 7908 Will It Stop? โ
import math
n = int(input())
if int(math.log(n,2)) == math.log(n,2):
print('TAK')
else:
print('NIE')
๐คฝ๐ปโ๏ธ ์์ธ์๋ถํด ๊ฒฐ๊ณผ 2๋ก๋ง ์ด๋ฃจ์ด์ง ์, ์ฆ 2์ ์ ๊ณฑ์๋ผ๋ฉด ๊ฒฐ๊ตญ n์ด 1์ด ๋๋ฏ๋ก TAK ์ถ๋ ฅ / ๊ทธ๋ ์ง ์๊ณ 2๊ฐ ์๋ ๋ค๋ฅธ ์์ธ์๊ฐ ์กด์ฌํ๋ค๋ฉด ๋ฌด์กฐ๊ฑด ๋ฌดํ๋ฐ๋ณต๋ฌธ์ ๊ฑธ๋ ค์ NIE ์ถ๋ ฅ.
๐คฝ๐ปโ๏ธ ๋ชจ๋ ์์ฐ์๋ 2^k*p(p๋ ์์ ๋๋ 1)๋ก ๋ํ๋ผ ์ ์๋๋ฐ, p๊ฐ 1์ธ ๊ฒฝ์ฐ 2์ ์ ๊ณฑ์์ด๋ฏ๋ก ์ด ๋๋ TAK ์ถ๋ ฅ / p๊ฐ 1์ด ์๋ ์์์ธ ๊ฒฝ์ฐ ์ธ์ ๊ฐ๋ p ํ์๋ก ์ธํด n์ด 3*n+3์ผ๋ก ์ฐ์ฐ๋๋ ๋ถ๋ถ์ ๊ฑธ๋ฆฌ๊ฒ ๋๊ณ , ์ฆ 3์ด ๊ณฑํด์ง๋ฏ๋ก 3์ด ์ง์์ง์ง ์๊ฒ ๋๊ธฐ์(3์ ๋ฐฐ์ ์ ์ง) ๋ฌดํ๋ฐ๋ณต๋ฌธ์ ๊ฐํ์ NIE ์ถ๋ ฅ
โ 13662 Elevador โ
๐คฝ๐ปโ๏ธ ์ฃผ์ด์ง ์ง์ฌ๊ฐํ์์ ๋ ์์ ๋ฃ์ ์ ์๋ ์ง ํ๋ณํ๋ ๊ธฐํํ ๋ฌธ์
: ์ ๋ ์์ ๋ฐ์ง๋ฆ์ r1, r2๋ผ ํ๊ณ ์ง์ฌ๊ฐํ์ ๊ฐ๋ก ๊ธธ์ด๋ฅผ W, ์ธ๋ก ๊ธธ์ด๋ฅผ H๋ผ ํ์(์ผ์ชฝ ์ A, ์ค๋ฅธ์ชฝ ์ B). A๋ฅผ ์ง์ฌ๊ฐํ์ ์ผ์ชฝ ์์ ์ต๋ํ ๋ฐฐ์นํ๊ณ , B๋ฅผ ์ง์ฌ๊ฐํ์ ์ค๋ฅธ์ชฝ ์๋์ ์ต๋ํ ๋ฐฐ์นํ์. ๊ทธ๋ฌ๋ฉด A์ ์ค์ฌ ์ขํ E๋ (r1,H-r1) / B์ ์ค์ฌ ์ขํ G๋ (W-r2,r2). ๋ ์์ด ์ง์ฌ๊ฐํ ์์ ๋ค์ด๊ฐ๋ ค๋ฉด ๋ ์์ ์ค์ฌ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๊ฐ ์ต์ (r1+r2)๋ณด๋ค๋ ํฌ๊ฑฐ๋ ๊ฐ์์ผ ํ๋ค. (๊ทธ๋ฆผ ๋งํฌ)
: ์ผ๋จ ๋ ์ ์ค ํฐ ์์ ์ง๋ฆ์ด ๊ฐ๋ก ๊ธธ์ด, ์ธ๋ก ๊ธธ์ด ์ค ์ต์๊ฐ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์์ผ ํ๊ณ , ์ ๋ถ๋ฑ์์ ๋ง์กฑํ๋ฉด ๋ ์์ ์ง์ฌ๊ฐํ์ ๋ฃ๊ธฐ ๊ฐ๋ฅ!
import sys
input=sys.stdin.readline
while 1:
H,W,r1,r2=map(int,input().split())
if (H,W,r1,r2) == (0,0,0,0):
break
if min(H,W) >= max(2*r1,2*r2):
if ((W-r1-r2)**2 + (H-r1-r2)**2) >= (r1+r2)**2:
print('S')
else:
print('N')
else:
print('N')
โ 1500 ์ต๋ ๊ณฑ โ
S,K=map(int,input().split())
ans=[S//K]*K
for x in range(S%K):
ans[x]+=1
final = 1
for x in ans:
final*=x
print(final)
๐คฝ๐ปโ๏ธ ํฉ์ด ์ผ์ ํ๊ณ , ์ฃผ์ด์ง ์ซ์ ๊ฐ์๊ฐ ์ผ์ ํ ์ํ์์, ์ฐ์ -๊ธฐํ ํ๊ท ์ ์ํด ์ฃผ์ด์ง ์ซ์๊ฐ ์๋ก ์ฐจ์ด๊ฐ ํฌ์ง ์๊ฒ ํด์ผ best.
: maximizing productํ๊ธฐ ์ํด ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ฐ์ -๊ธฐํํ๊ท ์์ ๋ง๋ค ์ ์๊ณ , ๋ฑํธ ์กฐ๊ฑด, ์ฆ x1~xk๊น์ง์ ๊ณฑ์ด ์ต๋๊ฐ์ธ ์กฐ๊ฑด์ x1~xk๊ฐ ๋ชจ๋ ๋์ผํ ๋, ์ฆ S/K์ผ ๋๋ค, K๊ฐ ์ ํํ S์ ์ํด ๋๋์ด์ง์ง ์๋๋ค๋ฉด, ์ ์๋ค์ ์ต๋ํ S/K์ ๊ฐ๊น์์ผ ํ๋ค.
'BOJ > ๐ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โ Binary Search Upper-Intermediate I - 6 Solvedโ (0) | 2023.02.09 |
---|---|
โ Greedy Upper-Intermediate I - 9 Solvedโ (0) | 2023.01.27 |
โ Coordinate Compression Upper-Intermediate - 3 Solvedโ (0) | 2023.01.24 |
โ Prefix Sum Upper + Intermediate I - 7 Solvedโ (0) | 2023.01.18 |
โ PQ ์ค์๊ธ - 6๋ฌธ์ ()โ (0) | 2023.01.11 |
๋๊ธ