1. ๋ฌธ์ ๋งํฌ
2. ์ ๊ทผ ๋ฐฉ์
๋ฐฑ์ค์์ ํ์๋ ์ค๋ฅธ์ชฝ์์ ํฐ ์์ ๊ฐ์ ๋ฌธ์ ์ธ๋ฐ, ๋ฌธ์ ๋ฅผ ํธ๋ ์์ด๋์ด๊ฐ ์๊ฐ์ด ์๋์, ์ ๋ฒ์ ํ์๋ ๊ฒ ์ข ๋ดค๋ค.
ํด๋น ๋ฌธ์ ๋ Stack ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ํ์ด์ผ ํ๋ค.
๋๋ ๋จผ์ Node๋ผ๋ Class๋ฅผ ๋ง๋ค์๋ค. Node์ ๊ตฌ์กฐ๋ ๋ค์๊ณผ ๊ฐ๋ค.
class Node {
int i; // ์๋ index
int v; // ๊ฐ
public Node (int i, int v){
this.i = i;
this.v = v;
}
}
ํด๋น Node๋ฅผ ์๋ฃํ์ผ๋ก ๊ฐ์ง Stack์ ๋ง๋ ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ต์ ์ ์ฅํ๋ ๋ฐฐ์ดans์ ํ๋ ๋ ๋ง๋ ๋ค.
๋ฐฐ์ด์ index = ์๋ ๊ฐ์ ์์น, value = ํด๋น index ๊ฐ์ ๋ทํฐ์๊ฐ ๋ฌด์์ธ์ง ์ ์ฅ ํ๋ค.
Node Stack์ ๊ท์น์ ๋ค์๊ณผ ๊ฐ๋ค.
- ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ฐฐ์ด์ ์ํํ๋ค.
- Stack์ด ๋น์ด์์ผ๋ฉด ํ์ฌ ์กฐํ ์ค์ธ ์์์ ๊ฐ์ ์ ์ฅํ๋ค.
- Stack์ด ๋น์ด์์ง ์๋ค๋ฉด, ํ์ฌ ์กฐํ ์ค์ธ ๊ฐ๊ณผ Stack.top์ ๋น๊ตํ๋ค.
(1) ๋ง์ฝ Top์ด ๋ ํฌ๋ฉด, Stack์ ํ์ฌ ์กฐํ ์ค์ธ ์๋ฅผ ์ ์ฅํ๊ณ ๋์ด๊ฐ๋ค.
(2) ๋ง์ฝ ๋ฐ๋๋ก ํ์ฌ ์กฐํ ์ค์ธ ์๊ฐ ๋ ํฌ๋ฉด ํด๋น ์๊ฐ Top์ ๋ทํฐ์ ์ด๋ฏ๋ก, ans์ Top ์๋ฆฌ์ ์กฐํ ์ค์ธ ์๋ฅผ ๋ทํฐ์๋ก ์ ์ฅํ๋ค. ๊ทธ ํ Stack์ Top์ POPํ๊ณ ๋ค์ ์์ ๋ํ์ฌ 3๋ฒ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค. - ANS๊ฐ ์ฑ์์ก์ ๊ฒ์ด๋ค. ๊ทผ๋ฐ ans์ ๊ฐ์ด ๊ฐฑ์ ๋์ง ์์ ๋ ์์ ๋ทํฐ์๊ฐ ์๋ค๋ ์๋ฆฌ์ด๋ฏ๋ก -1์ ์ถ๋ ฅํ๋ค.
3. ์ฝ๋ ๋ถ์
class Solution {
public int[] solution(int[] numbers) {
// ์๋์ ์ธ๋ฑ์ค์ ๊ฐ์ ๊ฐ์ง stack
Node [] stack = new Node [numbers.length];
int top = -1;
// i = ์๋ number ๋ฐฐ์ด์ ์ธ๋ฑ์ค, value = numer[i]์ ๋ทํฐ์
int [] NGE = new int [numbers.length];
// ๊ฐ ์ด๊ธฐํ
for(int i = 0; i < numbers.length; i++){
NGE[i] = -1;
}
for(int i = 0; i < numbers.length; i ++){
Node now = new Node(i ,numbers[i]);
if(top == -1){
stack[++top] = now;
}else {
while(top > -1 && stack[top].v < now.v){
NGE[stack[top--].i] = now.v;
}
stack[++top] = now;
}
}
return NGE;
}
}
class Node {
int i; // index
int v; // ๊ฐ
public Node(int i, int v){
this.i = i;
this.v = v;
}
}
0