โถ ์ ํ
- ๋งจํดํผ ๊ฑฐ๋ฆฌ(Manhattan Distance)๋ ๋์ ๋ธ๋ก์ ๋ฐ๋ผ ์ด๋ํ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ์์ด๋ค.
- ์ํ์์์ ๊ฑฐ๋ฆฌ ๊ณต์์ด๋์ ๋ค๋ฅธ๋ฐ, |x1 - x2| + |y1 - y2| ๋ก ๋ ์ ์ฌ์ด์ x์ขํ ์ฐจ์ด์ ์ ๋๊ฐ๊ณผ y์ขํ ์ฐจ์ด์ ์ ๋๊ฐ์ ํฉ์ ๋งจํดํผ ๊ฑฐ๋ฆฌ๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์ฆ ๊ฒฉ์ํ ๊ตฌ์กฐ์์์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ฉด ๋๋ ๊ฑฐ๋๊น ์ขํํ๋ฉด์ด๋ ๋๊ฐ์ ์ ๊ณ ๋ คํ์ง์๋ ์ํฉ์์ ์ ์ฉํ ์์์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
- ๊ทผ๋ฐ ์ด๊ฑธ ์ฌ๋ฌ ์ ๋ค ์ฌ์ด์์ ๋งจํดํผ ๊ฑฐ๋ฆฌ ์ต์ ํฉ์ ๊ตฌํ๋ ค๋ฉด ์ค์๊ฐ์ ์ ํํ๋ฉด ๋๋ค.
โถ ์ ๋ต
1์ฐจ์, 2์ฐจ์์ผ๋ก ๋๋ ์ ๋ณด๊ฒ ๋ค.
1์ฐจ์์์ ์ฌ๋ฌ ์ ๋ค๋ก๋ถํฐ์ ๋งจํดํผ ๊ฑฐ๋ฆฌ ํฉ์ด ์ต์๊ฐ ๋๋ ์ง์ ์ด ์ค์๊ฐ์ธ ์ด์ ๋ฅผ ์์๋ณด์.
์ํ์ ์ n๊ฐ์ ์ xโ, xโ, ..., xโ์ด ์์ ๋, ๊ฑฐ๋ฆฌ ํฉ์ ์๊ฐํด๋ณธ๋ค๋ฉด
- p๊ฐ ์ด๋ค ์ xแตข๋ณด๋ค ์์ผ๋ฉด: -1 ๊ธฐ์ฌ
- p๊ฐ ์ด๋ค ์ xแตข๋ณด๋ค ํฌ๋ฉด: +1 ๊ธฐ์ฌ
๋ผ๊ณ ๋ณผ ์ ์๋ค. ๊ทธ๋์ ๊ฒฐ๊ตญ ์ต์ ๊ฐ์ ์ฐพ๊ธฐ ์ํด์๋ ๊ธฐ์ค ์ ์ ์ค์ฌ์ผ๋ก ์์ ์ ๋ค์ ๊ฐ์, ํฐ ์ ๋ค์ ๊ฐ์๊ฐ ๊ฐ์ ์ง์ ์ ๋์ผํ๋๋ฐ, ์ด ๋ง์ ๊ณง ์ค์๊ฐ์ด๋ผ๋ ์๊ธฐ๊ฐ๋๋ค.
๋ค์ ๋งํ์๋ฉด, ์ํ์ ์์
์ค์๊ฐ์์ ์ผ์ชฝ์ผ๋ก ์ด๋ํ ๊ฒฝ์ฐ ์ผ์ชฝ ์ ๋ค๊ณผ์ ๊ฑฐ๋ฆฌ๋ ์ค์ง๋ง, ์ค๋ฅธ์ชฝ ์ ๋ค๊ณผ์ ๊ฑฐ๋ฆฌ๊ฐ ๋ ๋ง์ด ์ฆ๊ฐํ๊ณ
์ค์๊ฐ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋: ์ค๋ฅธ์ชฝ ์ ๋ค๊ณผ์ ๊ฑฐ๋ฆฌ๋ ์ค์ง๋ง, ์ผ์ชฝ ์ ๋ค๊ณผ์ ๊ฑฐ๋ฆฌ๊ฐ ๋ ๋ง์ด ์ฆ๊ฐํ๋ค.
๊ทธ๋์ ์ค์๊ฐ์ด ์ด ๋ ์ต์ ์ ์ด ๋๋ ๊ฒ์ด๋ค!
๊ทธ๋ผ 2์ฐจ์์ผ๋ก ๊ฐ๋ณด์
2์ฐจ์์ ์ํ์ ์ด ๋จ์ํ 2๊ฐ ์๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค. ๊ณง x์ถ๊ณผ y์ถ์ด ๋ ๋ฆฝ์ ์ผ๋ก ์กด์ฌํ๊ณ , ๊ฐ๊ฐ์ ์ถ์ ๊ธฐ์ค์ผ๋ก 1์ฐจ์ ๋งจํดํผ ๊ฑฐ๋ฆฌ ์ต์ ์ ์ฐพ๋ฏ ํ๋ฉด ๋๋ค.
์ฆ x์ขํ์ ์ค์๊ฐ๊ณผ y์ขํ์ ์ค์๊ฐ์ด ๋ง๋๋ ์ ์ด ์ ์ฒด ์ต์ ํด๋ผ๊ณ ์๊ฐํ ์ ์๋ค.
๋ฐ๋ก ๋ฌธ์ ํ์ด๋ณด์.
https://www.acmicpc.net/problem/18310
1์ฐจ์ ๋งจํดํผ ๊ฑฐ๋ฆฌ ํฉ ์ต์ ์ ์ ์ฐพ๋ ๋ฌธ์ ๋ค.
๋ ์ฒ์์ ์ด๋ ๊ฒ ์์ฑํ๋ค๊ฐ ๋ฐ๋ก ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ๋ค.
public static void go() {
int[] target = new int[n];
for (int i = 0; i < n; i++) {
target[i] = point[i];
}
Arrays.sort(target);
int min = Integer.MAX_VALUE;
int minT = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int center = (target[j] + point[i]) / 2;
int dist = 0;
for (int k = 0; k < n; k++) {
int d = Math.abs(point[k] - center);
dist += d;
}
if (min > dist) {
min = dist;
minT = center;
}
// System.out.println("dist: " + dist + " minT: " + minT + " center: " + center);
// System.out.println();
}
}
}
์ง์ง ์์ ํ์ ๋ฐฉ์์ผ๋ก ํผ๊ฑด๋ฐ ์ด๋ ๊ฒ ํ๋ฉด ๋ณด๋ค์ํผ O(n^3)์ด๋ค.
n์ด 20๋ง์ด๋ผ ์ ๋ ์ด๋ ๊ฒ ํ๋ฉด ์๋๋ค.
์ํ์ ์ต์ ์ ์ ์๊ฐํ๋ฉฐ ๋ค์ ํ๋ฉด ์๋์ ๊ฐ์ด ์งง์ ํ์ด๊ฐ ์์ฑ๋๋ค.
public static void go() {
Arrays.sort(point);
System.out.println(point[(n - 1) / 2]);
}
์ด๊ฑธ 2์ฐจ์์ผ๋ก ๋ค๊ณ ๊ฐ๋ฉด ์๋ ๋ฌธ์ ๊ฐ ๋๋ค.
https://www.acmicpc.net/problem/1090
์ฒ์์ ์ค์๊ฐ์ด ํญ์ ์ต์ ์ธ ์ด์ ๋ฅผ ๋ชจ๋ฅด๊ณ , ์ฃผ์ด์ง ์ ์ ํ์ฉํด์ ๊ฑฐ๋ฆฌํฉ์ ๊ตฌํ๋ค. ์ด๋ ๊ฒํ๋ฉด ์ฒซ๋ฒ์งธ ์์์์ 0 2 4 6์ด ๋์ค๋ฉฐ ํ๋ฆฐ ๋ต๋ง ๋ด๋๋๋ค.
๊ทธ๋์ x ์ถ, y ์ถ์ ๋ถ๋ฆฌํด ๊ฐ ์ขํ๋ฅผ ๋ผ์ด๋ด์ด ์กฐํฉํด์ผ๋๋ค.
์ฒ์ ์์ฑํ ๋ ์ค์๊ฐ ๋น๊ต๋ฅผ ์๊ฐํ์ง ๋ชปํด์ ๊ณ์ ํ๋ ธ๋ค.
public static void go() {
for (int k = 1; k <= n; k++) {
// k์ผ๋ ์ต์๊ฑฐ๋ฆฌํฉ
int res = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int centerX = checker[i][0]; // ์ ๋์์ X
int centerY = checker[j][1]; // ๋น๊ต ๋์์ Y
int[] dist = new int[n];
for (int p = 0; p < n; p++) {
dist[p] = Math.abs(checker[p][0] - centerX) + Math.abs(checker[p][1] - centerY);
}
// System.out.println(Arrays.toString(dist));
Arrays.sort(dist);
int sum = 0;
for (int d = 0; d < k; d++) {
sum += dist[d];
}
res = Math.min(res, sum);
}
}
sb.append(res).append(" ");
}
}
์๋์์ X์ขํ, ๋น๊ต ๋์์ Y์ขํ๋ฅผ ๊ธฐ์ค์ผ๋ก ํด์ ๋งจํดํผ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ฉฐ k ๋งํผ์ ํฉ์ ๊ณ์ ๋ง๋ค์ด๊ฐ๋ฉด ๋๋ ๋ฌธ์ ๋ค. ๋๋ ๋์ด๋๋ฅผ ๋ชจ๋ ๊ฐ๋ฆฌ๊ณ ํ๊ธฐ ๋๋ฌธ์ ์ด๊ฒ ํ๋ ๋ผ๋ ๊ฑธ ์๊ณ ์ข ๋๋๋ค.
๋์์ด ๋๋ค๋ฉด ๋๊ธ์ด๋ ๊ณต๊ฐ ๋ฒํผ ํ ๋ฒ์ฉ ๋๋ฅด๊ณ ๊ฐ์ฃผ์ธ์!
'OJ๐ผ > ์๊ณ ๋ฆฌ์ฆ ์ ํ ์ ๋ฆฌ๐' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ชจ๋ ธํค์คํ(๋จ์กฐ์คํ)โฐ (0) | 2025.01.07 |
---|---|
โ๏ธ์ด์งํ์ - BinarySearch(feat. ํ๋ผ๋ฉํธ๋ฆญ ์์น) (0) | 2024.07.16 |
์ ๋ ฌ - Comparable<T> ~ compareTo(T o1) (0) | 2024.05.29 |
Dynamic Programming์ด ์์ธ DFSโ๏ธ - ๋ด๋ฆฌ๋ง๊ธธ, ์์ฌ์์ด ํ๋ค๐ผ (0) | 2024.04.07 |
์ ๋ ฌโ๏ธ- ์์์ ๋ ฌ (0) | 2024.04.04 |