1. ์ฌ๋ผ์ด๋ฉ ๋จ์กฐ ํ๋ ๋ฌด์์ธ๊ฐ์?
์ฌ๋ผ์ด๋ฉ ๋จ์กฐ ํ
๋, DECK์ ํ์ฉํด ๊ตฌํํ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ก, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ๊ตฌ๊ฐ ๋ด์ ์ต์๊ฐ, ์ต๋๊ฐ์ O(1)์ ์ฐพ๊ธฐ ์ํด ๊ณ ์ํ ๊ตฌํ์ฒด์ด๋ค. ๋จ์กฐ๋ผ๋ ์ด๋ฆ์ด ๋ถ์ ์ด์ ๋, ๊ตฌ๊ฐ ๋ด ์ต์๊ฐ์ ์ฐพ๊ณ ์ถ์ ๊ฒฝ์ฐ, Deck ๋ด๋ถ ์์๋ค์ด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ์ง๋๊ณ , ๊ตฌ๊ฐ ๋ด ์ต๋๊ฐ์ด ์ฐพ๊ณ ์ถ์ ๊ฒฝ์ฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ์ง๋๊ธฐ ๋๋ฌธ์ด๋ค.
์ฌ์ค ๋ด๊ฐ ๋ง๋ ์ด๋ฆ์ด๋ค...๐
์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์ฌํ ๋ฌธ์
๋ฅผ ํ๋ฉด์, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ Deck์ผ๋ก ๊ตฌํํ ํํ๊ฐ ๊พธ์คํ ๋์ค๋๋ฐ, ์ธํฐ๋ท ์ฌ๊ธฐ ์ ๊ธฐ ์ฐพ์๋ด๋, ํํ๋ง ์์ ๋ฟ ์ด๊ฒ์ ์ ๋๋ก ๋ ์ด๋ฆ์ด ์์๋ค.
๋ฐ๋ผ์ ์ ์ ๋ช ์นญ์ ์๋์ง๋ง! ์ค๋ช ์ ํธ์๋ฅผ ์ํด ์์ผ๋ก ํ ๊ตฌ๊ฐ ๋ด์ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ ์ฐพ๊ธฐ ์ํด Deck์ผ๋ก ๊ตฌํํ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ ์ฌ๋ผ์ด๋ฉ ๋จ์กฐ ํ (Sliding Mono Queue)๋ผ๊ณ ๋ถ๋ฅด๊ฒ ๋ค.
2. ์ ์ฐ๋์?
์์์ ์ฉ๋๋ฅผ ์ค๋ช ํ์ง๋ง, ์๋์ฐ ๊ตฌ๊ฐ ๋ด์ ์ต์๊ฐ์ด๋ ์ต๋๊ฐ์ O(1)์ ๊ตฌํ๊ธฐ ์ํด์ ์ฌ์ฉํ๋ค.
(1) ๊ธฐ๋ณธ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ก๋ ๊ตฌ๊ฐ ๋ด ์ต์ ํน์ ์ต๋๊ฐ์ ์ฐพ์ ์ ์๋์?
๊ธฐ๋ณธ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ก ์ต์๊ฐ ํน์ ์ต๋๊ฐ์ ์ฐพ๋๋ค๋ฉด, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ ์ฐ๋ ์๋ฏธ๊ฐ ์๋ค.
์ฐ๋ฆฌ๊ฐ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์คํฌ์ ์ผ๋ ์ด์ ๋ ๋งค ์์ง์๋ง๋ค ์์ ํ์์ผ๋ก ๊ณ์ฐํด์ผ ํ๋, ํน์ ๊ตฌ๊ฐ์ ๊ตฌ์ฑ์์ ๊ฐ์๋ ํฉ์, ๋งจ ์ผ์ชฝ ๋น ์ง๋ ๊ฐ๊ณผ ์ค๋ฅธ์ชฝ ๊ฐ ๋ ๊ฐ๋ง ์ ๊ฒฝ์ฐ๋ฉด ๋๋๋ก ์๊ฐ ๋ณต์ก๋๋ฅผ ์ค์ฌ์คฌ๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ง๋ง ์ต์, ์ต๋๊ฐ์ ๊ฒฝ์ฐ ์ด๋ค๊ฐ. ๋น ์ง๋ ๊ฐ์ด ๋ช ๋ฒ์งธ๋ก ์์ ์์ธ์ง ๋ชจ๋ฅด๊ณ , ๋ค์ด์ค๋ ๊ฐ์ด ๋ช ๋ฒ์งธ๋ก ํฐ ๊ฐ์ธ์ง ๋จ๋ฒ์ ํ์ ์ด ์ด๋ ต๋ค. ์ด๋ ๊ฒ ๋๋ฉด, ์ฝ์ ๊ฐ๊ณผ ์ญ์ ๊ฐ์ ๋ฐ๋ฅธ ์์ ๋ณ๋์ ๋งค ์์ง์๋ง๋ค ๊ณ์ฐํด์ผํด์, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์ฌ์ฉ์ ์ด์ ๋ฅผ ์๋๋ค.
3. ์ด๋ป๊ฒ ์ฌ์ฉํ๋์?
๋ค์ ๊ณผ์ ์ ๋ฐ๋ฅด๋ฉด ๋๋ค. ์ฐ๋ฆฌ๋ ๊ตฌ๊ฐ ๋ด ์ต์๊ฐ์ DECK์ PEEK()์ผ๋ก ์ ์งํ๋ ๊ฒ์ ๋ชฉํ๋ก ํ๊ฒ ๋ค. ์ด์ DECK ์์ ๋ฌด์กฐ๊ฑด ์ค๋ฆ์ฐจ์์ด ์ ์ง๋์ด์ผ ํ๋ค.
- (0) ์ฝ์
๋ ๊ฐ๋ค์ ๊ฐ์ฒด ํํ๋ก ๋ฐฐ์ด์์์
index
์value
๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค. - (1)
DECK
์ ๋ง๋ ๋ค. - (2) DECK์ด ๋น์ด์์ผ๋ฉด, ์ฝ์ ๊ฐ์ ๋ฌด์กฐ๊ฑด ๋ฃ๋๋ค.
- (3) DECK์ด ๋น์ด์์ง ์์ผ๋ฉด,
- a.
DECK.peekLast()์ ๊ฐ์น
<=์ฝ์ ๊ฐ์ ๊ฐ์น
์ด๋ฉด ์ฝ์ ๊ฐ์ DECK ๊ผฌ๋ฆฌ์ ์ฝ์ ํ๋ค. - b.
DECK.peekLast()์ ๊ฐ์น
>์ฝ์ ๊ฐ์ ๊ฐ์น
: (3)-a๊ฐ ์ฑ๋ฆฝํ ๋๊น์งDECK.pollLast()
๋ก ๊ผฌ๋ฆฌ๊ฐ์ ์ ๊ฑฐํ๋ค.
- a.
- (4) DECK์ front๋ฅผ ํ์ธํ์ฌ, ์ด๋ฏธ ๊ตฌ๊ฐ ๋ด์ ๊ฐ์ด ์๋๋ฉด ์ญ์ ํ๋ค.
(1) DECK.peek()
์ ์๋ฏธ
์์ ๋ฐฉ์๋๋ก ๊ฐ๋ฉด DECK์ peek์ ๋ฌด์กฐ๊ฑด ์ต์๊ฐ์ด ์ ์ง๋ ๊ฒ์ด๋ค. ํด๋น ์ต์๊ฐ์ ํ ๊ตฌ๊ฐ ๋ด์ ์ต์๊ฐ์ ์๋ฏธํ๋ค.
(2) ์ค๋ฆ์ฐจ์ ์ ์ง ์ด์
๊ตฌ๊ฐ์ด ์์ง์ด๋ฉด์, ๋ง์ฝ deck์ peek์ด ๊ตฌ๊ฐ์ ๋ ์ด์ ์ํ์ง ์๋ํ๊ฒ ๋์ด ๋น ์ ธ ๋๊ฐ๋ค๋ฉด? ๊ทธ ๋ค์ ์์ ๊ฐ์ด ์ต์๊ฐ์ด ๋์ด์ผ ํ๋ค. ์ด๋ฅผ ์ํด์ deck ๋ด๋ถ๋ฅผ ์ค๋ฆ ์ฐจ์์ผ๋ก ์ ์งํ๋ ๊ฒ์ด๋ค. deck ์์ ์์๋ค์ ์ต์๊ฐ ํ๋ณด๋ค์ด๋ค.
(3) 3๋ฒ ํด์
์ฐ๋ฆฌ๋ ๊ตฌ๊ฐ ๋ด ์ต์๊ฐ์ ์ ์ง ํด์ผํ๋ค.
(a) ์ฝ์ ๊ฐ์ด Deck.peekLast() ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด, ๋น์ฅ์ ์ต์๊ฐ์ด ๋ ์ ์์ง๋ง, ์๋์ฐ๊ฐ ์์ง์์ ๋ฐ๋ผ ์ถํ์ ์ต์๊ฐ์ด ๋ ์๋ ์๋ค. ๋ฐ๋ผ์ ์ด๋ ค๋๊ณ DECK์ ๊ผฌ๋ฆฌ์นธ์ ํ์น ์ํจ๋ค.
(b) ์ฝ์ ๊ฐ์ด Deck.peekLast()๋ณด๋ค ์๋ค๋ฉด, Deck.peekLast()์ ์๋ ๊ฐ์ ๋ ์ด์ ์ธ๋ชจ๊ฐ ์์ด์ง๋ค. ์๋ํ๋ฉด, ์ ๊ท๋ก ๋ค์ด์ค๋ ๊ฐ์ด ์ต์๋ผ๋ฉด, Deck.peekLast()์ ๊ทธ๊ฒ์ด ๊ตฌ๊ฐ์์ ๋น ์ ธ ๋๊ฐ๋ ๊ทธ ๋ ๊น์ง ์์ํ ์ต์๊ฐ์ด ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ํ๋ ํฌ๋ง์ ๊ฐ์ง์ง ์๊ฒ ๋ฏธ๋ฆฌ ์ญ์ ํด์ค๋ค.
4. ์ฝ๋
import java.io.*;
import java.util.ArrayDeque;
public class Main {
public static void main(String[] args) throws IOException {
int [] arr = new int[]{1, 5, 2, 3, 6, 2, 3, 7, 3, 5, 2, 6};
slidingMonoQueue(arr, 3);
}
public static void slidingMonoQueue (int [] arr, int W) { // arr = ์ ์ฒด ๋ฐฐ์ด, W = ์๋์ฐ ํฌ๊ธฐ
ArrayDeque<Num> window = new ArrayDeque<>();
for (int i = 0; i < arr.length; i++) {
if(window.isEmpty()) window.add(new Num(i, arr[i]));
else {
while (!window.isEmpty() && window.peekLast().v > arr[i]) window.pollLast();
window.add(new Num(i, arr[i]));
}
if(!window.isEmpty() && window.peek().i <= i-W) window.poll();
if(!window.isEmpty()){
System.out.printf("ํ์ฌ ์์ญ: %d ~ %d์ ์ต์๊ฐ: %d\n", i-W+1, i, window.peek().v);
}
}
}
}
class Num {
int i;
int v;
public Num (int i, int v){
this.i = i;
this.v = v;
}
}