์ด ๋ฌธ์ ๋, ๊ฐ๋จํ๊ฒ ํด์ํ๋ฉด ํ์ด ์ผ๋ ฌ๋ก ์์ ๋, ์์ ์ ์ผ์ชฝ์ ์๋ ํ ์ค ์์ ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ์์น๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ด๋ค. (์์ ์ 0)
์ด ๋ฌธ์ ๋ฅผ ์ ๊ทผํ ๋์๋,
ํ์ฌ ํ ์์น ์ผ์ชฝ์, ํ์ฌ ํ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ฐ๋ฉด์ ๋์ ํ์ ์์น๋ฅผ ์ฐพ์ง ๋ง๊ณ ,
ํ์ฌ ํ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ฐ๋ฉด์ ๋์ ํ์ ๋์ด๋ฅผ ๋จผ์ ์ฐพ์๋ณด๋ ๊ฒ์ด ์ดํดํ๊ธฐ ์ข๋ค.
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.valueOf(br.readLine());
int[] tops = Arrays.stream(br.readLine().split(" ")).mapToInt(s -> Integer.valueOf(s)).toArray();
Stack<Integer> stack = new Stack<>();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < N; i++) {
int top = tops[i];
while (!stack.isEmpty()) {
if (stack.peek() < top) {
stack.pop();
} else {
sb.append(stack.peek() + " ");
break;
}
}
if(stack.isEmpty()) {
sb.append(0 + " ");
}
stack.push(top);
}
System.out.println(sb);
}
}
์์ ๊ฐ์ ์ฝ๋๋ก ๋ด ์ผ์ชฝ์ ์์ผ๋ฉด์ ๋๋ณด๋ค ๋์ ํฐ ํ์ ๋์ด๋ฅผ ๊ตฌํ ์ ์๋ค.
์์ ๊ธฐ์ค,
6 9 5 7 4 ๋ฅผ ์ ๋ ฅํ์ ๋
0 0 9 9 7 ์ด ์ถ๋ ฅ๋๋ ์ฝ๋์ด๋ค.
for ๋ฌธ ์์ ์ด๋ป๊ฒ ๊ตฌํํ๋์ง ์ดํด๋ณด๋ฉด,
stack์๋ ์ ์ด๋ 1๊ฐ์ ํ์ ๋์ด๊ฐ ์ ๋ ฅ๋๋ค.
1. ๋์ด๊ฐ 6์ธ 1๋ฒ์งธ ํ
1๋ฒ์งธ ํ์ ์ผ์ชฝ์ ์ด๋ ํ ํ๋ ์์ผ๋ฏ๋ก sb์ 0์ด ๊ธฐ๋ก๋๋ฉฐ ๋์ด 6์ด stack์ ์ ๋ ฅ๋๋ค.
ํ์ฌ stack = [ 6 ]
2. ๋์ด๊ฐ 9์ธ 2๋ฒ์งธ ํ
2๋ฒ์งธ ํ์ stack์ ์ ๋ ฅ๋ 6๊ณผ ๋น๊ต๋ฅผ ํด๋ณธ๋ค.
6๋ณด๋ค ๋์ด๊ฐ ๋์ผ๋ฏ๋ก ์ก์ ํ ์ ์์ผ๋ฏ๋ก, ์กฐ๊ฑด๋ฌธ์ ๋ฐ๋ผ stack์ pop ํ๋ค.
pop์ ํ๋ ์ด์ ๋, ์ด์ฐจํผ ์ดํ์ 3๋ฒ์งธ 4๋ฒ์งธ.... ํ๋ค์ ๋์ด๊ฐ 9์ธ ํ์ด 6์ ๋ง๊ธฐ ๋๋ฌธ์ ๊ณ ๋ คํ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค.
ํ๋ง๋๋ก, ํ์ฌ ํ ๋์ด์ธ 9๋ณด๋ค ๋์ด๊ฐ ๋ฎ์ ๋์ด๊ฐ 6์ธ ํ์ ๊ธฐ๋กํ ์ด์ ๊ฐ ์ ํ ์๋ค.
๊ทธ๋ ๊ฒ, 6์ popํ๋ ์๊ฐ stack์ ๋น๊ฒ๋๊ณ , ์ก์ ํ ์ ์๋ ํ์ด ์์ผ๋ฏ๋ก sb์ 0์ด ๊ธฐ๋ก๋๋ฉฐ ๋์ด 9๊ฐ stack์ ๊ธฐ๋ก๋๋ค.
ํ์ฌ stack = [ 9 ]
3. ๋์ด๊ฐ 5์ธ 3๋ฒ์งธ ํ
3๋ฒ์งธ ํ์ stack์ ์ ๋ ฅ๋ 9์ ๋น๊ต๋ฅผ ํด๋ณธ๋ค.
9๊ฐ 5๋ณด๋ค ๋์ผ๋ฏ๋ก, ์ก์ ๋ ์ ์๋ค.
๋ฐ๋ผ์ sb์ ๋์ด 9๋ฅผ ๊ธฐ๋กํ ๋ค, while๋ฌธ์ ๋น ์ ธ๋์จ๋ค.
ํ์ฌ stack = [ 9 ]
๋์ค์ 6~8์ธ ํ์๊ฐ ๋ํ๋ ์, ๋์ด๊ฐ 9์ธ ํ์ ์ ๋ณด๊ฐ ํ์ํ๊ธฐ ๋๋ฌธ์ stack์ ๋ณด์กดํด๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋์ด 5์ธ ํ๋ stack์ ์ ๋ ฅํด์ผํ๋ค. ์ด์ ๋ ๋ค์ ๋์ด๊ฐ 4๋ 3์ธ ํ์ด ๋ํ๋ ์ ์ก์ ํ์ด ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ฌ stack = [ 9 5 ]
4. ๋์ด๊ฐ 7์ธ 4๋ฒ์งธ ํ
4๋ฒ์งธ ํ์ ๋จผ์ stack์ ์ ๋ ฅ๋ 5๊ณผ ๋น๊ต๋ฅผ ํด๋ณธ๋ค.
๋์ด๊ฐ 7์ธ ํ์ด 5๋ณด๋ค ํฌ๋ฏ๋ก 5์ ์คํ์์ ์ ์ธํ๋ค.
์ ์ธ์ํค๋ ์ด์ ๋ 2๋ฒ์งธ ๋จ๊ณ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ๊ทธ๋ฆผ์ฒ๋ผ ๋์ด๊ฐ 7์ธ ํ์ด 6์ ๊ฐ๋ฆด ์ ์๊ธฐ ๋๋ฌธ์, ๋์ด๊ฐ 6์ธ ํ์์ ๋ํ ์ ๋ณด๋ ์ ํ ํ์ํ์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ฌ stack = [ 9 ]
๊ทธ๋ฆฌ๊ณ ๋ค์ stack์ ์ ๋ ฅ๋ 9์ ๋น๊ต๋ฅผ ํด๋ณธ๋ค.
๋์ด๊ฐ 7์ธ ํ์ฌ ํ๋ณด๋ค ํฌ๋ฏ๋ก ์ก์ ๋ ์ ์์ผ๋ฏ๋ก sb์ ๋์ด 9๋ฅผ ๊ธฐ๋กํ๊ณ while ๋ฌธ์ ๋น ์ ธ๋์จ๋ค.
๊ทธ๋ฆฌ๊ณ ํ์ฌ ํ์ ๋์ด์ธ 7์ stack์ ๊ธฐ๋กํ๋ค.
ํ์ฌ stack = [ 9 7 ]
5. ๋์ด๊ฐ 4์ธ 5๋ฒ์งธ ํ
5๋ฒ์งธ ํ์ stack์ ์ ๋ ฅ๋ 7๊ณผ ๋น๊ต๋ฅผ ํด๋ณธ๋ค.
๋์ด๊ฐ 7์ธ ํ์ด ๋ ๋์ผ๋ฏ๋ก ์ก์ ๋ ์ ์์ผ๋ฉฐ sb์ ๋์ด 7์ ๊ธฐ๋กํ๊ณ while๋ฌธ์ ๋น ์ ธ๋์จ๋ค.
๊ทธ๋ฆฌ๊ณ ํ์ฌ ํ์ธ 4๋ฅผ stack์ ๊ธฐ๋กํ๋ค.
์ต์ข stack = [9 7 4]
์ต์ข ์คํ ์ํ๋ ์์ ๊ฐ์ ๊ฒ์ด๊ณ ๊ทธ๋์ ์ ๋ ฅํด๋ sb๋ฅผ ์ถ๋ ฅํ๋ฉด
[0 0 9 9 7] ์ด ๋์จ๋ค.
์ ๋ต์, ์ก์ ๋๋ ํ์์ ๋์ด๊ฐ ์๋ ํ์์ ์์น๋ฅผ ์ถ๋ ฅํด์ผํ๋ค.
์ ๋ฉ์ปค๋์ฆ์ ์ดํดํ๋ค๋ฉด, ์์น๋ฅผ ๋ฝ์๋ด๋ ๊ฒ์ ์ด๋ ต์ง ์์ ๊ฒ์ด๋ค.
์์น๋ฅผ ๊ธฐ๋กํ๊ธฐ ์ํด์๋ class๋ฅผ ์๋ก ์ ์ํ๊ฑฐ๋ ์๋ ์ฝ๋์ ๊ฐ์ด int[] ๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉด ๋๋ค.
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.valueOf(br.readLine());
int[] tops = Arrays.stream(br.readLine().split(" ")).mapToInt(s -> Integer.valueOf(s)).toArray();
Stack<int []> stack = new Stack<>();
StringBuilder sb = new StringBuilder();
for(int i = 0; i < N; i++) {
int top = tops[i]; // ํ์ฌ ํ์ ๋์ด
while(!stack.empty()) {
if(stack.peek()[1] < top) { //ํ ๋์ด ๋น๊ต
stack.pop();
}
else {
sb.append(stack.peek()[0] + " "); //ํ ์์น ์ถ๊ฐ
break;
}
}
if(stack.isEmpty()) {
sb.append(0+" ");
}
stack.push(new int[] {i+1, top}); // (ํ์ ์์น, ํ์ ๋์ด)
}
System.out.println(sb);
}
}