์ฃผ์๊ฐ๊ฒฉ ๋ฌธ์ ํ์ด
๐ปQ
์ด ๋จ์๋ก ๊ธฐ๋ก๋ ์ฃผ์๊ฐ๊ฒฉ์ด ๋ด๊ธด ๋ฐฐ์ด prices๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ธฐ๊ฐ์ ๋ช ์ด์ธ์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
๐โ๏ธ ์ ํ ์ฌํญ
- prices์ ๊ฐ ๊ฐ๊ฒฉ์ 1 ์ด์ 10,000 ์ดํ์ธ ์์ฐ์์
๋๋ค.
- prices์ ๊ธธ์ด๋ 2 ์ด์ 100,000 ์ดํ์
๋๋ค.
์
์ถ๋ ฅ ์
1์ด ์์ ์ โฉ1์ ๋๊น์ง ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์ต๋๋ค.
2์ด ์์ ์ โฉ2์ ๋๊น์ง ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์ต๋๋ค.
3์ด ์์ ์ โฉ3์ 1์ด๋ค์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง๋๋ค. ๋ฐ๋ผ์ 1์ด๊ฐ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ฒ์ผ๋ก ๋ด
๋๋ค.
4์ด ์์ ์ โฉ2์ 1์ด๊ฐ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์ต๋๋ค.
5์ด ์์ ์ โฉ3์ 0์ด๊ฐ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์ต๋๋ค.
๐กA
์คํ/ํ ๋ฌธ์ ์ค์์ ๋ฌธ์ ์์ฒด๋ฅผ ์ดํดํ๋๋ฐ ๊ฐ์ฅ ์ค๋ ๊ฑธ๋ ธ๋ค. ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ ๋ฌธ์ ๋ฅผ ํด์ํ๋๊ฒ๋ ์ฝ์ง ์์๊ฒ ๊ฐ๋ค.
์ฒ์์ ์ฃผ์ ํ๊ฐ๋ฅผ ์ฐ ๋ค๋ก ์ด๋ง๋ค ๊ทธ ์ฃผ์์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ์๊ฐ์ ๊ตฌํด์ผ ํ๋ค.
stack์ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ์ ๋น๊ตํ๊ณ ๋จ์ด์ง์ง ์์ ๊ฐ๊ฒฉ๋ค๋ง ๋จ๊ฒจ ๊ธฐ๊ฐ์ ๋นผ์ค๋ค.
import java.util.Stack;
class Solution {
public int[] solution(int[] prices) {
Stack<Integer> stack = new Stack<Integer>();
int[] answer = new int[prices.length];
for(int i = 0; i < prices.length; i++) {
while(!stack.empty() && prices[stack.peek()] > prices[i]){
int time = stack.pop();
answer[time] = i - time;
}
stack.push(i);
}
while(!stack.empty()){
int time = stack.pop();
answer[time] = (prices.length - 1) - time;
}
return answer;
}
}โ
ํ์ง๋ง ์ด ๋ฌธ์ ๋ ์ด์ค for๋ฌธ์ผ๋ก ํ๋ฉด ๊ฐ๋จํ ํ๋ฆฌ๋ ๋ฌธ์ ์๋ค.
๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฒ์ ๋ณด๊ณ ๋๋ ์ ์ ์ด์ค for๋ฌธ์ ์ฌ์ฉํ๋ฉด ๋ ๊น๋ํ๊ฒ ํ๋ฆฐ๋ค๋ ๊ฒ์ด๋ค.
class Solution {
public int[] solution(int[] prices) {
int[] answer = new int[prices.length];
for (int i = 0; i < prices.length; i++) {
for (int j = i + 1; j < prices.length; j++) {
ans[i]++;
if (prices[i] > prices[j])
break;
}
}
return answer;
}
}โ