ํ์ด ๋ฐฉ๋ฒ
์งํฉ P๋ n๊ฐ์ ์ ๋ค์ ์งํฉ์ด๊ณ , P์ ๋ฒกํฐ ๋งค์นญ์ P์ ๋ชจ๋ ์ ์ ํ ๋ฒ์ฉ ์ฌ์ฉํ์ฌ ๋ง๋ ๋ฒกํฐ์ ์งํฉ์ด๋ค. ์ฆ,
$P = {(x_1, y_1), (x_2, y_2), \dots , (x_n, y_n)}$
$VM = {(x_i - x_j,\space y_i - y-j)\space|\space 1 \le i, j \le n, i \ne j }$
๋ฐ๋ผ์ ๋ฒกํฐ ๋งค์นญ์ ์ํ๋ ๋ชจ๋ ๋ฒกํฐ์ ํฉ์ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํ ์ ์๋ค.
$v_1 = (x_2 - x_1, \space y_2 - y_1)$
$v_2 = (x_4 - x_3, \space y_4 - y_3)$
$ \dots $
$v_{n/2} = (x_n - x_{n-1}, \space y_n - y_{n-1})$
$v_1 + v_2 + ... + v_{n/2} =
((x_2 + x_4 + ... + x_n) - (x_1 + x_3 + ... + x_{n-1}),\space
(y_2 + y_4 + ... + y_n) - (y_1 + y_3 + ... + y_{n-1}))$
$v_1 + v_2 + ... + v_{n/2} =
\sum_{k=1}^n x_k - 2\sum_{k=1}^n x_{2k-1},\space
\sum_{k=1}^n y_k - 2\sum_{k=1}^n y_{2k-1})$
์ด๋ ๊ฐ๋ฅํ ๋ฒกํฐ ๋งค์นญ์ ๊ฐ์ง์๋ ์งํฉ P์์ $N/2$ ๊ฐ์ ์ถ๋ฐ์ ์ ์ ํํ๋ ๊ฒฝ์ฐ์ ์์ ๊ฐ์ผ๋ฏ๋ก, ํด๋น ๊ฒฝ์ฐ๋ฅผ ๋ชจ๋ ํ์ํ์ฌ ๋ฒกํฐํฉ์ ๊ธธ์ด์ ์ต์๊ฐ์ ์ฐพ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค. ๋ฐ๋ผ์ Brute Force๋ก ํ์ํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์๋ ์ต๋ $nC{n/2}$ ์ด๋ค.
๋ค์๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ๊ฐ๋จํ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํด ๋ณผ ์ ์๋ค.
- ์งํฉ P์ ๋ชจ๋ ์ ์ ๋ํด x์ขํ๋ผ๋ฆฌ, y์ขํ๋ผ๋ฆฌ ๊ฐ๊ฐ ๋ํ ๊ฐ์ ์ ์ฅํ๋ค.
- ์งํฉ P์์ ๋ฒกํฐ์ ์ถ๋ฐ์ ์ ํด๋นํ๋ N/2๊ฐ์ ์ ์ ์ ํํ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฆฌ์คํธ์ ์ ์ฅํ๋ค.
- 2์์ ์ ์ฅ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์์ ๋ํด, ํด๋น ๊ฒฝ์ฐ์์ ๋ฐ์ํ๋ ๋ฒกํฐ ํฉ์ ๊ธธ์ด๋ฅผ ์ฐ์ฐํด ์ด์ ์ ์ต์๊ฐ๊ณผ ๋น๊ตํ์ฌ ๋ ์์ ๊ฒฝ์ฐ ์ต์๊ฐ์ ๊ฐฑ์ ํ๋ค. ๋ฒกํฐ ํฉ์ 1์์ ์ ์ฅ๋ x์ขํ, y์ขํ์ ์ดํฉ์์ ์ถ๋ฐ์ ์ x์ขํ ํฉ,y์ขํ ํฉ์ ๋ ๋ฒ์ฉ ๋นผ์ ๊ณ์ฐํ๋ค.
- 2์์ ์ ์ฅ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ํ์์ด ์ข ๋ฃ๋๋ฉด ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์ํ์ฐฉ์ค
- ๋ฌธ์ ๋ฅผ ์ ํํ ์ดํดํ๋ ๋ฐ ์๊ฐ์ด ๊ฝค ๊ฑธ๋ ธ๋ค. ์ฒ์์๋ ์งํฉ P์์ ๋ง๋ค์ด์ง ์ ์๋ ๋ชจ๋ ๋ฒกํฐ๋ฅผ ๊ตฌํ๊ณ ์ ํ๋๋ฐ, ๋ฒกํฐ์ ๊ฐ์๊ฐ ์ ์ ๊ฐ์์ ์ ๋ฐ์ด๋ผ๋ ์ ์ ์ ๋๋ก ์ฒดํฌํ๋ค๋ฉด ๋ณด๋ค ๋น ๋ฅด๊ฒ ํ์ดํ ์ ์์ง ์์๋ ์ถ๋ค.
- ์ฒซ ๋ฒ์จฐ ์ ๊ทผ์์๋ ํฉํ ๋ฆฌ์ผ ์์ค์ ์๊ฐ ๋ณต์ก๋๊ฐ ๋์์ผ๋.. ๋๋ถ๋ถ์ ๋ฌธ์ ๋ ํฉํ ๋ฆฌ์ผ ์๊ณ ๋ฆฌ์ฆ์ 1์์ ํด๊ฒฐ์ฑ ์ผ๋ก ๋์ง ์๋๋ค๋ ์ฌ์ค์ ์ ๊ธฐ์ตํด์ผ ํ๋ค. ์ถ๋ฐ์ ์ ์ ํํ๋ฉด (๋ชจ๋ ์ ์ ํ ๋ฒ์ฉ ์ฌ์ฉํด์ผ ํ๋ฏ๋ก) ๋์ฐฉ์ ๋ ์๋์ผ๋ก ์ ํ๋๋ค๋ ์ ์ด ํคํฌ์ธํธ์๋ค.
์ ์ฒด ์ฝ๋
from itertools import combinations
import math
T = int(input())
for _ in range(T):
N = int(input())
P = [(0, 0) for _ in range(N)]
xsum, ysum = 0, 0
for i in range(N):
x, y = map(int, input().split())
xsum += x
ysum += y
P[i] = (x,y)
cases = list(combinations(P, N // 2))
min = -1
for case in cases: # NC(N/2)
vsum = [xsum, ysum]
for point in case:
vsum[0] -= (2 * point[0])
vsum[1] -= (2 * point[1])
length = math.sqrt(pow(vsum[0], 2) + pow(vsum[1], 2))
if (length < min or min < 0):
min = length
print(min)
'DevLog ๐จ > Baekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[DevLog][Baekjoon] 8983: ์ฌ๋ฅ๊พผ (0) | 2023.08.16 |
---|---|
[DevLog][Baekjoon] 2110: ๊ณต์ ๊ธฐ ์ค์น (0) | 2023.08.16 |
[DevLog][Baekjoon] 2261: ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ์ (0) | 2023.08.14 |
[DevLog][Baekjoon] 1629: ๊ณฑ์ (0) | 2023.08.14 |
[BaekJoon] 1005: ACM Craft (0) | 2023.02.14 |