๋ฌธ์
์ ์๋ฅผ ์ ์ฅํ๋ ์คํ์ ๊ตฌํํ ๋ค์, ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ๋ช ๋ น์ ์ฒ๋ฆฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๋ช ๋ น์ ์ด ๋ค์ฏ ๊ฐ์ง์ด๋ค.
- push X: ์ ์ X๋ฅผ ์คํ์ ๋ฃ๋ ์ฐ์ฐ์ด๋ค.
- pop: ์คํ์์ ๊ฐ์ฅ ์์ ์๋ ์ ์๋ฅผ ๋นผ๊ณ , ๊ทธ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์คํ์ ๋ค์ด์๋ ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
- size: ์คํ์ ๋ค์ด์๋ ์ ์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
- empty: ์คํ์ด ๋น์ด์์ผ๋ฉด 1, ์๋๋ฉด 0์ ์ถ๋ ฅํ๋ค.
- top: ์คํ์ ๊ฐ์ฅ ์์ ์๋ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์คํ์ ๋ค์ด์๋ ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ด์ง๋ ๋ช ๋ น์ ์ N (1 โค N โค 10,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๋ช ๋ น์ด ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ์ ์๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค. ๋ฌธ์ ์ ๋์์์ง ์์ ๋ช ๋ น์ด ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ๋ ์๋ค.
์ถ๋ ฅ
์ถ๋ ฅํด์ผํ๋ ๋ช ๋ น์ด ์ฃผ์ด์ง ๋๋ง๋ค, ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค.
https://www.acmicpc.net/problem/1874
ํ์ด
์๊ณ ๋ฆฌ์ฆ ํ๋ฆ
- ์ ๋ ฅ ๋ฐ๊ธฐ
- ์ ๋ ฅ๋ฐ์ ๊ฐ์ PUSH ํ๊ธฐ
- ์ํ๋ ์ซ์์ผ๋ POPํ๊ธฐ
- ๋ง์ฝ ํด๋น์ซ์๊ฐ ๋ชป๋์จ๋ค๋ฉด NO ์ถ๋ ฅ
- ๋ชจ๋ ์ถ๋ ฅ๋์๋ค๋ฉด sb์ ์ ์ฅ๋ ๊ฐ์ ์ถ๋ ฅ
- ์ด๋ ์คํ์ ์๋ฅผ ๋ฃ์๋๋ ๋ฐ๋์ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ค์ด๊ฐ๋ค.
๋ง์ฝ์ ์
๋ ฅ๊ฐ์ด 8์ด๋ผ๋ฉด
1 2 3 4 5 6 7 8 ์ด๋ ๊ฒ PUSH๊ฐ ์ผ์ด๋ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ๊บผ๋ด์ผ๋ ๊ฐ์ด ๋๋ค๋ฉด ํด๋น ๊ฐ์POPํ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค์ด๋ณด์. ๋ง์ฝ ์ ๋ ฅ์ด ์๋์ ๊ฐ๋ค๊ณ ์๊ฐํด๋ณด์.
5
4
2
3
1
5
์ฒซ๋ฒ์งธ์ 5๋ ๊ฐฏ์N์ด๋ฏ๋ก ๊ทธ๋ค์ 5๊ฐ๊ฐ ๋์ฌ๊ฒ์ ์๋ ค์ค๋ค. ์๋ตํ๊ณ ๋ค์ ์ซ์๋ฅผ ๋ณด์
4 ! ์ ๊ทธ๋ผ 4๋ฅผ ๊บผ๋ผ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น? ์ผ๋จ 4๊ฐ๋ฅผ PUSHํด์ผํ ๊ฒ์ด๋ค.
์ฆ ์คํ์ ๋ณธ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
STACK - 1
STACK - 1 2
STACK - 1 2 3
STACK - 1 2 3 4
4๊ฐ ๋์๋ค. ๊ทธ๋ผ ๋ฌธ์ ์์ ์ํ๋ 4๋ฅผ ์ฐพ์์ผ๋ฏ๋ก 4๋ฅผ POPํ๋ค. ๊ทธ๋ผ ๋ค์๊ณผ ๊ฐ์ด ๋๋ค.
STACK - 1 2 3
๋ค์์ผ๋ก ์ฐพ์ ์ซ์๋ 2์ด๋ค. 2๋ฅผ ์ฐพ์ผ๋ ค๊ณ ๋ณด๋ 3์ด TOP์ ์๋ค. ๊ทธ๋ผ POP ์ฐ์ฐ์ผ๋ก ์์ ์ค๋ค.
STACK - 1 2
๊ทธ๋ผ 2๊ฐ ๋์๋ค. ๋ฌธ์ ์์ ์ํ๋ ๊ฐ์ ์ฐพ์์ผ๋ 2๋ฅผ POP ํด์ค๋ค.
STACK - 1
๋ค์์ผ๋ก ์ฐพ์์ซ์๋ 3์ด๋ค. 3์ ์ฐพ์์ผํ๋๋ฐ ์ฐ๋ฆฌ๊ฐ 4๊น์ง PUSH๋ฅผ ํ์ผ๋ฏ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก PUSH๋๋ ค๋ฉด ๋ค์์ผ๋ก PUSH๋๋ ๊ฐ์ 5์ด๋ค.
STACK - 1 5
์๋ฌด๋ฆฌ ์ฌ๊ธฐ์ 5 6 7 8 ์ถ๊ฐ๊ฐ ๋์ด๋ ์ฐพ์ผ๋ ค๋ 3์ ์ฐพ์์์์๊ฒ์ด๋ค.
์ด๋ ๊ฒ ๋์์๋ ์ถ๋ ฅ์ "NO"๊ฐ ์ถ๋ ฅ๋๋ค.
์ฝ๋
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder sb = new StringBuilder();
Stack<Integer> stack = new Stack<>();
int n = sc.nextInt();
int start = 0;
for(int i=0; i<n; i++){
int value = sc.nextInt();
if(value > start){
for(int j=start+1; j<=value; j++){
stack.push(j);
sb.append('+').append('\n');
}
start = value;
} else if (stack.peek() != value) {
System.out.println("NO");
return;
}
stack.pop();
sb.append('-').append('\n');
}
sc.close();
System.out.println(sb);
}
}