[ํ๋ก๊ทธ๋๋จธ์ค] ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์
https://programmers.co.kr/learn/courses/30/lessons/64061
๋ฌธ์ ์ค๋ช
๊ฒ์๊ฐ๋ฐ์์ธ "์ฃ ๋ฅด๋"๋ ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ธฐ๊ณ๋ฅผ ๋ชจ๋ฐ์ผ ๊ฒ์์ผ๋ก ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค.
"์ฃ ๋ฅด๋"๋ ๊ฒ์์ ์ฌ๋ฏธ๋ฅผ ๋์ด๊ธฐ ์ํด ํ๋ฉด ๊ตฌ์ฑ๊ณผ ๊ท์น์ ๋ค์๊ณผ ๊ฐ์ด ๊ฒ์ ๋ก์ง์ ๋ฐ์ํ๋ ค๊ณ ํฉ๋๋ค.
๊ฒ์ ํ๋ฉด์ "1 x 1" ํฌ๊ธฐ์ ์นธ๋ค๋ก ์ด๋ฃจ์ด์ง "N x N" ํฌ๊ธฐ์ ์ ์ฌ๊ฐ ๊ฒฉ์์ด๋ฉฐ ์์ชฝ์๋ ํฌ๋ ์ธ์ด ์๊ณ ์ค๋ฅธ์ชฝ์๋ ๋ฐ๊ตฌ๋๊ฐ ์์ต๋๋ค. (์ ๊ทธ๋ฆผ์ "5 x 5" ํฌ๊ธฐ์ ์์์ ๋๋ค). ๊ฐ ๊ฒฉ์ ์นธ์๋ ๋ค์ํ ์ธํ์ด ๋ค์ด ์์ผ๋ฉฐ ์ธํ์ด ์๋ ์นธ์ ๋น์นธ์ ๋๋ค. ๋ชจ๋ ์ธํ์ "1 x 1" ํฌ๊ธฐ์ ๊ฒฉ์ ํ ์นธ์ ์ฐจ์งํ๋ฉฐ ๊ฒฉ์์ ๊ฐ์ฅ ์๋ ์นธ๋ถํฐ ์ฐจ๊ณก์ฐจ๊ณก ์์ฌ ์์ต๋๋ค. ๊ฒ์ ์ฌ์ฉ์๋ ํฌ๋ ์ธ์ ์ข์ฐ๋ก ์์ง์ฌ์ ๋ฉ์ถ ์์น์์ ๊ฐ์ฅ ์์ ์๋ ์ธํ์ ์ง์ด ์ฌ๋ฆด ์ ์์ต๋๋ค. ์ง์ด ์ฌ๋ฆฐ ์ธํ์ ๋ฐ๊ตฌ๋์ ์์ด๊ฒ ๋๋ ๋ฐ, ์ด๋ ๋ฐ๊ตฌ๋์ ๊ฐ์ฅ ์๋ ์นธ๋ถํฐ ์ธํ์ด ์์๋๋ก ์์ด๊ฒ ๋ฉ๋๋ค. ๋ค์ ๊ทธ๋ฆผ์ [1๋ฒ, 5๋ฒ, 3๋ฒ] ์์น์์ ์์๋๋ก ์ธํ์ ์ง์ด ์ฌ๋ ค ๋ฐ๊ตฌ๋์ ๋ด์ ๋ชจ์ต์ ๋๋ค.
๋ง์ฝ ๊ฐ์ ๋ชจ์์ ์ธํ ๋ ๊ฐ๊ฐ ๋ฐ๊ตฌ๋์ ์ฐ์ํด์ ์์ด๊ฒ ๋๋ฉด ๋ ์ธํ์ ํฐ๋จ๋ ค์ง๋ฉด์ ๋ฐ๊ตฌ๋์์ ์ฌ๋ผ์ง๊ฒ ๋ฉ๋๋ค. ์ ์ํ์์ ์ด์ด์ [5๋ฒ] ์์น์์ ์ธํ์ ์ง์ด ๋ฐ๊ตฌ๋์ ์์ผ๋ฉด ๊ฐ์ ๋ชจ์ ์ธํ ๋ ๊ฐ๊ฐ ์์ด์ง๋๋ค.
ํฌ๋ ์ธ ์๋ ์ ์ธํ์ด ์ง์ด์ง์ง ์๋ ๊ฒฝ์ฐ๋ ์์ผ๋ ๋ง์ฝ ์ธํ์ด ์๋ ๊ณณ์์ ํฌ๋ ์ธ์ ์๋์ํค๋ ๊ฒฝ์ฐ์๋ ์๋ฌด๋ฐ ์ผ๋ ์ผ์ด๋์ง ์์ต๋๋ค. ๋ํ ๋ฐ๊ตฌ๋๋ ๋ชจ๋ ์ธํ์ด ๋ค์ด๊ฐ ์ ์์ ๋งํผ ์ถฉ๋ถํ ํฌ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. (๊ทธ๋ฆผ์์๋ ํ๋ฉดํ์ ์ ์ฝ์ผ๋ก 5์นธ๋ง์ผ๋ก ํํํ์์)
๊ฒ์ ํ๋ฉด์ ๊ฒฉ์์ ์ํ๊ฐ ๋ด๊ธด 2์ฐจ์ ๋ฐฐ์ด board์ ์ธํ์ ์ง๊ธฐ ์ํด ํฌ๋ ์ธ์ ์๋์ํจ ์์น๊ฐ ๋ด๊ธด ๋ฐฐ์ด moves๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ํฌ๋ ์ธ์ ๋ชจ๋ ์๋์ํจ ํ ํฐํธ๋ ค์ ธ ์ฌ๋ผ์ง ์ธํ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- board ๋ฐฐ์ด์ 2์ฐจ์ ๋ฐฐ์ด๋ก ํฌ๊ธฐ๋ "5 x 5" ์ด์ "30 x 30" ์ดํ์ ๋๋ค.
- board์ ๊ฐ ์นธ์๋ 0 ์ด์ 100 ์ดํ์ธ ์ ์๊ฐ ๋ด๊ฒจ์์ต๋๋ค.
- 0์ ๋น ์นธ์ ๋ํ๋ ๋๋ค.
- 1 ~ 100์ ๊ฐ ์ซ์๋ ๊ฐ๊ธฐ ๋ค๋ฅธ ์ธํ์ ๋ชจ์์ ์๋ฏธํ๋ฉฐ ๊ฐ์ ์ซ์๋ ๊ฐ์ ๋ชจ์์ ์ธํ์ ๋ํ๋ ๋๋ค.
- moves ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค.
- moves ๋ฐฐ์ด ๊ฐ ์์๋ค์ ๊ฐ์ 1 ์ด์์ด๋ฉฐ board ๋ฐฐ์ด์ ๊ฐ๋ก ํฌ๊ธฐ ์ดํ์ธ ์์ฐ์์ ๋๋ค.
Code
import java.util.Stack;
class Solution {
public int solution(int[][] board, int[] moves) {
int answer = 0;
Stack <Integer> basket = new Stack<>();
for(int move : moves){
int idx = move - 1;
for(int i = 0 ; i<board.length; i++){
if(board[i][idx] != 0){
if(basket.empty()) basket.push(board[i][idx]);
else{
if(basket.peek()==board[i][idx]){
basket.pop();
answer += 2;
}
else{
basket.push(board[i][idx]);
}
}
board[i][idx]=0;
break;
}
}
}
return answer;
}
}
Code ์ค๋ช
๋ฐ๊ตฌ๋๋ฅผ ์คํ์ผ๋ก ์ ์ธํ๊ณ moves์ ๋ฐฐ์ด์ ๋๋ฉด์ ํ์ธํด์ผํ๋ค.
๋ฐ๋ณต๋ฌธ์ ํตํด์ board[i][idx]๊ฐ 0์ด ์๋๋ฉด
๋ฐ๊ตฌ๋๊ฐ ๋น์์ ๋๋ ๋ฐ๋ก ๋ฐ๊ตฌ๋ ์คํ์ push๋ฅผ ํด์ฃผ๊ณ ,
๋น์ด์์ง ์์๋๋ ๋ฐ๊ตฌ๋์ ๋ง์ง๋ง ๊ฐ๊ณผ ๋น๊ตํ๊ณ ๊ฐ๋ค๋ฉด pop์ ํด์ฃผ๊ณ answer์ 2๋ฅผ ๋ํด์ค๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฐ์ง ์๋ค๋ฉด push ํด์ค๋ค.
๊ทธ ์ดํ์ board[i][idx]๋ฅผ 0์ผ๋ก ๋ง๋ค์ด ์ฃผ๊ณ break๋ฅผ ํตํด์ ๋ค์ move๋ก ๋์ด๊ฐ๋ค.
๋ฐฐ์ด์
- ์๋ฐ์์ ๋ฐฐ์ด์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋๋ฆด ๋,
for(๋ด์ ๋ณ์ :๋ฐฐ์ด)๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐฐ์ด ๋ฐ๋ณต๋ฌธ์ ๋ ์ฝ๊ฒ ๋๋ฆด ์ ์๋ค. - java.util.Stack ์ ์ด์ฉํด์ Stack์ ์ฌ์ฉํ ๋
Stack <๋ณ์ํ> ์คํ์ด๋ฆ = new Stack<๋ณ์ํ> ();๋ฅผ ์ด์ฉํด์ ์ ์ธํ ์ ์๊ณ ,
Stack.push(๋ณ์)๋ก push, Stack.pop() pop, Stack.peek()๋ top๊ฐ์ ๋ฐํํด์ฃผ๊ณ , Stack.empty()๋ฅผ ํตํด์ Stack์ด ๋น์๋์ง ํ์ธํ ์ ์๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algoritm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ์ฒด์ก๋ณต (0) | 2021.07.13 |
---|---|
[Algoritm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ํฐ์ผ๋ชฌ (0) | 2021.07.12 |
[Algorithm/JAVA][ํ๋ก๊ทธ๋๋จธ์ค] ์์ฃผํ์ง ๋ชปํ ์ ์ (0) | 2021.07.11 |
[Algorithm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ๋ชจ์๊ณ ์ฌ (0) | 2021.07.08 |
[Algorithm/JAVA][ํ๋ก๊ทธ๋๋จธ์ค]K๋ฒ์งธ ์ (0) | 2021.07.07 |