ํ์ด ๋ฐฉ๋ฒ
์งํฉ P๋ n๊ฐ์ ์ ๋ค์ ์งํฉ์ด๊ณ , P์ ๋ฒกํฐ ๋งค์นญ์ P์ ๋ชจ๋ ์ ์ ํ ๋ฒ์ฉ ์ฌ์ฉํ์ฌ ๋ง๋ ๋ฒกํฐ์ ์งํฉ์ด๋ค. ์ฆ,
P=(x1,y1),(x2,y2),โฆ,(xn,yn)P=(x1,y1),(x2,y2),โฆ,(xn,yn)
VM=(xiโxj, yiโyโj) | 1โคi,jโคn,iโ jVM=(xiโxj, yiโyโj) | 1โคi,jโคn,iโ j
๋ฐ๋ผ์ ๋ฒกํฐ ๋งค์นญ์ ์ํ๋ ๋ชจ๋ ๋ฒกํฐ์ ํฉ์ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํ ์ ์๋ค.
v1=(x2โx1, y2โy1)v1=(x2โx1, y2โy1)
v2=(x4โx3, y4โy3)v2=(x4โx3, y4โy3)
โฆโฆ
vn/2=(xnโxnโ1, ynโynโ1)vn/2=(xnโxnโ1, ynโynโ1)
v1+v2+...+vn/2=((x2+x4+...+xn)โ(x1+x3+...+xnโ1), (y2+y4+...+yn)โ(y1+y3+...+ynโ1))v1+v2+...+vn/2=((x2+x4+...+xn)โ(x1+x3+...+xnโ1), (y2+y4+...+yn)โ(y1+y3+...+ynโ1))
v1+v2+...+vn/2=โnk=1xkโ2โnk=1x2kโ1, โnk=1ykโ2โnk=1y2kโ1)v1+v2+...+vn/2=โnk=1xkโ2โnk=1x2kโ1, โnk=1ykโ2โnk=1y2kโ1)
์ด๋ ๊ฐ๋ฅํ ๋ฒกํฐ ๋งค์นญ์ ๊ฐ์ง์๋ ์งํฉ P์์ N/2 ๊ฐ์ ์ถ๋ฐ์ ์ ์ ํํ๋ ๊ฒฝ์ฐ์ ์์ ๊ฐ์ผ๋ฏ๋ก, ํด๋น ๊ฒฝ์ฐ๋ฅผ ๋ชจ๋ ํ์ํ์ฌ ๋ฒกํฐํฉ์ ๊ธธ์ด์ ์ต์๊ฐ์ ์ฐพ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค. ๋ฐ๋ผ์ Brute Force๋ก ํ์ํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์๋ ์ต๋ nCn/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 |