1. ๋ฌธ์ ์ ๋ํ์ฌ ๐ฆ
(1) ์กฐ๊ฑด ๋ถ์ ๐
- ๋งค์ด ์ฃผ์ ๊ฐ๊ฒฉ์ด ํ๋์ฉ ๋์จ๋ค.
- ํ๋์ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๊ทธ ๋ฐ์ผ๋ก ๋จ์ด์ง์ง ์์ ๊ธฐ๊ฐ์ ๊ตฌํ์ฌ๋ผ
[!example]
[3,1,2,3] ์ผ๋ก ๊ฐ ์ด๋ง๋ค์ ์ฃผ์ ๊ฐ๊ฒฉ์ด ์ฃผ์ด์ก์ ๊ฒฝ์ฐ,
0์ด์ ์ฃผ์ ๊ฐ๊ฒฉ์ ๊ทธ ๋ค์ ์ด์ 1๋ก ๋ฐ๋ก ๋จ์ด์ง๋ค. ๋ฐ๋ผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ธฐ๊ฐ์ 1์ด์ด๋ค.
๋ฐ๋ฉด 1์ด๋์ ์ฃผ์๊ฐ๊ฒฉ์ ์ฃผ์ ๊ฐ๊ฒฉ ๋ฐฐ์ด์ด ๋๋ ๋๊น์ง ๊ทธ๋ณด๋ค ๋ฐ์ผ๋ก ๋จ์ด์ง์ง ์๋๋ค.
2. ์ฝ๋๊ฐ ๋์ค๊ธฐ๊น์ง ๐ ๏ธ
KEY WORD: STACK ํ์ฉ
STOCK์ด๋ ํด๋์ค๋ฅผ ๋ง๋ ๋ค. ๋ฉค๋ฒ๋ณ์๋ ํด๋น ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋์๋ ์ด(index)์ ๊ฐ๊ฒฉ(price)์ด๋ค.
STACK์ ์กด์ฌํ๋ ๊ฐ๋ค์ ์์ง ๊ทธ๋ณด๋ค ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์, ๋งค ๋ฒ ๊ฐ๊ฒฉ ์ ์ง ๊ธฐ๊ฐ์ด ๊ฐฑ์ ๋์ด์ผ ํ๋ ๊ฐ๋ค์ด๋ค. ๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐ์ ํ ํ, STACK์ ๋จ์์๋ ๋ชจ๋ ๊ฐ๋ค์ ๋ํด ์ ์ง ๊ธฐ๊ฐ์ +1 ์ฌ๋ฆฐ๋ค.
- STACK์ด ๋น์ด์์ ๋๋ ํ์ฌ ์ด์ ์ฃผ์ ๊ฐ๊ฒฉ์ ๋ฃ๋๋ค.
- STACK์ด ๋น์ด์์ง ์์ ๋๋ STACK TOP์ ์ฃผ์ ๊ฐ๊ฒฉ๊ณผ ํ์ฌ ์ด์ ์ฃผ์ ๊ฐ๊ฒฉ์ ๋น๊ตํ์ฌ ๊ณ์ฐํ๋ค.
(1) STACK TOP์ ์ฃผ์๊ฐ๊ฒฉ๋ณด๋ค ํ์ฌ ์ด์ ์ฃผ์๊ฐ๊ฒฉ์ด ๋๋ค๋ฉด, ๊ทธ๋๋ก STACK์ ๋ฃ๋๋ค.
(2) ๋ฐ๋์ ๊ฒฝ์ฐ TOP์ POPํ๊ณ , 2๋ฒ์ ๋ค์ ํ๋ค. - STACK์ ๋จ์์๋ ๋ชจ๋ ๊ฐ๋ค์ ์์ง ๊ทธ๋ณด๋ค ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ฐ๋ค์์ผ๋ก, ํด๋น ๊ฐ๋ค์ด ๊ฐ๊ฒฉ ์ ์ง ๊ธฐ๊ฐ์ ๊ฐฑ์ ํ๋ค.
(1) ์๊ฐ๋ณต์ก๋ ๋ถ์ โณ
๋์ฌ ์ ์๋ ์ฃผ์ ๊ฐ๊ฒฉ์ ๊ฐ์๋ 100,000๊ฑด์ด๋ค. $10^{5}$ ์ด๋ผ ์๊ฐ ๋ณต์ก๋๊ฐ $O(n^{2})$ ๋๋ฉด, ๋ฌธ์ ๋ฅผ ํ์ง ๋ชปํ ์ ์๋ค. 100,000๊ฑด์ ํ๋์ฉ ํ์ธํ๋ค. ํ์ง๋ง 1๊ฑด๋ง๋ค 100,000๊ฑด ์ ์ฒด๋ฅผ ํ์ง ์๊ธฐ ๋๋ฌธ์ $O(n^{2})$ ๋ณด๋จ ํจ์ฌ ์๊ฐ ๋ณต์ก๋๊ฐ ์์ ๊ฒ์ด๋ผ ์์๋๋ค.
3. ์ฝ๋ ๐
import java.util.*;
class Solution {
static class Stock {
int index;
int price;
public Stock(int index, int price){
this.index = index;
this.price = price;
}
@Override
public String toString(){
return "(์๋ ์์น: " + index + " ๊ฐ๊ฒฉ: " + price + ")";
}
}
public int[] solution(int[] prices) {
int [] answer = new int[prices.length];
int iter = -1;
Stock [] stack = new Stock [prices.length];
for(int i = 0; i < prices.length-1; i++){
// ๋น์ด ์ฃผ์ ๋ฃ๊ธฐ
if(iter == -1) stack[++iter] = new Stock(i, prices[i]);
else {
while(iter >= 0 && stack[iter].price > prices[i]){
iter--;
}
stack[++iter] = new Stock(i, prices[i]);
}
// ํ๋ฃจ๊ฐ ํ๋ฆ.
for(int j = 0; j <= iter; j++){
answer[stack[j].index]++;
}
}
return answer;
}
}