[BOJ][๐ก5][๋ฐฑ์ค#01041] ์ฃผ์ฌ์
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
+---+
| D | +---+---+---+---+ | E | A | B | F | +---+---+---+---+
| C |
+---+
์ฃผ์ฌ์๋ ์์ ๊ฐ์ด ์๊ฒผ๋ค. ์ฃผ์ฌ์์ ์ฌ์ฏ ๋ฉด์๋ ์๊ฐ ์ฐ์ฌ ์๋ค. ์์ ์ ๊ฐ๋๋ฅผ ์๊ฐ ๋ฐ์ผ๋ก ๋์ค๊ฒ ์ ๋๋ค. A, B, C, D, E,ย F์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ง๋ฏผ์ด๋ ํ์ฌ ๋์ผํ ์ฃผ์ฌ์๋ฅผ N3๊ฐ ๊ฐ์ง๊ณ ์๋ค. ์ด ์ฃผ์ฌ์๋ฅผ ์ ์ ํ ํ์ ์ํค๊ณ ์์์, NรNรNํฌ๊ธฐ์ ์ ์ก๋ฉด์ฒด๋ฅผ ๋ง๋ค๋ ค๊ณ ํ๋ค. ์ด ์ ์ก๋ฉด์ฒด๋ ํ์์์ ์์ผ๋ฏ๋ก, 5๊ฐ์ ๋ฉด๋ง ๋ณด์ธ๋ค. N๊ณผ ์ฃผ์ฌ์์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง ๋, ๋ณด์ด๋ 5๊ฐ์ ๋ฉด์ ์ฐ์ฌย ์๋ ์์ ํฉ์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์ ์ฃผ์ฌ์์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์์ ๊ทธ๋ฆผ์์ A, B, C, D, E, F์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋ค. N์ 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๊ณ , ์ฐ์ฌ ์๋ ์๋ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฌธ์ ์ ์ ๋ต์ ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
2
1 2 3 4 5 6
์ถ๋ ฅ
36
์์ 2
์ ๋ ฅ
3
1 2 3 4 5 6
์ถ๋ ฅ
69
์์ 3
์ ๋ ฅ
1000000
50 50 50 50 50 50
์ถ๋ ฅ
250000000000000
์์ 4
์ ๋ ฅ
10
1 1 1 1 50 1
์ถ๋ ฅ
500
My Sol
import sys
from itertools import combinations
def main():
def calc_min_single():
return min(arr)
def calc_min_double():
S = {comb for comb in combinations(range(6), 2)}
del_S = {(0, 5), (1, 4), (2, 3)}
minn = 1000
for a, b in S - del_S:
minn = min(minn, arr[a]+arr[b])
return minn
def calc_min_triple():
S = {(0,1,2),(0,1,3),(0,4,2),(0,4,3), (5,1,2),(5,1,3),(5,4,2),(5,4,3)}
minn = 1000
for a, b, c in S:
minn = min(minn, arr[a]+arr[b]+arr[c])
return minn
def check_outer():
min_single = calc_min_single()
min_double = calc_min_double()
min_triple = calc_min_triple()
sq_triple = 4
sq_double = 4*(N-2)+4*(N-1)
sq_single = 4*(N-1)*(N-2)+(N-2)**2
single = min_single * sq_single
double = min_double * sq_double
triple = min_triple * sq_triple
return single + double + triple
N = int(input())
arr = list(map(int, input().split()))
if N==1: return sum(arr)-max(arr)
return check_outer()
print(main())
๋ฐ๋ฉด์ ์ ์ธํ๊ณ ์๋ฉด๊ณผ ์๋ฉด์ผ๋ก ๊ตฌ๋ถํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค ํ๋ค. ๊ฐ์ฅ ์์ 4๊ฐ์ ๊ผญ์ง์ ๋ง 3๊ฐ์ ๋ฉด์ ๊ฐ์ง๊ณ , 4๊ฐ์ ์ธ๋ก ๋ณ์ 2๊ฐ์ ๋ฉด, ๊ทธ๋ฆฌ๊ณ ๋๋จธ์ง๋ ํ ๊ฐ์ ๋ฉด์ ๊ฐ์ง๋ค๋ ์ ์์ ํ์ด๋ฅผ ์ฐฉ์ํ๋ค.
- ์
๋ ฅ์ผ๋ก
N
๊ณผ 6๊ฐ์ ์arr
์ ๋ฐ์ ์ฒ๋ฆฌํ๋ค. calc_min_single
ํจ์์์ 1๊ฐ ๋ฉด์ ๋ณด์ด๋ ๊ฒฝ์ฐ์ ์ต์๊ฐ์ ๊ณ์ฐํ๋ค. ์ด๋ ๋จ์ํarr
์ ์ต์๊ฐ์ ์ทจํ๋ฉด ๋๊ฒ ๋ค.calc_min_double
ํจ์์์ 2๊ฐ ๋ฉด์ ๋ณด์ด๋ ๊ฒฝ์ฐ์ ์ต์๊ฐ์ ๊ณ์ฐํ๋ค. ํ๋ํ๋ ํ๋์ฝ๋ฉํ๋ฉด ์ด 4+4+4๊ฐ์ ๊ฒฝ์ฐ์ ์๊ฐ ๋์ค์ง๋ง ํ๋ํ๋ ์ฐ๊ธฐ๊ฐ ์ซ์ด์itertools
์combinations
ํจ์๋ฅผ ์ฌ์ฉํ์ฌ6C2
๋ฅผ ๊ตฌํ๊ณ , ์๋ก ๋ง์ฃผ๋ณด๋ 3๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๋นผ์ฃผ์๋ค. 12๊ฐ์ง ๊ฒฝ์ฐ์์ ๊ฐ์ฅ ์์ ํฉ์ ๋ฐํํ๋ค.calc_min_triple
ํจ์์์ 3๊ฐ ๋ฉด์ ๋ณด์ด๋ ๊ฒฝ์ฐ์ ์ต์๊ฐ์ ๊ณ์ฐํ๋ค. ์ด๋ ์ด์ฉ ์ ์์ด ํ๋์ฝ๋ฉํด์ฃผ์๊ณ , 8๊ฐ์ ๊ฒฝ์ฐ์์์ด๋ฉด ๋๋ฏ๋ก ํฌ๊ฒ ๋ฌธ์ ๊ฐ ๋์ง ์์๋ค. ์์ฒ๋ผ ํฉ์ ์ต์๊ฐ์ ๊ตฌํด ๋ฐํํ์๋ค.check_outer
ํจ์์์ 5๊ฐ ๋ฉด์์ ๊ตฌํด์ ธ์ผ ํ๋ 1๊ฐ๋ฉด, 2๊ฐ๋ฉด, 3๊ฐ๋ฉด์ ๊ฐ์๋ฅผ ๊ตฌํด ๊ณฑํด์ฃผ์๋ค. ์ด ๊ฐ๊ฐ์single
,double
,triple
๋ก ์ง์ ํ์๊ณ , ์ด๋ฅผ ๋ํ ๊ฐ์ ๋ฐํํ์๋ค.- N์ด 1์ธ ํน์ด ์ผ์ด์ค์์๋ง ์ ์ฒด ํฉ์์ ์ต๋๊ฐ์ ๋นผ์ค ๊ฐ์ ๋ฐํํ๊ณ , ๋๋จธ์ง๋
check_outer
ํจ์์ ๋ฐํ๊ฐ์ผ๋ก ๊ณ์ฐํ ์ ์์ด์ ๋ถ๊ธฐ์ฒ๋ฆฌํด ๋ฐํํ๊ณ ,main
ํจ์์ ๋ฐํ๊ฐ์ ์ต์ข ์ ์ผ๋ก ์ถ๋ ฅํด์ค๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
n=int(input())
a,b,c,d,e,f=map(int,input().split())
if n==1:
print(a+b+c+d+e+f-max(a,b,c,d,e,f))
else:
print(min(a,b,c,d,e,f)*(5*n*n-16*n+12)+min(a+c,a+b,a+d,a+e,b+c,b+f,b+d,c+e,c+f,d+e,d+f,e+f)*(8*n-12)+min(a+b+c,a+b+d,a+d+e,a+e+c,b+d+f,b+c+f,c+e+f,d+e+f)*4)
์ฌ์ค ๋ชจ๋ฒ๋ต์์ ์๋๊ณ ์ฝ๋๊ธธ์ด์ ์ฐ์ฐ์๊ฐ์ด ์งง์ ํ์ด๋ฅผ ๊ฐ์ ธ์๋ณด์๋ค. ์ฌ์ค ๊ฒฝ์ฐ์ ์๋ฅผ ๋ชจ๋ ํ๋์ฝ๋ฉ์ผ๋ก ์์ฑํ์ฌ minimum์ ์ฐพ์ผ๋ฉด ๋๋ ๋ฌธ์ ๊ธด ํ๋ค. ๋ฌธ์ ๋ฅผ ํ๋ฉด์๋ ์ด๊ฒ ์๊ณ ๋ฆฌ์ฆ์ ์๊ตฌํ๋..? ํ๋ ์๊ฐ์ ์ข ํ๊ธด ํ๋ค. ์๋ฌดํผ ๊ทธ๊ฑด ๊ทธ๊ฑฐ๊ณ ํ๋์ฝ๋ฉ์ธ ์ ์ ์ ์ธํ๋ฉด ๋๋ฆ ์ง๊ด์ ์ด๊ณ ์ฝ๊ฒ ํ์ด๋ธ ํ์ด์๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ