
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก์ Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์
์บ ํ์ฅ์ ํ
ํธ๋ฅผ ์น ์ ์๋ ๋์ ํ์ง๋ฅผ ์ ๊ณตํ๊ณ ์๋๋ฐ, ์ด ํ์ง์๋ ์ด๋ฏธ ์บ ํ์ฅ์์ ์ค์นํด ๋์ n๊ฐ์ ์๊ธฐ๊ฐ ๋ฐํ ์๋ค. ์บ ํ์ฅ ์ด์ฉ ๊ณ ๊ฐ์ ์ด ์๊ธฐ๋ค ์ค ํ ์์ ๊ณจ๋ผ ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋๋ก ํ
ํธ๋ฅผ ์ค์นํด์ผ ํ๋ค.
- ํ
ํธ๋ ์ง์ฌ๊ฐํ ํํ์ฌ์ผ ํ๋ค.
- ํ
ํธ์ ๋ค ๋ฉด์ด ์ ํํ๊ฒ ๋, ์, ๋จ, ๋ถ์ ํฅํด์ผ ํ๋ค.
- ๋๊ฐ์ ์์นํ๋ ํ
ํธ์ ๋ ๊ผญ์ง์ ์ด ์ ํํ๊ฒ ์ ํํ ๋ ๊ฐ์ ์๊ธฐ์ ์์นํด์ผ ํ๋ค.
- ํ
ํธ๊ฐ ์ ์ ํ๋ ์ง์ฌ๊ฐํ ์์ญ์ ๋์ด๋ 0๋ณด๋ค๋ ์ปค์ผ ํ๋ค.
- ํ
ํธ๊ฐ ์ ์ ํ๋ ์ง์ฌ๊ฐํ ์์ญ ๋ด๋ถ์ ๋ค๋ฅธ ์๊ธฐ๋ฅผ ํฌํจํ๋ฉด ์ ๋๋ค. (๋ค๋ฅธ ์๊ธฐ๊ฐ ๊ฒฝ๊ณ์ ์์นํ๋ ๊ฒฝ์ฐ๋ ํ์ฉํจ)
- ์บ ํ์ฅ์์๋ ์์ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์น๋ผ๋ฉด ์ด๋๋ ๊ณ ๊ฐ์ด ํ
ํธ๋ฅผ ์ค์นํ ์ ์๋๋ก ์ ํํ ํฌ๊ธฐ์ ํ
ํธ๋ฅผ ๋ชจ๋ ๊ตฌ๋นํ์ฌ ๋์ฌํด์ค๋ค๊ณ ํ๋ค.
๋น์ ์ ์์ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํ
ํธ๋ฅผ ์ค์นํ ์ ์๋ ์๊ธฐ์ ์์ ๊ฐ์๋ ์ด ๋ช ๊ฐ์ง๊ฐ ๋ ์ง ๊ถ๊ธํด์ก๋ค.
n๊ฐ์ ์๊ธฐ์ ์์น๊ฐ ์ขํ๋ก ์ฃผ์ด์ง ๋, ์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์๊ธฐ์ ์์ ๊ฐ์๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋จ, ๋์ ๋ฐฉํฅ์ x์ถ, ๋จ๋ถ ๋ฐฉํฅ์ y์ถ๊ณผ ํํํ๋ค๊ณ ๊ฐ์ ํ๋ค.
์์ ์ ์ถ๋ ฅ
| n | data | answer |
| 4 | [[0, 0], [1, 1], [0, 2], [2, 0]] | 3 |
ํ์ด
๋จผ์ ๋ ๊ฐ์ ์๊ธฐ๋ฅผ ๋น๊ตํด์ผํ๊ธฐ ๋๋ฌธ์ ์ด์ค for๋ฌธ์ ์ฌ์ฉํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฐฉํฅ์ ์ฝ๊ฒ ์ ํ๊ธฐ ์ํด x์ขํ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํฉ๋๋ค.

๋ง์ฝ ์๊ธฐ๊ฐ ์์ ํํ๋ก ์ ๊ณต๋์๋ค๋ฉด ์ ๋ ฌ ํ์๋ ์๋์ ๊ฐ์ต๋๋ค.
[[1, 0], [3, 2], [2, 1], [0, 1]] // ์ ๋ ฌ ์
[[0, 1], [1, 0], [2, 1], [3, 2]] // ์ ๋ ฌ ํ
๊ธฐ์ค(src) ์๊ธฐ ์ํ๋ฅผ i, ํ๊ฒ(tgt)์๊ธฐ ์ํ๋ฅผ j์ผ ๋ j๋ ์ธ์ ๋ i+1๋ถํฐ size๋งํผ ์ํํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ๊ธฐ์ค์๊ธฐ์ ๊ฐ์ X์ขํ์ด๊ฑฐ๋ ๊ฐ์ Y์ขํ์ธ ๊ฒฝ์ฐ์๋ ์ง์ฌ๊ฐํ์ผ๋ก ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ ๊ฑด๋๋๋๋ค.
#include <bits/stdc++.h>
using namespace std;
int solution(int n, vector<vector<int>> data) {
// ์ ๋ ฌ(x๊ฐ ๊ฐ์ผ๋ฉด y์ขํ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ)
sort(data.begin(), data.end(), [](const vector<int>& a, const vector<int>& b){
if (a[0] == b[0])
return a[1] < b[1];
return a[0] < b[0];
});
int answer = 0;
for (int i = 0; i < n; i++) {
const int srcX = data[i][0];
const int srcY = data[i][1];
for (int j = i+1; j < n; j++) {
const int tgtX = data[j][0];
const int tgtY = data[j][1];
int diffX = tgtX - srcX;
int diffY = tgtY - srcY;
if (diffX == 0 || diffY == 0)
continue;
...
...
์์ ์ด๋ฏธ์ง์ ์๊ธฐ์์๋ C ์๊ธฐ๊ฐ A์ B๋ก ๊ตฌ์ฑ๋ ํ ํธ์ ํฌํจ๋๊ธฐ ๋๋ฌธ์ ์ด ๋ถ๋ถ์ ๊ฐ์ํด์ ์งํํด์ผ ํฉ๋๋ค. ์ฆ, ์ง์ฌ๊ฐํ์ ๊ตฌ์ฑํ ๋ ๋ ๋ค๋ฅธ ์๊ธฐ๊ฐ ์ง์ฌ๊ฐํ ํ ํธ์ ํฌํจ๋์ด ์๋์ง ์ฒดํฌํ๋ ํ๋ก์ธ์ค๊ฐ ๋ฐ๋์ ํ์ํฉ๋๋ค.
์ดํ i์ j ์ฌ์ด์ ์๋ ์๊ธฐ๋ค์ด ์ง์ฌ๊ฐํ ์์ ์์นํ๋์ง k(ํ๋ฒ ๋ ๋ฐ๋ณต)๋ฅผ ํตํด ์ฐพ์ต๋๋ค. i์ j ์ฌ์ด์ k ์๊ธฐ๊ฐ ๋ปํ๋ ๊ฒ์ ๋ง๋๋ ค๋ ์ง์ฌ๊ฐํ ํ ํธ ๋ด ๋ ๋ค๋ฅธ ์๊ธฐ๊ฐ ์๋์ง ์ฒดํฌํ๋ ์๋ฏธ์ ๋๋ค. ์ด๋ฏธ data๋ x ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ๋์ด ์๊ธฐ ๋๋ฌธ์ i์ j ์ฌ์ด๋ง ๋ณด๋ฉด ๋ฉ๋๋ค.
ํค ํฌ์ธํธ๋ k๋ผ๊ณ ๋ณผ ์ ์์ต๋๋ค. ์ด๋ฏธ ๋ง๋ค์ด์ง ์ง์ฌ๊ฐํ์ ๋ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ ์ฅํด์ ๋น๊ตํ๊ธฐ๋ ํ๋๋ฐ, ์ด๋ ์ฝ๋ ๋ณต์ก๋๋ฅผ ๋๋ฌด ๋๋ฆฌ๊ธฐ๋ ํ๊ณ ๊ฒฝ์ฐ์ ๋ฐ๋ผ ์๋ฌ๋ฅผ ๋ฐ์์ํฌ ์๋ ์๊ธฐ ๋๋ฌธ์ ์ง์ฌ๊ฐํ ๋ด ๋ค๋ฅธ ์๊ธฐ ํ์ ๋ฐฉ๋ฒ์ด ๋ ์ข์ต๋๋ค.
์ ๋ต ์ฝ๋
#include <bits/stdc++.h>
using namespace std;
int solution(int n, vector<vector<int>> data) {
sort(data.begin(), data.end(), [](const vector<int>& a, const vector<int>& b){
if (a[0] == b[0])
return a[1] < b[1];
return a[0] < b[0];
});
int answer = 0;
for (int i = 0; i < n; i++) {
const int srcX = data[i][0];
const int srcY = data[i][1];
for (int j = i+1; j < n; j++) {
const int tgtX = data[j][0];
const int tgtY = data[j][1];
int diffX = tgtX - srcX;
int diffY = tgtY - srcY;
if (diffX == 0 || diffY == 0)
continue;
int minY = min(srcY, tgtY);
int maxY = max(srcY, tgtY);
bool flag = true;
for (int k = i+1; k<j; k++) {
int x = data[k][0];
int y = data[k][1];
if (x > srcX && x < tgtX && y > minY && y < maxY) {
flag = false;
break;
}
}
if (flag)
answer++;
}
}
return answer;
}'์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [๋ฌธ์ ํ์ด/ํ๋ก๊ทธ๋๋จธ์ค] ์์ ์์ถ(feat. BFS) (0) | 2025.10.27 |
|---|---|
| [DFS] ์ฌ๊ท์ ์คํ์ผ๋ก ๊ฐ๋ณ๊ฒ ๋ฌธ์ ํ๊ธฐ (1) | 2025.05.16 |
| [์คํ, ํ] ๋ฐฑํธ๋ํน(์ด์ ์ํ ๊ธฐ์ต)์ ์คํ์ ํ์ฉํ์ธ์ (0) | 2025.05.11 |
| [์ฐ์ ์์ ํ] ์ต์๊ฐ or ์ต๋๊ฐ ์ฐพ๊ธฐ ์๊ณ ๋ฆฌ์ฆ(feat. deque) (0) | 2025.04.13 |
| [๊ธฐ๋ณธ] ํฌ ํฌ์ธํฐ (0) | 2025.03.25 |