5. 3. ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ(์นด์นด์ค)
๋ฌธ์
๊ฒ์๊ฐ๋ฐ์์ธ ์ฃ ๋ฅด๋๋ ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ธฐ๊ณ๋ฅผ ๋ชจ๋ฐ์ผ ๊ฒ์์ผ๋ก ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค.
์ฃ ๋ฅด๋๋ ๊ฒ์์ ์ฌ๋ฏธ๋ฅผ ๋์ด๊ธฐ ์ํด ํ๋ฉด ๊ตฌ์ฑ๊ณผ ๊ท์น์ ๋ค์๊ณผ ๊ฐ์ด ๊ฒ์ ๋ก์ง์ ๋ฐ์ํ๋ ค๊ณ ํฉ๋๋ค.
๊ฒ์ ํ๋ฉด์ 1 x 1 ํฌ๊ธฐ์ ์นธ๋ค๋ก ์ด๋ฃจ์ด์ง N x N ํฌ๊ธฐ์ ์ ์ฌ๊ฐ ๊ฒฉ์์ด๋ฉฐ ์์ชฝ์๋ ํฌ๋ ์ธ์ด ์๊ณ ์ค๋ฅธ์ชฝ์๋ ๋ฐ๊ตฌ๋๊ฐ ์์ต๋๋ค.
(์ ๊ทธ๋ฆผ์ 5 x 5 ํฌ๊ธฐ์ ์์์ ๋๋ค). ๊ฐ ๊ฒฉ์ ์นธ์๋ ๋ค์ํ ์ธํ์ด ๋ค์ด ์์ผ๋ฉฐ ์ธํ์ด ์๋ ์นธ์ ๋น์นธ์ ๋๋ค.
๋ชจ๋ ์ธํ์ 1 x 1 ํฌ๊ธฐ์ ๊ฒฉ์ ํ ์นธ์ ์ฐจ์งํ๋ฉฐ ๊ฒฉ์์ ๊ฐ์ฅ ์๋ ์นธ๋ถํฐ ์ฐจ๊ณก์ฐจ๊ณก ์์ฌ ์์ต๋๋ค.
๊ฒ์ ์ฌ์ฉ์๋ ํฌ๋ ์ธ์ ์ข์ฐ๋ก ์์ง์ฌ์ ๋ฉ์ถ ์์น์์ ๊ฐ์ฅ ์์ ์๋ ์ธํ์ ์ง์ด ์ฌ๋ฆด ์ ์์ต๋๋ค. ์ง์ด ์ฌ๋ฆฐ ์ธํ์ ๋ฐ๊ตฌ๋์ ์์ด๊ฒ ๋๋ ๋ฐ,
์ด๋ ๋ฐ๊ตฌ๋์ ๊ฐ์ฅ ์๋ ์นธ๋ถํฐ ์ธํ์ด ์์๋๋ก ์์ด๊ฒ ๋ฉ๋๋ค.
๋ค์ ๊ทธ๋ฆผ์ [1๋ฒ, 5๋ฒ, 3๋ฒ] ์์น์์ ์์๋๋ก ์ธํ์ ์ง์ด ์ฌ๋ ค ๋ฐ๊ตฌ๋์ ๋ด์ ๋ชจ์ต์ ๋๋ค.
๋ง์ฝ ๊ฐ์ ๋ชจ์์ ์ธํ ๋ ๊ฐ๊ฐ ๋ฐ๊ตฌ๋์ ์ฐ์ํด์ ์์ด๊ฒ ๋๋ฉด ๋ ์ธํ์ ํฐ๋จ๋ ค์ง๋ฉด์ ๋ฐ๊ตฌ๋์์ ์ฌ๋ผ์ง๊ฒ ๋ฉ๋๋ค.
์ ์ํ์์ ์ด์ด์ [5๋ฒ] ์์น์์ ์ธํ์ ์ง์ด ๋ฐ๊ตฌ๋์ ์์ผ๋ฉด ๊ฐ์ ๋ชจ์ ์ธํ ๋ ๊ฐ๊ฐ ์์ด์ง๋๋ค.
ํฌ๋ ์ธ ์๋ ์ ์ธํ์ด ์ง์ด์ง์ง ์๋ ๊ฒฝ์ฐ๋ ์์ผ๋ ๋ง์ฝ ์ธํ์ด ์๋ ๊ณณ์์ ํฌ๋ ์ธ์ ์๋์ํค๋ ๊ฒฝ์ฐ์๋ ์๋ฌด๋ฐ ์ผ๋ ์ผ์ด๋์ง ์์ต๋๋ค.
๋ํ ๋ฐ๊ตฌ๋๋ ๋ชจ๋ ์ธํ์ด ๋ค์ด๊ฐ ์ ์์ ๋งํผ ์ถฉ๋ถํ ํฌ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. (๊ทธ๋ฆผ์์๋ ํ๋ฉดํ์ ์ ์ฝ์ผ๋ก 5์นธ๋ง์ผ๋ก ํํํ์์)
๊ฒ์ ํ๋ฉด์ ๊ฒฉ์์ ์ํ๊ฐ ๋ด๊ธด 2์ฐจ์ ๋ฐฐ์ด board์ ์ธํ์ ์ง๊ธฐ ์ํด ํฌ๋ ์ธ์ ์๋์ํจ ์์น๊ฐ ๋ด๊ธด ๋ฐฐ์ด moves๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ํฌ๋ ์ธ์ ๋ชจ๋ ์๋์ํจ ํ ํฐํธ๋ ค์ ธ ์ฌ๋ผ์ง ์ธํ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์ฒซ ์ค์ ์์ฐ์ N(5<=N<=30)์ด ์ฃผ์ด์ง๋๋ค.
๋ ๋ฒ์งธ ์ค๋ถํฐ N*N board ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋๋ค.
board์ ๊ฐ ์นธ์๋ 0 ์ด์ 100 ์ดํ์ธ ์ ์๊ฐ ๋ด๊ฒจ์์ต๋๋ค.
0์ ๋น ์นธ์ ๋ํ๋ ๋๋ค.
1 ~ 100์ ๊ฐ ์ซ์๋ ๊ฐ๊ธฐ ๋ค๋ฅธ ์ธํ์ ๋ชจ์์ ์๋ฏธํ๋ฉฐ ๊ฐ์ ์ซ์๋ ๊ฐ์ ๋ชจ์์ ์ธํ์ ๋ํ๋ ๋๋ค.
board๋ฐฐ์ด์ด ๋๋ ๋ค์์ค์ moves ๋ฐฐ์ด์ ๊ธธ์ด M์ด ์ฃผ์ด์ง๋๋ค.
๋ง์ง๋ง ์ค์๋ moves ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋๋ค.
moves ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค.
moves ๋ฐฐ์ด ๊ฐ ์์๋ค์ ๊ฐ์ 1 ์ด์์ด๋ฉฐ board ๋ฐฐ์ด์ ๊ฐ๋ก ํฌ๊ธฐ ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ๋ ฅ
5
0 0 0 0 0
0 0 1 0 3
0 2 5 0 1
4 2 4 4 2
3 5 1 3 1
8
1 5 3 5 1 2 1 4
์ถ๋ ฅ
4
ํ์ด
ํ๋ก๊ทธ๋๋จธ์ค์์ ์ง๋๊ฐ๋ค ๋ณธ ๋ฌธ์ , ์นด์นด์ค ๋ฌธ์ + ๋ฌธ์ ๊ธธ์ด ๋๋ฌธ์ ์ด์ง ๊ฒ๋จน์์ง๋ง ์ฐจ๊ทผ์ฐจ๊ทผ ๋ฌธ์ ๋ฅผ ์ฝ๊ณ ์ดํดํ๋ ๊ฒ ๋ถํฐ ์์
1. moves์ ๋ด๊ธด ๊ฐ์ ์ด ๋ฒํธ(y)๋ก, 0-n ํ(x)์ ํ์ํ๋ฉด์
1.1. stack์ ์ต์๋จ ๊ฐ์ด board(x,y) ๊ฐ๊ณผ ์ผ์นํ๋ค๋ฉด -> stack.peek() ์ฌ์ฉํ๊ธฐ
1.1.1. ๊ฐ์ ์ธํ์ด๋ฏ๋ก ์ญ์ ํ๊ณ ์ฌ๋ผ์ง ์ธํ ๊ฐ์ +2 ํด์ฃผ๊ธฐ
1.2. 0์ด ์๋๋ฉด stack์ ์ธํ ๋ฃ์ด์ฃผ๊ธฐ -> push()
1.3. ์ธํ์ ๋ฃ์ด์คฌ์ผ๋ฉด ํด๋น board(x,y) ๊ฐ์ 0์ผ๋ก ์ด๊ธฐํ
1.4. ๋ค์ moves ๊ฐ์ผ๋ก ๋์ด๊ฐ์ผ ํจ
์ด๋ ๊ฒ ์ ๋ฆฌ ํ๋ค.
์ค๋ต ํ์ด
2์ฐจ์ ๋ฐฐ์ด์ด๋ผ๋ ๊ฒ์ ์ด์ค for๋ฌธ์ ๋๋ฉด์ ์์ํ๋ฉด ๋๊ฒ ์ง ์๊ฐํจ...
ํฌ๋ ์ธ ์๋์์น๋ก board๋ฅผ ์กฐํ ํ๊ธฐ ์ํด์๋
moves์ ๋ด๊ธด ๋ฒํธ๋ 1๋ถํฐ ์์ํ๊ณ ๋ฐฐ์ด ์ธ๋ฑ์ค๋ 0 ๋ถํฐ ์์ํ๋ -1์ ํด์ค์ผ ํ๋ค.
x์ขํ๋ฅผ ์ด๋ํ๋ ค๋ฉด ๋ค๋ฅธ ๋ณ์ ํ๋๊ฐ ๋ ํ์ํ๋ค๊ณ ์๊ฐ๋์ด์ k๋ฅผ ์ ์ํด์ x ์ขํ์ ๋ฃ์ด์ค...
๊ทธ๋ฆฌ๊ณ board์ ๊ฐ์ด 0์ด ์๋๋ฉด ์ธํ์ด ์๋ ๊ฑฐ๋๊น
๋ง์ฝ stack์ด ๋น์ด์์ง ์๊ณ ๊ฐ์ฅ ์ต๊ทผ์ ๋ฝ์์ธํ๊ณผ ํ์ฌ ๋ฝ์ ์ธํ์ด ๊ฐ๋ค๋ฉด
stack์์ ์ญ์ ํ๊ณ +2๋ฅผ ํด์ค
๋ค๋ฅธ ์ธํ์ด๋ฉด ๊ทธ๋ฅ stack์ push
๊ทธ๋ฆฌ๊ณ ๋ ๊ฒฝ์ฐ ๋ชจ๋ ์ธํ์ ๋ฝ์๊ฑฐ๋๊น ๊ทธ ์๋ฆฌ๋ฅผ 0์ผ๋ก ์ด๊ธฐํ ํ๊ณ
๋ค์ ํฌ๋ ์ธ ๋์ ๋ฒํธ๋ก ๊ฐ๊ธฐ ์ํด break๋ฅผ ๊ฑธ์ด ๋ฐ๋ณต๋ฌธ์ ๋ฉ์ท๋ค.
public int solution(int n, int[][] board, int m, int[] moves) {
int answer = 0;
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int y = moves[j] - 1;
int k = 0;
while (k < n) {
if (board[k][y] != 0) {
if (!stack.isEmpty() && stack.peek() == board[k][y]) {
stack.pop();
answer += 2;
} else {
stack.push(board[k][y]);
}
board[k][y] = 0;
break;
}
k++;
}
}
}
return answer;
}
์ด๋ ๊ฒ ํ์๋๋ฐ ํ ์คํธ ์ผ์ด์ค 1, 2๋ ํต๊ณผํ๋๋ฐ 3, 4, 5๋ ์ค๋ต์ผ๋ก ๋์ด
๋ค์ ๋ณด๋๊น board ๊ธธ์ด ๋งํผ ๋ฐ๋ณต๋๋ ์ฒซ๋ฒ์งธ for๋ฌธ์ i๋ ์ฌ์ฉํ์ง๋ ์๊ณ ์์๋ค.
์ฒซ๋ฒ์งธ for๋ฌธ ๋๋ฌธ์ moves๋ฅผ ๋ค ๋์์์๋ ๋ถ๊ตฌํ๊ณ n๋ฒ ๋ฐ๋ณตํ๊ณ ์์๋ค.
2์ฐจ์ ๋ฐฐ์ด์ด๋ผ๋ ์ด์ ๋ก ์ฐ์ ์ด์ค๋ฐ๋ณต๋ฌธ ๋๋ฆฌ๋ฉด์ ์์ํ์ -> ์ด๋ ๊ฒ ์๊ฐํ๊ณ ํ์ด๋ฅผ ์์ํด์ ์ผ์ค ๋ฐ๋ณต๋ฌธ์ ๋๋ฆฐ ๊ฒ์ด ๋ฌธ์ ์๋ค .. ๐ฅฒ
์ ๋ต ํ์ด
public int solution(int n, int[][] board, int m, int[] moves) {
int answer = 0;
Stack<Integer> stack = new Stack<>();
// moves : y์ขํ
for (int i = 0; i < m; i++) {
int pos = moves[i] - 1;
for (int j = 0; j < n; j++) { // x์ขํ ๋๋ฉด์ ์ธํ ์ฐพ๊ธฐ
// board์์ 0์ด ์๋๋ฉด ์ธํ
if (board[j][pos] != 0) {
// stack์ด ๋น์ด์์ง ์๊ณ stack์ ๊ฐ์ฅ ์ต๊ทผ ๊ฐ๊ณผ ํ์ฌ ๊ฐ์ด ๊ฐ์ ์ํ์ด๋ฉด ์ญ์
if (!stack.isEmpty() && stack.peek() == board[j][pos]) {
stack.pop();
answer += 2; // 2๊ฐ ์ญ์
} else {
// stack์ ๋ฃ๊ธฐ
stack.push(board[j][pos]);
}
// ์ฐพ์ผ๋ฉด 0 ์ผ๋ก ๋ณ๊ฒฝํ๊ณ break
board[j][pos] = 0;
break;
}
}
}
return answer;
}
์ฒซ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์์ moves๋ฅผ ๋๋ฉด์ y์ขํ๋ฅผ ๋ณ๊ฒฝํด์ฃผ๊ณ
x์ขํ๋ board์ ๊ธธ์ด๋งํผ ๋ฐ๋ณต๋ฌธ์ ๋๋ ค์ฃผ๋ฉด์ ์ธํ์ ๋ฝ์์ฃผ๋๋ก ํ๋ค.
์ด๋ ๊ฒ ํธ๋๊น ์ ๋ต ใ ใ ๐ฅบ
๋ฉ๋ชจ
- ๋ฐฐ์ด, ๋ฌธ์ ํ๊ธฐ ์ ๋ฐ๋ณต๋ฌธ ์กฐ๊ฑด ์ด๋ป๊ฒ ์ค์ ํด์ ์กฐํํด์ผํ ์ง ๊ณ ๋ฏผํ๊ธฐโ๏ธ