๋ฌธ์ (์ถ์ฒ: https://www.acmicpc.net/problem/2493)
<ํ>
๋ฌธ์
KOI ํต์ ์ฐ๊ตฌ์๋ ๋ ์ด์ ๋ฅผ ์ด์ฉํ ์๋ก์ด ๋น๋ฐ ํต์ ์์คํ ๊ฐ๋ฐ์ ์ํ ์คํ์ ํ๊ณ ์๋ค. ์คํ์ ์ํ์ฌ ์ผ์ง์ ์์ N๊ฐ์ ๋์ด๊ฐ ์๋ก ๋ค๋ฅธ ํ์ ์ํ ์ง์ ์ ์ผ์ชฝ๋ถํฐ ์ค๋ฅธ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ฐจ๋ก๋ก ์ธ์ฐ๊ณ , ๊ฐ ํ์ ๊ผญ๋๊ธฐ์ ๋ ์ด์ ์ก์ ๊ธฐ๋ฅผ ์ค์นํ์๋ค. ๋ชจ๋ ํ์ ๋ ์ด์ ์ก์ ๊ธฐ๋ ๋ ์ด์ ์ ํธ๋ฅผ ์งํ๋ฉด๊ณผ ํํํ๊ฒ ์ํ ์ง์ ์ ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ๋ฐ์ฌํ๊ณ , ํ์ ๊ธฐ๋ฅ ๋ชจ๋์๋ ๋ ์ด์ ์ ํธ๋ฅผ ์์ ํ๋ ์ฅ์น๊ฐ ์ค์น๋์ด ์๋ค. ํ๋์ ํ์์ ๋ฐ์ฌ๋ ๋ ์ด์ ์ ํธ๋ ๊ฐ์ฅ ๋จผ์ ๋ง๋๋ ๋จ ํ๋์ ํ์์๋ง ์์ ์ด ๊ฐ๋ฅํ๋ค.
์๋ฅผ ๋ค์ด ๋์ด๊ฐ 6, 9, 5, 7, 4์ธ ๋ค์ฏ ๊ฐ์ ํ์ด ์ํ ์ง์ ์ ์ผ๋ ฌ๋ก ์ ์๊ณ , ๋ชจ๋ ํ์์๋ ์ฃผ์ด์ง ํ ์์์ ๋ฐ๋ ๋ฐฉํฅ(์ผ์ชฝ ๋ฐฉํฅ)์ผ๋ก ๋์์ ๋ ์ด์ ์ ํธ๋ฅผ ๋ฐ์ฌํ๋ค๊ณ ํ์. ๊ทธ๋ฌ๋ฉด, ๋์ด๊ฐ 4์ธ ๋ค์ฏ ๋ฒ์งธ ํ์์ ๋ฐ์ฌํ ๋ ์ด์ ์ ํธ๋ ๋์ด๊ฐ 7์ธ ๋ค ๋ฒ์งธ ํ์ด ์์ ์ ํ๊ณ , ๋์ด๊ฐ 7์ธ ๋ค ๋ฒ์งธ ํ์ ์ ํธ๋ ๋์ด๊ฐ 9์ธ ๋ ๋ฒ์งธ ํ์ด, ๋์ด๊ฐ 5์ธ ์ธ ๋ฒ์งธ ํ์ ์ ํธ๋ ๋์ด๊ฐ 9์ธ ๋ ๋ฒ์งธ ํ์ด ์์ ์ ํ๋ค. ๋์ด๊ฐ 9์ธ ๋ ๋ฒ์งธ ํ๊ณผ ๋์ด๊ฐ 6์ธ ์ฒซ ๋ฒ์งธ ํ์ด ๋ณด๋ธ ๋ ์ด์ ์ ํธ๋ ์ด๋ค ํ์์๋ ์์ ์ ํ์ง ๋ชปํ๋ค.
ํ๋ค์ ๊ฐ์ N๊ณผ ํ๋ค์ ๋์ด๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ๊ฐ์ ํ์์ ๋ฐ์ฌํ ๋ ์ด์ ์ ํธ๋ฅผ ์ด๋ ํ์์ ์์ ํ๋์ง๋ฅผ ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ํ์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ N์ด ์ฃผ์ด์ง๋ค. N์ 1 ์ด์ 500,000 ์ดํ์ด๋ค. ๋์งธ ์ค์๋ N๊ฐ์ ํ๋ค์ ๋์ด๊ฐ ์ง์ ์์ ๋์ธ ์์๋๋ก ํ๋์ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ํ๋ค์ ๋์ด๋ 1 ์ด์ 100,000,000 ์ดํ์ ์ ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ด์ง ํ๋ค์ ์์๋๋ก ๊ฐ๊ฐ์ ํ๋ค์์ ๋ฐ์ฌํ ๋ ์ด์ ์ ํธ๋ฅผ ์์ ํ ํ๋ค์ ๋ฒํธ๋ฅผ ํ๋์ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ๋ ์ด์ ์ ํธ๋ฅผ ์์ ํ๋ ํ์ด ์กด์ฌํ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ํ์ด
- my solution (Python)
import sys
if __name__=='__main__':
n=int(input()) # ํ์ ์
arr=list(map(int, sys.stdin.readline().split())) # ํ์ ๋์ด
stack=[]
answer=[]
for i in range(len(arr)):
while True:
if len(stack)==0: # ๋ ์ด์ ์ ํธ ์์ ํ๋ ํ ์กด์ฌ x
answer.append(str(0))
stack.append([str(i+1), arr[i]])
break
elif stack[-1][1]<arr[i]: # ์ผ์ชฝ ํ์ ๋์ด๊ฐ ๋ ๋ฎ์ผ๋ฉด
stack.pop()
else: # ์ผ์ชฝ ํ์ ๋์ด๊ฐ ๋๊ฑฐ๋ ๊ฐ์ผ๋ฉด
answer.append(stack[-1][0])
stack.append([str(i+1), arr[i]])
break
print(' '.join(answer))
- my solution (JAVA)
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Stack;
public class _2493_ํ {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int n=Integer.parseInt(br.readLine()); // ํ์ ์
String arr[]=br.readLine().split(" "); // ํ์ ๋์ด
Stack<int[]> stack=new Stack<>();
int[] answer=new int[n];
for(int i=0; i<n; i++) {
while(true) {
if(stack.size()==0) { // ๋ ์ด์ ์ ํธ ์์ ํ๋ ํ ์กด์ฌ x
answer[i]=0;
stack.push(new int[] {i+1, Integer.parseInt(arr[i])});
break;
}else if(stack.peek()[1]< Integer.parseInt(arr[i])) { // ์ผ์ชฝ ํ์ ๋์ด๊ฐ ๋ ๋ฎ์ผ๋ฉด
stack.pop();
}else { // ์ผ์ชฝ ํ์ ๋์ด๊ฐ ๋๊ฑฐ๋ ๊ฐ์ผ๋ฉด
answer[i]=stack.peek()[0];
stack.push(new int[] {i+1, Integer.parseInt(arr[i])});
break;
}
}
}
for(int i=0; i<n; i++) { // ์ถ๋ ฅ
bw.write(answer[i]+" ");
}
bw.flush();
bw.close();
}
}
๋ฌธ์ ์ ์๋ ์๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ๋ค.
๋ ์ด์ ๊ฐ ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ๋ฐ์ฌํ๋ฏ๋ก ์ผ์ชฝ์ ํ ๊ธธ์ด์ ๋น๊ตํ๋ฉด ๋ ๊ฒ ๊ฐ์ stack์ ํ์ฉํ์๋ค.
๋ํ, ์์ ํ ํ์ ์๊ธฐ ์ํด ์กฐ๊ฑด์ 3๊ฐ์ง๋ก ์ค์ ํ์๋ค. stack์ด ๋น์์ ๋, ์ผ์ชฝ ํ์ ๊ธธ์ด๊ฐ ๋ ์งง์ ๋, ๊ธธ๊ฑฐ๋ ๊ฐ์ ๋๋ก ๋๋์ด ๊ตฌํํ์๋ค. stack์ด ๋น์์ผ๋ฉด ์์ ํ๋ ํ์ด ์กด์ฌํ์ง ์์ผ๋ฏ๋ก answer์ 0์ ๋ฃ๊ณ ๋ค์ ํ์ ์ํด stack์ ๋ฃ์ด์ค๋ค. ์ผ์ชฝ ํ์ ๊ธธ์ด๊ฐ ์งง์ ๋๋ ๊ทธ ํ์ ๋ ์ด์ ๋ฅผ ์์ ํ ์ ์์ผ๋ฏ๋ก pop์ ํด์ค๋ค. ํ์ง๋ง stack์ ๋จ์์๋ ํ ์ค์์ ์์ ํ ์ ์๋ ํ์ด ์์ ์ ์์ผ๋ฏ๋ก while์ ํตํด ๋๊น์ง ํ์ธํด์ค๋ค. ๋ง์ง๋ง์ผ๋ก ์ผ์ชฝ ํ์ ๊ธธ์ด๊ฐ ๊ธธ๊ฑฐ๋ ๊ฐ๋ค๋ฉด ๋ ์ด์ ๋ฅผ ์์ ํ ์ ์์ผ๋ฏ๋ก answer์ ๊ทธ ํ์ ๋ฒํธ๋ฅผ ๋ฃ๊ณ ๋ค์ ํ์ ์ํด stack์ ๋ฃ์ด์ค๋ค.
์์ ์ค๋ช ์ ๊ฐ๋จํ ๋ํ๋ด๋ฉด ์๋์ ๊ฐ๋ค.
- ํ์ ์, ํ์ ๋์ด ์ ๋ ฅ
- ํ์ ๋์ด ๋ฐ๋ณต๋ฌธ ์ํ (for๋ฌธ)
: while
1) len(stack) == 0
- ๋ ์ด์ ์ ํธ ์์ ํ๋ ํ์ด ์กด์ฌํ์ง ์๋๋ค๋ ์๋ฏธ
- ์ ํธ๋ฅผ ์์ ํ๋ ํ์ด ์กด์ฌํ์ง ์์ผ๋ฏ๋ก answer์ 0 ์ถ๊ฐ
- ๋ค์ ํ์ ์ํด stack์ [index, height] ์ถ๊ฐ
- break
2) stack [-1][1] < arr [i]
- ์ผ์ชฝ ํ์ ๋์ด๊ฐ ๋ ๋ฎ์ผ๋ฉด
- ์ ํธ๋ฅผ ์์ ํ์ง ๋ชปํ๋ฏ๋ก stack์์ pop
3) stack [-1][1] >= arr [i]
- ์ผ์ชฝ ํ์ ๋์ด๊ฐ ๋ ๋๊ฑฐ๋ ๊ฐ์ ์ ํธ ์์ ๊ฐ๋ฅํ๋ฉด
- answer์ stack [-1]์ index ์ถ๊ฐ
- ๋ค์ ํ์ ์ํด stack์ [index, height] ์ถ๊ฐ
- break - ๊ฒฐ๊ณผ answer ์ถ๋ ฅ
โ JAVA์์ ์ ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ๊ฐ ๋ฐ์ํ๋๊ฐ?
Scanner๋ฅผ ์ฌ์ฉํด์ ๋ฐ์ํ๋ค. ์์ ์ Scanner ์ฐ๋ ์ต๊ด์ด ๊ทธ๋๋ก...
BufferedReader, BufferedWriter๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๋๋ฅผ ๊ณ ์ณค๋๋ ํต๊ณผํ ์ ์์๋ค.
์๊ฐ๐ค
๋ฌธ์ ๋ณด๊ณ ์๊ฐ๋๋ ๋ฐ๋ก ๋๋ฑ๋๋ฑํ๋๋ ํ ๋ฒ๋ง์ ์ฑ๊ณต -!
JAVA BufferedReader, BufferedWriter ์ฌ์ฉํ๋ ๋ฒ ์ฐพ์๋ณธ๋ค๊ณ ์กฐ๊ธ ์๊ฐ์ด ๊ฑธ๋ ธ์ง๋ง ๋ง์กฑํ๋ค.
'๐Algorithm > ๐ฅBaekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Baekjoon] 2178_๋ฏธ๋ก ํ์ (0) | 2022.03.31 |
---|---|
[Baekjoon] 6198_์ฅ์ ์ ์ ๊พธ๋ฏธ๊ธฐ (0) | 2022.03.29 |
[Baekjoon] 1068_ํธ๋ฆฌ (0) | 2022.03.25 |
[Baekjoon] 3190_๋ฑ (0) | 2022.03.23 |
[Baekjoon] 7569_ํ ๋งํ (0) | 2022.03.22 |