๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์
์ด์คfor๋ฌธ
ํ์ฌ ์ธ๋ฑ์ค์ ์๋ ์์๊ณผ ์ดํ ๋ชจ๋ ๊ฐ์ ๋น๊ตํ๋ฉด์ ํ์ฌ ์์๊ฐ ๋น๊ตํ๊ณ ์๋ ์์๋ณด๋ค ์ปค์ง๋ฉด break;๋ฅผ ๊ฑธ์ด์ค๋ค.
๊ทธ ์ ๊น์ง๋ answer[i]++์ ํด ์ค๋ค.
ํ์ฌ ์์๊ฐ ๋ ํฌ๋ค๋ ๋ง์ ์ดํ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ก๋ค๋ ๊ฒ์ ์๋ฏธํ๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ฌ ์์๊ฐ ๋น๊ตํ๋ ๊ฐ๊ณผ ๊ฐ๊ฑฐ๋ ๋ ์ ๋ค๋ฉด ๊ฐ๊ฒฉ์ด ์ ์ง๋๊ฑฐ๋ ์ค๋ฅธ ๊ฒ์ด๋ค.
์คํ(Stack)
๊ทผ๋ฐ ์ด๊ฒ ์คํ/ํ ๋ฌธ์ ๋ผ๋๋ฐ ์คํ์ผ๋ก๋ ์ด๋ป๊ฒ ํ์ง? ์ค์
๊ทธ๋์ ๋ค๋ฅธ ์ฌ๋๋ค์ ์ด๋ป๊ฒ ํธ๋ ์ง ์ข ์ฐพ์ ๋ดค๋ค.
๊ทธ๋ฅ ์ด์คํฌ๋ฌธ์ผ๋ก ํธ๋๊ฒ ๋ ๊ฐ๋จํ ๊ฒ ๊ฐ๋ค.
prices์ ์ธ๋ฑ์ค๋ฅผ ์คํ์ ๋ฃ์ด ์ฃผ๋ฉด์ ํ์ฌ ๊ฐ๊ฒฉ๊ณผ ์คํ์ ๊ฐ์ฅ ์ ๊ฐ๊ฒฉ์ ๋น๊ตํด์ค๋ค.
์คํ์ด ๋น์ด์์ง ์๊ณ , ํ์ฌ ๊ฐ๊ฒฉ์ด ์คํ์ ๊ฐ์ฅ ์ ๊ฐ๊ฒฉ๋ณด๋ค ์์ผ๋ฉด
๋ฐ๋ก ๊ฐ๊ฒฉ์ด ๋จ์ด์ง ์ง์ ์์์ ์๊ฐ์ ๊ณ์ฐํ๊ณ , stack.pop()์ ํด ์ค๋ค.
๋ง์ฝ ํ์ฌ ๊ฐ๊ฒฉ์ด ์คํ ๋งจ ์ ๊ฐ๊ฒฉ๋ณด๋ค ๋๋ค๋ฉด ์คํ์ ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ๋ฃ์ด ์ฃผ๋ ์์ ์ ๋ฐ๋ณตํ๋ค.
๊ทธ๋ฌ๋ฉด ๊ฐ๊ฒฉ์ด ๋จ์ด์ง ์ง์ ์์ ๊ฑธ๋ฆฐ ์๊ฐ์ด ๋จผ์ answer[i]์ ์ฑ์ ์ง๋ค.
์คํ ์์ ๋จ์์๋ ์ธ๋ฑ์ค๋ค์ ๋ง์ง๋ง๊น์ง ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๊ฐ ๊ฐ๊ฒฉ์ด ๋๊น์ง ๋จ์ด์ง์ง ์์ ๊ธฐ๊ฐ์ ๋ฐ๋ก ๊ตฌํด์ค๋ค.
answer[stack.peek()] = prices.length - stack.peek() - 1;
์ฌ๊ธฐ์ -1์ ํด ์ฃผ๋ ์ด์ ๋ ๋ง์ง๋ง ๋ ์ง๋ ์ด๋ฏธ ๊ณ์ฐ๋ ๊ฒ์ด๋ฏ๋ก ์ ์ธํด ์ฃผ๋ ๊ฒ์ด๋ค. ์ฃผ์ด์ง ๊ฐ๊ฒฉ์ "๊ธฐ๊ฐ"์ ํด๋น ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์๊ณ ์ ์ง๋ ๊ธฐ๊ฐ์ ์๋ฏธํ๋๋ฐ, ๋๋ ๋๊น์ง ์ ์ง๋ ์ํ๋ฅผ ํฌํจํ๋ฉด ์ ๋๊ธฐ ๋๋ฌธ์ ๋ง์ง๋ง ๋ ์ง๋ฅผ ์ ์ธํ๊ณ ๊ณ์ฐํ๋ค.
โญ 3. ์ฝ๋
์ด์ค 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++) {
// ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ผ๋ฉด ์๊ฐ ์ฆ๊ฐ
answer[i]++;
// ๊ฐ๊ฒฉ์ด ๋จ์ด์ง๋ฉด ๋ค์ ์ธ๋ฑ์ค ๋น๊ต
if(prices[i] > prices[j]) {
break;
}
}
}
return answer;
}
}
Stack
import java.util.Stack;
class Solution {
public int[] solution(int[] prices) {
int[] answer = new int[prices.length]; // ๋ต์ ๋ด์ ๋ฐฐ์ด
Stack<Integer> stack = new Stack<>(); // ๊ฐ๊ฒฉ ์ธ๋ฑ์ค๋ฅผ ๋ด์ ์คํ
// ๊ฐ ๊ฐ๊ฒฉ์ ๋ํด ๊ทธ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์๋ ์๊ฐ์ ๊ณ์ฐ
for (int i = 0; i < prices.length; i++) {
while (!stack.isEmpty() && prices[i] < prices[stack.peek()]) {
// ์คํ์ด ๋น์ด์์ง ์๊ณ , ํ์ฌ ๊ฐ๊ฒฉ์ด ์คํ์ ๊ฐ์ฅ ์ ๊ฐ๊ฒฉ๋ณด๋ค ์์ผ๋ฉด
// ์คํ์์ ํ๋์ฉ ๊บผ๋ด๋ฉด์ ๊ณ์ฐ
answer[stack.peek()] = i - stack.peek(); // ๋จ์ด์ง ์ง์ ์์์ ์๊ฐ ๊ณ์ฐ
stack.pop(); // ์คํ์์ ๊ฐ๊ฒฉ ์ธ๋ฑ์ค ์ ๊ฑฐ
}
stack.push(i); // ํ์ฌ ๊ฐ๊ฒฉ ์ธ๋ฑ์ค๋ฅผ ์คํ์ ๋ฃ์
}
// ์คํ์ ๋จ์ ์ธ๋ฑ์ค๋ค์ ๋ํด ๋ง์ง๋ง ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์ผ๋ฏ๋ก ๋จ์ ๊ธฐ๊ฐ์ ๊ตฌํจ
while (!stack.isEmpty()) {
answer[stack.peek()] = prices.length - stack.peek() - 1;
// ๋ง์ง๋ง๊น์ง ๋จ์ด์ง์ง ์์ ์๊ฐ ๊ณ์ฐ
stack.pop(); // ์คํ์์ ์ ๊ฑฐ
}
return answer;
}
}
๐๐ป 4. ๊ฐ์ ์ ํ ๋ฌธ์