๋ฌธ์ (์ถ์ฒ: https://www.acmicpc.net/problem/6198)
<์ฅ์ ์ ์ ๊พธ๋ฏธ๊ธฐ>
๋ฌธ์
๋์์๋ N๊ฐ์ ๋น๋ฉ์ด ์๋ค.
๋น๋ฉ ๊ด๋ฆฌ์ธ๋ค์ ๋งค์ฐ ์ฑ์คํ๊ธฐ ๋๋ฌธ์, ๋ค๋ฅธ ๋น๋ฉ์ ์ฅ์ ์ ์์ ๋ฒค์น๋งํนํ๊ณ ์ถ์ด ํ๋ค.
i๋ฒ์งธ ๋น๋ฉ์ ํค๊ฐ hi์ด๊ณ , ๋ชจ๋ ๋น๋ฉ์ ์ผ๋ ฌ๋ก ์ ์๊ณ ์ค๋ฅธ์ชฝ์ผ๋ก๋ง ๋ณผ ์ ์๋ค.
i๋ฒ์งธ ๋น๋ฉ ๊ด๋ฆฌ์ธ์ด ๋ณผ ์ ์๋ ๋ค๋ฅธ ๋น๋ฉ์ ์ฅ์ ์ ์์ i+1, i+2,.... , N์ด๋ค.
๊ทธ๋ฐ๋ฐ ์์ ์ด ์์นํ ๋น๋ฉ๋ณด๋ค ๋๊ฑฐ๋ ๊ฐ์ ๋น๋ฉ์ด ์์ผ๋ฉด ๊ทธ๋ค์์ ์๋ ๋ชจ๋ ๋น๋ฉ์ ์ฅ์์ ๋ณด์ง ๋ชปํ๋ค.
์) N=6, H = {10, 3, 7, 4, 12, 2}์ธ ๊ฒฝ์ฐ
1๋ฒ ๊ด๋ฆฌ์ธ์ 2, 3, 4๋ฒ ๋น๋ฉ์ ์ฅ์์ ํ์ธํ ์ ์๋ค.
2๋ฒ ๊ด๋ฆฌ์ธ์ ๋ค๋ฅธ ๋น๋ฉ์ ์ฅ์์ ํ์ธํ ์ ์๋ค.
3๋ฒ ๊ด๋ฆฌ์ธ์ 4๋ฒ ๋น๋ฉ์ ์ฅ์์ ํ์ธํ ์ ์๋ค.
4๋ฒ ๊ด๋ฆฌ์ธ์ ๋ค๋ฅธ ๋น๋ฉ์ ์ฅ์์ ํ์ธํ ์ ์๋ค.
5๋ฒ ๊ด๋ฆฌ์ธ์ 6๋ฒ ๋น๋ฉ์ ์ฅ์์ ํ์ธํ ์ ์๋ค.
6๋ฒ ๊ด๋ฆฌ์ธ์ ๋ง์ง๋ง์ด๋ฏ๋ก ๋ค๋ฅธ ๋น๋ฉ์ ์ฅ์์ ํ์ธํ ์ ์๋ค.
๋ฐ๋ผ์, ๊ด๋ฆฌ์ธ๋ค์ด ์ฅ์์ ์์ ํ์ธํ ์ ์๋ ์ด ์๋ 3 + 0 + 1 + 0 + 1 + 0 = 5์ด๋ค.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ๋น๋ฉ์ ๊ฐ์ N์ด ์ ๋ ฅ๋๋ค.(1 ≤ N ≤ 80,000)
๋ ๋ฒ์งธ ์ค๋ถํฐ N+1๋ฒ์งธ ์ค๊น์ง ๊ฐ ๋น๋ฉ์ ๋์ด๊ฐ hi ์ ๋ ฅ๋๋ค. (1 ≤ hi ≤ 1,000,000,000)
์ถ๋ ฅ
๊ฐ ๊ด๋ฆฌ์ธ๋ค์ด ๋ฒค์น๋งํน์ด ๊ฐ๋ฅํ ๋น๋ฉ์ ์์ ํฉ์ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ํ์ด
- ์ด๊ธฐ ์ฝ๋: ์๊ฐ ์ด๊ณผ
if __name__=='__main__':
n=int(input())
stack=[]
answer=0
for i in range(n):
h=int(input())
stack.append(h)
for i in range(n):
for j in range(i+1,n):
if stack[i]>stack[j]:
answer+=1
else:
break
print(answer)
๋ฌธ์ ๊ฐ ์ํ๋ ๊ฒ์ด stack์ธ์ง ์๊ณ ์์์ง๋ง ์ด์ค for๋ฌธ์ผ๋ก ๊ฐ๋ฅํ์ง ์๋ ์๊ฐํ์ฌ ํ์๋ค๊ฐ ๋ฐ๋ก ์๊ฐ ์ด๊ณผ ๋ฐ์ํ ์ฝ๋
์ฌ์ค ๋ฐ๋ก stack์ผ๋ก ํ๊ณ ์ถ์๋๋ฐ ํ ๋ฐฉ๋ฒ์ด ์๊ฐ ์ ๋์ ํ์ฐธ ์๊ฐํ๋ค.
์๊ฐํ๋ค ์๊ฐํ๋ค ๊ฒฐ๊ตญ ๊ฒ์์ ํ์ ๋น๋ ธ๋ค.
์๊ฐํ๋ ๊ด์ ์ ๋ฐ๊พธ์ -!
ํ์ฌ ๊ฑด๋ฌผ์์ ๋ณผ ์ ์๋ ๊ฑด๋ฌผ์ ์๋ฅผ ์ธ๋ ๊ฒ์ด ์๋๋ผ ์์ ์ ๋ณผ ์ ์๋ ๊ฑด๋ฌผ์ ์ธ๋ ๋ฐฉ๋ฒ์ด์๋ค.
- my solution (Python)
if __name__=='__main__':
n=int(input())
arr=[]
answer=0
for i in range(n): # ๋น๋ฉ ๋์ด
h=int(input())
arr.append(h)
stack=[]
for i in range(n):
while stack:
if stack[-1]<=arr[i]: # ์์ ์ ๋น๋ฉ ๋์ด๋ณด๋ค ๋ฎ๋ค๋ฉด
stack.pop()
else:
break
stack.append(arr[i])
answer+=len(stack)-1
print(answer)
- my solution (JAVA)
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
public class _6198_์ฅ์์ ์๊พธ๋ฏธ๊ธฐ {
public static void main(String[] args) throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n=Integer.parseInt(br.readLine()); // ๋น๋ฉ์ ์
int [] arr=new int [n];
long answer=0;
for(int i=0; i<n; i++) {
arr[i]=Integer.parseInt(br.readLine());
}
Stack<Integer> stack=new Stack<>();
for(int i=0; i<n; i++) {
while(stack.size()!=0) {
if(stack.peek()<=arr[i]) {
stack.pop();
}else {
break;
}
}
stack.add(arr[i]);
answer+=stack.size()-1;
}
System.out.println(answer);
}
}
- ๋น๋ฉ์ ์, ๋น๋ฉ์ ๋์ด ์ ๋ ฅ
- ๋น๋ฉ์ ์ํ
: stack์ ๊ฐ์ด ์๋ค๋ฉด
-> ํ์ฌ ๋น๋ฉ์ ๋์ด๊ฐ stack์ ์๋ ๋ง์ง๋ง ๋น๋ฉ์ ๋์ด๋ณด๋ค ๋๋ค๋ฉด
= stack์ ์๋ ๋น๋ฉ์ ํ์ฌ ๋น๋ฉ์ ๋ณผ ์ ์์ผ๋ฏ๋ก stack์์ pop
: stack์ ํ์ฌ ๋น๋ฉ์ ์ถ๊ฐ
: stack์๋ ํ์ฌ ๋น๋ฉ์ ์ ์ธํ ์์ ์ ๋ณผ ์ ์๋ ๋น๋ฉ๋ค์ด ์กด์ฌํ๋ฏ๋ก stack์ ๊ธธ์ด -1์ answer์ ๋ํจ - answer ์ถ๋ ฅ
โ JAVA์์ ์ ํ๋ ธ์ต๋๋ค๊ฐ ๋ฐ์ํ๋๊ฐ?
ํ์ด์ฌ๊ณผ ๋ก์ง์ด ๊ฐ์๋ฐ ์ ํ๋ ธ๋ ํด์ ์ฐพ์๋ณด๋... ๋ต์ด intํ์ ๋์ด๊ฐ ์ ์์ด ๋ฐ์ํ ๋ฌธ์ ์๋ค.
ํ์ด์ฌ์์๋ ๊ณ ๋ คํ์ง ์์๋ ๋ถ๋ถ... answer์ longํ์ผ๋ก ๋ฐ๊ฟ์ ์ ์ถํ๋ ํต๊ณผํ ์ ์์๋ค.
์๊ฐ๐ค
์ด ๋ฌธ์ ๋ ๊ฒ์์ ํตํด์๋ ์ดํดํ๊ธฐ ํ๋ค์ด ํ์ฐธ ์๊ฐํ ๋ฌธ์ ์๋ค.
๊ทธ๋๋ ๊ฒฐ๊ตญ ์ดํดํ๊ธด ํ์ง๋ง ๊น๋ํ์ง๋ ์์๋ ๊ฒ ๊ฐ๋ค.
'๐Algorithm > ๐ฅBaekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Baekjoon] 2468_์์ ์์ญ (0) | 2022.04.01 |
---|---|
[Baekjoon] 2178_๋ฏธ๋ก ํ์ (0) | 2022.03.31 |
[Baekjoon] 2493_ํ (0) | 2022.03.28 |
[Baekjoon] 1068_ํธ๋ฆฌ (0) | 2022.03.25 |
[Baekjoon] 3190_๋ฑ (0) | 2022.03.23 |