์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
- ๋ ์
- ์นดํ๋๊ฐ
- ์ ๋ฆฌํธ๋ฆฌํธ
- ์๋ฐ์คํฌ๋ฆฝํธ
- ๊น๋ฏธ๊ฒฝ์๋งํ์์
- ์นํผ๋ธ๋ฆฌ์ฑ
- css
- K๋ฐฐํฐ๋ฆฌ๋ ๋ณผ๋ฃจ์
- ๋๊ฐ
- ์ค๋ผํด
- ํ๋ก๊ทธ๋๋ฐ
- ํ์ด์ฌ
- JavaScript
- ์ฑ
- html
- ์ฝ๋ฉ
- ๋ฐฐ์์ ๋ฐฐ์
- Python
- ์ค๋ธ์
- ๊ฐ๋ฐ
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ์ํ
- ์ํ์ฃผ
- Java
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- database
- ์๋ฐ
- ํ์ฒ์ ๋ฆฌํธ๋ฆฌํธ
- ๊ฐ์ดํ ์ข ๋ญ๊ฐ๋น
- ๋ฐ์ํ
- Today
- Total
JiYoung Dev ๐ฅ
[๋ฐฑ์ค 17298] ์คํฐ์ : Stack ๋ณธ๋ฌธ
๐ ๋ฌธ์
https://www.acmicpc.net/problem/17298
ํฌ๊ธฐ๊ฐ N์ธ ์์ด A = A1, A2, ..., AN์ด ์๋ค. ์์ด์ ๊ฐ ์์ Ai์ ๋ํด์ ์คํฐ์ NGE(i)๋ฅผ ๊ตฌํ๋ ค๊ณ ํ๋ค. Ai์ ์คํฐ์๋ ์ค๋ฅธ์ชฝ์ ์์ผ๋ฉด์ Ai๋ณด๋ค ํฐ ์ ์ค์์ ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ ์๋ฅผ ์๋ฏธํ๋ค. ๊ทธ๋ฌํ ์๊ฐ ์๋ ๊ฒฝ์ฐ์ ์คํฐ์๋ -1์ด๋ค.
์๋ฅผ ๋ค์ด, A = [3, 5, 2, 7]์ธ ๊ฒฝ์ฐ NGE(1) = 5, NGE(2) = 7, NGE(3) = 7, NGE(4) = -1์ด๋ค. A = [9, 5, 4, 8]์ธ ๊ฒฝ์ฐ์๋ NGE(1) = -1, NGE(2) = 8, NGE(3) = 8, NGE(4) = -1์ด๋ค.
์ฒซ์งธ ์ค์ ์์ด A์ ํฌ๊ธฐ N (1 ≤ N ≤ 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์ ์์ด A์ ์์ A1, A2, ..., AN (1 ≤ Ai ≤ 1,000,000)์ด ์ฃผ์ด์ง๋ค.
์ด N๊ฐ์ ์ NGE(1), NGE(2), ..., NGE(N)์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค.
๐ ๋ฌธ์ ํ์ด
๋ฌธ์ ํด๊ฒฐ์ ํต์ฌ์ ์คํ์ ์ธ๋ฑ์ค ์ ๋ณด๋ฅผ ์๊ณ , ์คํ์์ pop()ํ ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง๊ณ ์ ๋ต ์์ด์ ์คํฐ์๋ก ์ฑ์ฐ๋ ๊ฒ์ด๋ค.
์ฆ, ์ ๋ ฅ์์ ์ฃผ์ด์ง ์์ด(array)๊ฐ ์๊ณ , ์ถ๋ ฅํ ์ ๋ต ์์ด(answerArray) ๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ํ์ด๋ฅผ ์ํ ์คํ(myStack)์ด ํ์ํ๋ค.
์ ๋ ฅ์์ ์ฃผ์ด์ง ์์ด์ ์ฐจ๋ก๋๋ก ํ์ธํ๋ฉฐ,
๋ง์ฝ ์คํ์ ๋ง์ง๋ง์ ์์ด ๊ฐ(peek)๋ณด๋ค ๋ค์ ์ฐจ๋ก๋ก ๋ค์ด์ฌ ์ ๋ ฅ ์์ด์ ๊ฐ์ด ํฌ๋ค๋ฉด ์ด ์์ด์ ๊ฐ์ '์คํฐ์'์ ํด๋นํ๊ณ , ์คํ์๋ ์ ๋ ฅ ์์ด์ ์ธ๋ฑ์ค๋ฅผ ์ ์ฅํ๊ณ , ์ ๋ต ์์ด์ ์คํ์ ์ ์ฅ๋ ์ธ๋ฑ์ค ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ํด๋น ์ธ๋ฑ์ค์ ์คํฐ์๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ผ๋ก ํธ๋ ๊ฒ์ด๋ค. (answerArray[myStack.pop()] = array[i])
์์ ๋ด์ฉ์ 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 P17298_์คํฐ์๊ตฌํ๊ธฐ {
/**
* ๋ฌธ์ ํ์ด ๋ฐฉ๋ฒ
* 1. ์ฒซ๋ฒ์งธ ์์ด์ ์คํ์ ๋ฌด์กฐ๊ฑด ์๋๋ค.
* 2. ๋๋ฒ์งธ ์์ด๋ถํฐ ๋ง์ง๋ง ์์ด๊น์ง๋ ๋ฐ๋ณต์ผ๋ก ๊ฒ์ฌํ๋ค.
* 3. ๋ง์ฝ ์คํ์ ๋ง์ง๋ง์ผ๋ก ์ ์ฅ๋ ๊ฐ(stack.peek()) < ๋ค์ ์์ด => ์คํ์ ์ธ๋ฑ์ค๋ฅผ ๊บผ๋ด์ ํด๋น ์ธ๋ฑ์ค์ ๋ค์ ์์ด ๊ฐ ์ ์ฅ
* 4. ๋ง์ฝ ์คํ์ ๋ง์ง๋ง์ผ๋ก ์ ์ฅ๋ ๊ฐ(stack.peer()) >= ๋ค์ ์์ด => stack.push()
* 5. ๋ฐ๋ณต๋ฌธ์ด ๋๊น์ง ๋ ํ ๊ฐ์ด ๋น์ด์๋ ์ธ๋ฑ์ค์ -1 ๊ฐ ๋ฃ๊ธฐ
*
* ํ์ด์ ํต์ฌ
* popํ ์ธ๋ฑ์ค๋ฅผ ํ์ฉํ์ฌ ์ ๋ต ์์ด์ ์คํฐ์ ์ ์ฅ
*/
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int size = Integer.parseInt(br.readLine());
String arrayString = br.readLine();
int[] array = new int[size];
for(int i = 0 ; i < size ; i++){ //์์ด ์์ฑ
array[i] = Integer.parseInt(arrayString.split(" ")[i]);
}
int[] answer = new int[size];
Stack<Integer> stack = new Stack<>();
//์ฒซ๋ฒ์งธ ์์ด์ ๋ฌด์กฐ๊ฑด ์คํ์ ์๋๋ค.
stack.push(0);
for(int i = 1 ; i < size ; i++){
while(!stack.isEmpty() && array[stack.peek()] < array[i]){ //์คํ์ TOP(INDEX)์ ๋ํ ์์ด์ ๊ฐ < ๋ค์ด์ฌ ์์ด์ ๊ฐ
answer[stack.pop()] = array[i]; //์ ๋ต ์์ด์ POPํ INDEX์ ๋ค์ด์ฌ ์์ด์ ๊ฐ ์ ์ฅ
}
stack.push(i); //์ธ๋ฑ์ค ์ ์ฅ
}
while(!stack.empty()){ //์คํ์ด ๋น์์ง ๋๊น์ง
answer[stack.pop()] = -1; //์ ๋ต ์์ด์์ ๋น์ด์๋ ์ธ๋ฑ์ค์ -1 ์ ์ฅ
}
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
for(int i : answer){
bw.write(i + " ");
}
bw.close();
}
}
'Study > ์๊ณ ๋ฆฌ์ฆ, ๊ตฌํ ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค 1874] ์คํ์ผ๋ก ์ค๋ฆ์ฐจ์ ์์ด ๋ง๋ค๊ธฐ : Stack (1) | 2024.11.05 |
---|---|
[๋ฐฑ์ค 11003] ์ต์๊ฐ ์ฐพ๊ธฐ : Deque (2) | 2024.10.29 |
[๋ฐฑ์ค 2563] ์ด์ฐจ์ ๋ฐฐ์ด : ์์ข ์ด (0) | 2023.11.08 |