๋ฌธ์ ๋งํฌ
28683๋ฒ: ํผํ! ํผํ! ํผํ์ธ!
๋ฌธ์ ์์ฝ
์ผ๊ฐํ ํ ๋ณ ๊ธธ์ด์ ์ ๊ณฑ์ธ n์ด ์ฃผ์ด์ง๋ค. sqrt(n) ๊ธธ์ด์ ๋ณ์ ๊ฐ์ง๋ ๊ฐ๋ฅํ ํฉ๋์ด ์๋ ์๋ก ๋ค๋ฅธ ์ง๊ฐ์ผ๊ฐํ์ ๊ฐฏ์๋ฅผ ์ถ๋ ฅํ๋ผ.
๋จ, ์ง๊ฐ์ผ๊ฐํ์ ์ต์ํ ๋ ๋ณ์ ์ ์์ฌ์ผ ํ๋ค. ๊ฐ๋ฅํ ์ง๊ฐ์ผ๊ฐํ์ ๊ฐฏ์๊ฐ ์ ์ ์์ด ๋ง๋ค๋ฉด -1๋ฅผ ์ถ๋ ฅํ๋ค.
(ํผํ! ํผํ! ํผํ์ธ!์ ์๋ฏธ๋ฅผ ๊ธ์ ์ฐ๋ฉด์ ๊นจ๋ฌ์๋ค ๐ )
ํ์ด ์ค๋ช
๊ฝค ์ฌ๋ฌ๋ฒ์ ์๋์ ๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฅผ ์ฐธ๊ณ ํ ๋์ ๋ฌธ์ ๋ฅผ ํ์๋ค.
์ฒซ ๋ฒ์งธ ์๋: ๊ฒฝ์ฐ์ ์๋ฅผ ๋๋์ด ์ ๊ทผ (if n==์ ๊ณฑ์) (์๊ฐ ์ด๊ณผ)
๊ธฐ์กด์๋ n์ด ์ ๊ณฑ์๊ฑฐ๋ ์๋๊ฑฐ๋์ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋์ด ์๊ฐํด๋ณด์๋ค.
n์ด ์ ๊ณฑ์๋ผ๋ฉด, ๋ค๋ฅธ ํ ๋ณ์ ๊ธธ์ด๋ฅผ ์์์ ์ ๊ณฑ์๋ก ํ๊ณ , ๋๋จธ์ง๋ ์ ์ ํ ๊ธธ์ด๋ก ๋๋ฉด ์ฝ๊ฒ ๋ ๊ฐ ๋ณ์ ๊ธธ์ด๊ฐ ์ ์์ธ ์ง๊ฐ์ผ๊ฐํ์ด ์ฑ๋ฆฝ๋์ด ์ง๊ฐ์ผ๊ฐํ์ ๊ฐฏ์๋ ๋ฌดํํ ๋ง์์ง๋ค. ๋ฐ๋ผ์, ์ ๊ณฑ์์ธ ๊ฒฝ์ฐ -1์ ์ถ๋ ฅํ๋ค.
n_sqrt=math.sqrt(n)
if n_sqrt%1==0:
triangle_num=-1
if triangle_num==-1:
print(-1)
exit()
์ ๊ณฑ์๊ฐ ์๋ ๊ฒฝ์ฐ, n์ด ์ง๊ฐ์ผ๊ฐํ์ ํ ๋ณ์ ์ ๊ณฑ์ด ๋๋ ค๋ฉด ์๋์ ๊ฐ์ด ํผํ๊ณ ๋ผ์ค ์ ๋ฆฌ๋ฅผ ๋ง์กฑํ์ฌ์ผ ํ๋ค. (A์ B๋ ์ง๊ฐ์ผ๊ฐํ ๋๋จธ์ง ํ ๋ณ๋ค)
double_list=[]
prev=0
for i in range(1, 1000001):
if i*i-prev>n:
break
double_list.append(i*i)
prev=i*i
l=len(double_list)
for i in range(l):
for j in range(i,l):
if double_list[i]+n<double_list[j]:
break
elif double_list[i]+double_list[j]==n:
triangle_num+=1
break
elif double_list[i]+n==double_list[j]:
triangle_num+=1
break
B ์ ๊ณฑ - A ์ ๊ณฑ์ด n๋ณด๋ค ํฌ์ง ์์ ๊ฒฝ์ฐ๋ก ํ์ ํ์ฌ, ๋ชจ๋ ์ ๊ณฑ์๋ค์ ์ ์ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ ๊ณฑ์ 2๊ฐ๋ฅผ ์ ํํ๋ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ํํ๋ฉด์ ์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ ๊ฐ๋ฅํ ์ผ๊ฐํ ๊ฐฏ์(triangle_num)์ 1์ฉ ๋ํด์ค๋ค.
์ด ๋ฌธ์ ๋ ์๊ฐ ์ ํ์ด 1์ด์๊ณ , ์ ์์ ์ ๋ ฅ ์ ํ์ด 1<=n<=10^12 ์๊ธฐ ๋๋ฌธ์, 1์ด ๋์ ๊ฐ๋ฅํ ์ฐ์ฐ ํ์์ธ 1์ต(10^8) ๋ฒ์ ๊ณ ๋ คํ๋ค๋ฉด ๋น์ฐํ ์๊ฐ ์ด๊ณผ๊ฐ ๋ ์๋ฐ์ ์์๋ค. ๊ทธ๋ฆฌ๊ณ ์ญ์ ์๊ฐ ์ด๊ณผ๋ฌ๋ค. ๐
๋ ๋ฒ์งธ ์๋: ๋ค๋ฅธ ๋ถ๋ค ํ์ด ์ฐธ๊ณ (ํ๋ ธ์ต๋๋ค.)
๋ค๋ฅธ ๋ถ์ ํ์ด๋ฅผ ์ฐธ๊ณ ํ๋ค, ๋์ณค๋ ์ฌ์ค์ ๊นจ๋ฌ์๋ค.
n์ด ๋น๋ณ์ ์ ๊ณฑ์ด ์๋ ๊ฒฝ์ฐ, ๊ณฑ์ ๊ณต์์ ์ฌ์ฉํ์ฌ์ ์ด ๋ฌธ์ ๋ฅผ ์ฝ์ ์ฐพ๊ธฐ ๋ฌธ์ ๋ก ์นํํ ์ ์๋ค๋ ๊ฒ์ด์๋ค.
๋๋ถ์ด B-A์ B+A๊ฐ ํ๋๊ฐ ์ง์๋ฉด ๋๋จธ์ง๋ ์ง์, ํ๋๊ฐ ํ์๋ฉด ๋๋จธ์ง๋ ํ์์ด๊ธฐ ๋๋ฌธ์ ์ด ์กฐ๊ฑด์ ํ์ธํ์ฌ ๊ฐ๋ฅํ ์ง๊ฐ์ผ๊ฐํ์ ๊ฐฏ์๋ฅผ ๊ตฌํ ์ ์์๋ค.
๊ฑฐ์ ๋ค ์จ ์ํฉ์์, ๋ฒ์์ ๋ํ ๊ณ ๋ ค ์์ด ์ฝ๋๋ฅผ ์ง๋ ์ง๊ฐ์ผ๊ฐํ์ ์ค๋ณตํด์ ์นด์ดํธํ์ฌ, ์ค๋ต ์ฒ๋ฆฌ๋์๋ค.
์ธ ๋ฒ์งธ ์๋: ํ์ ๋ฒ์ ์ถ์ (๋ง์์ต๋๋ค!!)
for i in range(1, 1000001):
if i*i>n//2:
break
double_list.append(i*i)
prev=i*i
def check_double(num):
num_sqrt=math.sqrt(num)
if num_sqrt%1==float(0):
return True
if num_sqrt%1!=float(0):
return False
l=len(double_list)
for i in range(l):
if check_double(n-double_list[i]):
triangle_num+=1
for i in range(1, int(math.sqrt(n))+1):
if n%i==0:
if (n//i)%2==0 and i%2==0:
triangle_num+=1
elif (n//i)%2==1 and i%2==1:
triangle_num+=1
1๋ฒ ๊ฒฝ์ฐ๋ฅผ ํ์ํ ์ ๊ณฑ์ ๋ฐฐ์ด์ ๊ฒฝ์ฐ, n//2๋ณด๋ค ํฌ๋ฉด ์ ์ฝ๋์์ ์ค๋ณตํ์ฌ ์ง๊ฐ์ผ๊ฐํ์ ์นด์ดํธํ ์ ์๊ธฐ ๋๋ฌธ์ n//2๋ฅผ ์ค์ผ๋ก ๋ฒ์๋ฅผ ํ์ ํ๋ค.
2๋ฒ ๊ฒฝ์ฐ๋ฅผ ํ์ํ ๋, ๊ธฐ์กด์๋ range(1, n)์ผ๋ก ๋ฌด์ง์ฑ ํ์์ ํ์๋๋ฐ sqrt(n)๊น์ง ํ์ํ ํ์๋ ์ด๋ฏธ ์ฐพ์ ์ง๊ฐ์ผ๊ฐํ์ ๊ธด ๋ณ์ ํ์ํ๋ ๊ผด์ด์ด์ range(1, int(math.sqrt(n))+1)๋ก ๋ฒ์๋ฅผ ํ์ ํ๋ค.
2๋ฒ ์์ด๋์ด ์ง์ง ์ฐธ์ ํ๊ณ ์ข๋ค.์ด๋ ค์ด ๊ฐ๋ ์ ์๋์ง๋ง,
๋ค๋ฅธ ๋ฌธ์ ์ค์๋ ์ํ์ ๊ด์ ์์ ๋ ์ฝ๊ฒ ํ ์ ์๋ ๋ฌธ์ ๊ฐ ์์ ๊ฒ ๊ฐ๋ค๊ณ ์๊ฐํ๋ค!