2021. 4. 14. 16:35ใ๐ Algorithm/๐ช๐ป Python ๋ฌธ์ ํ์ด
๋ฌธ์ ์ค๋ช
์ค๋์ ์คํํธ๋งํฌ์ ๋ค๋๋ ์ฌ๋๋ค์ด ๋ชจ์ฌ์ ์ถ๊ตฌ๋ฅผ ํด๋ณด๋ ค๊ณ ํ๋ค. ์ถ๊ตฌ๋ ํ์ผ ์คํ์ ํ๊ณ ์๋ฌด ์ฐธ์๋ ์๋๋ค. ์ถ๊ตฌ๋ฅผ ํ๊ธฐ ์ํด ๋ชจ์ธ ์ฌ๋์ ์ด N๋ช ์ด๊ณ ์ ๊ธฐํ๊ฒ๋ N์ ์ง์์ด๋ค. ์ด์ N/2๋ช ์ผ๋ก ์ด๋ฃจ์ด์ง ์คํํธ ํ๊ณผ ๋งํฌ ํ์ผ๋ก ์ฌ๋๋ค์ ๋๋ ์ผ ํ๋ค.
BOJ๋ฅผ ์ด์ํ๋ ํ์ฌ ๋ต๊ฒ ์ฌ๋์๊ฒ ๋ฒํธ๋ฅผ 1๋ถํฐ N๊น์ง๋ก ๋ฐฐ์ ํ๊ณ , ์๋์ ๊ฐ์ ๋ฅ๋ ฅ์น๋ฅผ ์กฐ์ฌํ๋ค. ๋ฅ๋ ฅ์น Sij๋ i๋ฒ ์ฌ๋๊ณผ j๋ฒ ์ฌ๋์ด ๊ฐ์ ํ์ ์ํ์ ๋, ํ์ ๋ํด์ง๋ ๋ฅ๋ ฅ์น์ด๋ค. ํ์ ๋ฅ๋ ฅ์น๋ ํ์ ์ํ ๋ชจ๋ ์์ ๋ฅ๋ ฅ์น Sij์ ํฉ์ด๋ค. Sij๋ Sji์ ๋ค๋ฅผ ์๋ ์์ผ๋ฉฐ, i๋ฒ ์ฌ๋๊ณผ j๋ฒ ์ฌ๋์ด ๊ฐ์ ํ์ ์ํ์ ๋, ํ์ ๋ํด์ง๋ ๋ฅ๋ ฅ์น๋ Sij์ Sji์ด๋ค.
N=4์ด๊ณ , S๊ฐ ์๋์ ๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ์ดํด๋ณด์.
i\j12341234
1 | 2 | 3 | |
4 | 5 | 6 | |
7 | 1 | 2 | |
3 | 4 | 5 |
์๋ฅผ ๋ค์ด, 1, 2๋ฒ์ด ์คํํธ ํ, 3, 4๋ฒ์ด ๋งํฌ ํ์ ์ํ ๊ฒฝ์ฐ์ ๋ ํ์ ๋ฅ๋ ฅ์น๋ ์๋์ ๊ฐ๋ค.
- ์คํํธ ํ: S12 + S21 = 1 + 4 = 5
- ๋งํฌ ํ: S34 + S43 = 2 + 5 = 7
1, 3๋ฒ์ด ์คํํธ ํ, 2, 4๋ฒ์ด ๋งํฌ ํ์ ์ํ๋ฉด, ๋ ํ์ ๋ฅ๋ ฅ์น๋ ์๋์ ๊ฐ๋ค.
- ์คํํธ ํ: S13 + S31 = 2 + 7 = 9
- ๋งํฌ ํ: S24 + S42 = 6 + 4 = 10
์ถ๊ตฌ๋ฅผ ์ฌ๋ฏธ์๊ฒ ํ๊ธฐ ์ํด์ ์คํํธ ํ์ ๋ฅ๋ ฅ์น์ ๋งํฌ ํ์ ๋ฅ๋ ฅ์น์ ์ฐจ์ด๋ฅผ ์ต์๋ก ํ๋ ค๊ณ ํ๋ค. ์์ ์์ ์ ๊ฐ์ ๊ฒฝ์ฐ์๋ 1, 4๋ฒ์ด ์คํํธ ํ, 2, 3๋ฒ ํ์ด ๋งํฌ ํ์ ์ํ๋ฉด ์คํํธ ํ์ ๋ฅ๋ ฅ์น๋ 6, ๋งํฌ ํ์ ๋ฅ๋ ฅ์น๋ 6์ด ๋์ด์ ์ฐจ์ด๊ฐ 0์ด ๋๊ณ ์ด ๊ฐ์ด ์ต์์ด๋ค.
์ ๋ ฅํ์
์ฒซ์งธ ์ค์ N(4 ≤ N ≤ 20, N์ ์ง์)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ S๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์ค์ N๊ฐ์ ์๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , i๋ฒ ์ค์ j๋ฒ์งธ ์๋ Sij ์ด๋ค. Sii๋ ํญ์ 0์ด๊ณ , ๋๋จธ์ง Sij๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค.
์ถ๋ ฅํ์
์ฒซ์งธ ์ค์ ์คํํธ ํ๊ณผ ๋งํฌ ํ์ ๋ฅ๋ ฅ์น์ ์ฐจ์ด์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์ ์ถ๋ ฅ ์์
ํ์ด ๊ณผ์
๋ฐฑํธ๋ ํน ๋ฌธ์ ์๋ค. ๋ง์ฝ ์ฌ๋์ด N ๋ช ์ด ์๋ค๋ฉด N ๋ช ์ค N/2๋ช ์ ๋ฝ๋ ์กฐํฉ ๋ฌธ์ ์๋ค. ์ด๊ธฐ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค ๊ตฌํ์ฌ backtracking ํด์ฃผ์์ง๋ง, ๊ณ์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค. ๊ทธ๋์ ๋ถํ์ํ ์กฐํฉ์ ๊ตฌํ๋ ๊ฒ์ ์ ์ธ์์ผ์ฃผ๋ ๊ฑธ ์๊ฐํด๋ด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด 0,1,3,4 ์ค 2๊ฐ๋ฅผ ๊ณ ๋ฅผ๋ [0,3] ๊ณผ [3,0]์ ๊ฐ์ ์ฌ๋์ ๋ฝ๋ ๊ฑฐ๋ ๊ฐ๊ธฐ ๋๋ฌธ์ ๋ฌด์กฐ๊ฑด ์๊ธฐ ์์ ๋ณด๋ค ๋์ ์ซ์์์๋ง ์กฐํฉ์ ๊ตฌํ๊ฒ ์์ ํด์ฃผ์๋ค.
+) ๋ฌธ์ ๋ ๊ธ๋ฐฉ ํ ์ ์์์ง๋ง ์๊ฐ์ด๊ณผ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ๋ฌด์ฒ์ด๋ ํ๋ค์๋ค ใ
์๊ฐ ์ค์ด๊ธฐ ์ํด ํ๋ ์ผ
1. sys.stdin.readline์ผ๋ก ์ ๋ ฅ๋ฐ๊ธฐ
2. n//2 ๋ฅผ ๋ณ์๋ก ์ ์ฅํด์ ์ฌ์ฉํ๊ธฐ
3. set() ํจ์๋ฅผ ์ด์ฉํ์ฌ link_team ๊ตฌํ๊ธฐ
4. start ํฉ๊ณ์ link ํฉ๊ณ ๊ตฌํ ๋ ์ด์ค for๋ฌธ ์ต๋ํ ์ค์ด๊ธฐ
import sys
import time
def backtracking(idx, start):
global min_value
if idx == number:
sum_value = 0
diff_value = 0
link_team = list((total- set(start_team)))
for i in range(number):
for j in range(i+1, number):
sum_value += power[start_team[i]][start_team[j]] + power[start_team[j]][start_team[i]]
diff_value += power[link_team[i]][link_team[j]] + power[link_team[j]][link_team[i]]
min_value = min(min_value, abs(sum_value-diff_value))
return
for i in range(start, n):
if check[i]:
continue
check[i] = True
start_team[idx] = i
backtracking(idx+1, i+1)
check[i] = False
if __name__ == '__main__':
start = time.time() # ์์ ์๊ฐ ์ ์ฅ
n = int(sys.stdin.readline())
number = n//2
power = []
total = set(range(0,n))
for i in range(n):
power.append(list(map(int,sys.stdin.readline().split())))
min_value = float('inf')
start_team = [0] * number
check = [False] * n
backtracking(0,0)
print(min_value)
print("time :", time.time() - start) # ํ์ฌ์๊ฐ - ์์์๊ฐ = ์คํ ์๊ฐ
'๐ Algorithm > ๐ช๐ป Python ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python - ๋ฐฑ์ค 2529] ๋ถ๋ฑํธ (0) | 2021.04.14 |
---|---|
[Python - ๋ฐฑ์ค 14501] ํด์ฌ (0) | 2021.04.14 |
[Python - ๋ฐฑ์ค 18290] NM๊ณผ K(1) (2) | 2021.04.14 |