๐งฑ ํ๋ก๊ทธ๋๋จธ์ค ์ฝํ๋ฆฐ ๊ณต๋ถ
๐ธ ํฌ๋ ์ธ ์ธํ ๋ฝ๊ธฐ ๊ฒ์
๋ฌธ์ : ( ๋ณด๋ฌ๊ฐ๊ธฐ )
ํด์ค :
์ด ๋ฌธ์ ๋ ํฌ๋ ์ธ์ด ๋ค์ฐจ์ ๋ฐฐ์ด๋ก ๋ ๋ฐฐ์ด์ ์ซ์๋ฅผ ๋ฝ์์ ๊ฐ์ ์์ผ ๊ฒฝ์ฐ ์์ ์ค๋ค. ์ด ์์ ์ค ์์ ๊ฐฏ์๋ฅผ ๋ฆฌํดํ๋ผ๋ ๋ฌธ์ ์ด๋ค.
์์ ์ฌ์ง ์ฒ๋ผ ์ธํ์ด ๋ฐฐ์ด๋์ด์๋ค. ์ด๊ฒ์ ๊ฐ๋จํ ์๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
5 |
0 |
3 |
2 |
0 |
1 |
4 |
3 |
4 |
4 |
3 |
5 |
2 |
1 |
5 |
1 |
์ด๋ ๊ฒ 5*5 ํํ๋ก 2์ฐจ์ ๋ฐฐ์ด์ ์ค๋ค. ๋๋ ์ด ๋ถ๋ถ์์ ํผ๋์ด ์์ ํค๋งธ๋ค.. ์ฃผ์ด์ง ํ ์คํธ ์ผ์ด์ค๋ ์๋์ ๊ฐ์ด ์ค๋ค.
[[00000],[00105],[03201],[43443],[52151]] ์ด๋ถ๋ถ์ ๋ฐ๋๋ก ์๊ฐํด์ ๋ง์ด ํด๋งธ์ง๋ง ์ด ๋ถ๋ถ์ ์ด๋ ต๊ฒ ๋ณด์ง๋ง๊ณ ์์ ํ์ฒ๋ผ ์ญ์ฑ ์์ฌ์๋ค๋ ์ํ๋ก ๋ณธ๋ค๋ฉด ์ดํด๊ฐ ๋น ๋ฅด๋ค.
์ด ๋ฐฐ์ด ๋ง๊ณ ๋ ํฌ๋ ์ธ์ ์์น๋ฅผ ๋ํ๋ด ์ฃผ๋ ๋ฐฐ์ด์ด ํ๋ ๋ ์ฃผ์ด์ง๋ค.
[1, 5, 1, 3, 2, 1, 2] ๋ผ๊ณ ์๋ฅผ ๋ค๋ฉด,
ํฌ๋ ์ธ์ 1๋ฒ ์์น์ธ 4๋ฅผ ๊ฐ์ ธ์จ๋ค. ๋ฌด์จ๋ง์ด๋ ํ๋ฉด 0 0 0 0 0 ์ด ๋ค์ฐจ์ ๋ฐฐ์ด์ 0๋ฒ์งธ ์ธ์์ด์ง๋ง ์ฌ๊ธฐ์ ๋งจ ๋ค์ ๊ฒ์ ๊ฐ์ ธ์ค๋ ๊ฒ์ด ์๋๋ผ, ์์ ํ ์์์์ ๊ฐ์ฅ ์์ ๊ฐ์ธ 4๋ฅผ ๊ฐ์ ธ์จ๋ค๊ณ ๋ณด๋ฉด๋๋ค. ์ฆ ๋ค์ฐจ์ ๋ฐฐ์ด ์์์๋
3๋ฒ์งธ ์ธ์์์ 0๋ฒ์งธ ์์์ธ 4๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒฐ๊ณผ๊ฐ ๋๋ค.
(ํน์ ์ดํด๊ฐ ์๋๋ค๋ฉด ๋๊ธ.)
์ด์ ์ดํด๊ฐ ๋๋ ๋ค์ ๋ณต๊ธฐ๋ฅผ ํด๋ณด๊ฒ ๋ค.
ํฌ๋ ์ธ์ ์ขํ์ ๋ค์ฐจ์ ๋ฐฐ์ด์ ์ขํ๋ฅผ ์ ์ ๊ฐ๋๋๊ฒ ์ฝ๋ฉ์ ํด์ค์ผ ํ๋ค.
์๋ฅผ ๋ค์ด ํฌ๋ ์ธ ์์น๊ฐ 1์ด๋ผ๋ฉด, ๋ค์ฐจ์๋ฐฐ์ด์ ๋ชจ๋ ~ 0๋ฒ์งธ ์ธ์๋ค ์ค 0์ด ์๋ ๊ฐ์์ ์ฒ์ ๋์ค๋ ๊ฐ์ด ์คํ์ ์์ฌ์ผ ํ๋ค.
๋ ๊ฐ์ง ๊ฐ๋ ์ ์ดํดํด์ผ ํ๋ค.
- ์คํ
- ๋ค์ฐจ์ ๋ฐฐ์ด์์์ ์ด์ค ๋ฐ๋ณต๋ฌธ
์คํ์ ์ฑ ์ ์๋ ๋ฏ์ด ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด์ค๋ค. ๊ทธ๋ฆฌ๊ณ pop, push, peek ๋ฑ์ ๋ฉ์๋๋ฅผ ํตํด์ ๊ฐ์ ๊บผ๋๋ค ๋ฃ์๋ค ์ง์ ๋ค ํ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๋ฌํ ๊ธฐ์ค ์ ์ ์ ์ผ ๋ง์ง๋ง ๊ฐ์ด ๋๋ค. FILO ์ ๊ฐ๋ ์ ์๋ฉด ๊ฐ๋จํ๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด์ ๊ฒฝ์ฐ ๋ณดํต [][] ์ด๋ ๊ฒ ๋๊ฐ์ง ์ฃผ์๊ฐ์ ๋ฃ์ ๊ณต๊ฐ์ด ์๊ธด๋ค. ์์ [] ๋ ์ฒซ ์์์ ์์น, ๋ค์ [] ๋ ํด๋น ์์ ์์ ์์์ ์์น๋ผ๊ณ ์ ์ ์๋ค.
์ด๋ฅผ ์ด๋ป๊ฒ ํ์ฉํ๋๋์ ๋ฐ๋ผ ๋ฐ๋๋ก ์์ง์ผ ์๋ ์๋ค.
์ด์ ์ฝ๋๋ฅผ ๋ณด์. ( ์ฐธ๊ณ ๋ก ์ด ํ์ด๋ ๋๋ ๋ต์์ ์ถ์ถํ ๊ฒ์ด๋ค. ๋ค๋ฅธ ๋ถ์! )
import java.util.*
class Solution{
fun solution(board: Array<IntArray>, moves: IntArray): Int{
var answer = 0
val stack = Stack<Int>()
moves.forEach {
for(i in board.indices) {
if(board[i][it-1] != 0 ){
if(stack.isNotEmpty() && stack.peek() == board[i][it-1]){
answer += 2
stack.pop()
}else{
stack.push(board[i][it-1])
}
board[i][it-1] = 0
break
}
}
}
return answer
}
}
๋จผ์ , java.util.* ์ importํด์ค๋ค.
์ด์ , stack์ ์ ์ธํด์ค๋ค. val stack = Stack<Int>()
ํฌ๋ ์ธ์ ์์ง์์ธ moves๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋ฆฌ๊ธฐ ์ํด ๊ฐ์ฅ ๋จผ์ ๋ฐ๋ณต๋ฌธ์ ๋๋ ค์ค๋ค. moves.forEach{}
๋ค์์ ์ธํ๋ค์ด ๋ค์ด์๋ ๋ณด๋๋ฅผ ์ธ๋ฑ์ค ๊ธฐ์ค์ผ๋ก ๋๋ ค์ค๋ค. for(i in board.indices) {}
์ด๋ ๊ฒ ํ๋ฉด ํฌ๋ ์ธ์ ์์น๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ณด๋ํ์์ ๋์๋ค๋๋ค๊ณ ๋ณด๋ฉด๋๋ค.
์ด์ ์กฐ๊ฑด๋ฌธ์ ํตํด์ ์ํ๋ ์กฐ๊ฑด์ผ๋ก ํ๋ํด์ค๋ค.
if(board[i][it-1] != 0) ์ด ์กฐ๊ฑด๋ฌธ์ 0์ ๊ฐ์ ๊ฑธ๋ฌ์ค๋ค. ๊ทธ๋ฆฌ๊ณ i๊ฐ ๊ธฐ์ค์ด๋ค. i๋ ๋ณด๋์ ์ธ๋ฑ์ค์ด๊ธฐ ๋๋ฌธ์
๋ชจ๋ ์์๋ค์ 0๋ฒ์งธ ์ ์ธ์๋ฅผ ๋จผ์ ์ญ์ฑ ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ๊ธฐ์ ํฌ๋ ์ธ์ ์์น๊ฐ +1 ์ํ์ด๊ธฐ ๋๋ฌธ์ -1์ ํด์ฃผ์ด it -1 ์ ํด์ค๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์์ ํ์์ ์ธ๋ก ๋ฐฉํฅ์ผ๋ก 0์ด ์๋ ๊ฐ ์ฒซ๋ฒ์งธ๋ฅผ ์ฐพ๊ฒ ๋๋ค.
๊ทธ๋์ ์ฒ์ stack์ ์์ด๊ฒ ๋๋ ๊ฐ์ 4๊ฐ ๋๋ค. stack.push(board[i][it-1])
์์ ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ด else ๋ถ๋ถ์ด ๋จผ์ ์ ์ฉ๋๋ค.
๊ทธ๋ฌ๋ค๊ฐ stack์ ๊ฐ์ ๊ฐ์ด ์์ด๊ฒ ๋๋ฉด ์ญ์ ํ๊ณ ์ญ์ ๋ ์์์ ๊ฐฏ์๋ฅผ ์ธ์ด์ฃผ๋ ์กฐ๊ฑด์ ๋ฌ์์ค๋ค.
if(stack.isNotEmpty() && stack.peek() == board[i][it-1])
์คํ์ด ๋น์ด์์ง ์๊ฑฐ๋, ์คํ์์ ๋งจ ๋ค ๊ฐ์ ๊ฐ์ ธ์ค๊ณ , ๊ทธ ๊ฐ์ด ํด๋น 0์ด ์๋ ๊ฐ๊ณผ ๊ฐ๋ค๋ฉด
answer+2 ๋ฅผ ํด์ค๋ค.
๊ทธ๋ฆฌ๊ณ ํด๋น ๊ฐ์ ์ง์์ฃผ๊ธฐ ์ํด stack.pop() ์ ํด์ค๋ค.
์ ์ด๋ ๊ฒ ๋์์ผ๋ฉด ํด๋น ๊ฐ์ Stack์ผ๋ก ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์, board[i][it-1] = 0์ผ๋ก ์ค์ ํ์ฌ ๋น ๊ฐ์ผ๋ก ์ค์ !
์ด์ return answer ๋ฅผ ํ๋ฉด ์ํ๋ ๊ฐ์ด ๋์จ๋ค.
'Algorithm > Kotlin' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Kotlin ๊ธฐ๋ณธ ๋ณ์ ๋ฐ ์ฐ์ฐ์ (0) | 2021.04.30 |
---|---|
#08_CS Arcade Kotlin >> Matrix Elements Sum (0) | 2020.12.31 |
#07_CS Arcade Kotlin >> Almost Increasing Sequence (0) | 2020.12.30 |