๐ 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. ๊ฐ์ ์ ํ ๋ฌธ์
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญ (์คํ/ํ)
๐ 1. ๋ฌธ์ ์ค๋ช ๐ก 2. ์ ๊ทผ๋ฐฉ์ Queueํธ๋ญ ์ง์ ๋ก์ง: ๋ค๋ฆฌ์ ๋งจ ์ ํธ๋ญ์ด ๋๊ฐ๊ณ ์๋ก์ด ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ ์ ์๋์ง ํ์ธํ ํ ๋ค๋ฆฌ์ ์ถ๊ฐ์ด๋์๊ฐ: ํธ๋ญ์ด ๋ค๋ฆฌ ์์ ์ค๋ฅด๋ฉด ๋งค 1์ด๋ง๋ค
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ํ๋ก์ธ์ค ๋ฌธ์ ํ์ด (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช ์์ #1๋ฌธ์ ์ ๋์จ ์์ ๊ฐ์ต๋๋ค. ์์ #26๊ฐ์ ํ๋ก์ธ์ค [A, B, C, D, E, F]๊ฐ ๋๊ธฐ ํ์ ์๊ณ ์ค์๋๊ฐ [1, 1, 9, 1, 1, 1] ์ด๋ฏ๋ก [C, D, E, F, A, B] ์์ผ๋ก ์คํ๋ฉ๋๋ค. ๋ฐ๋ผ์ A๋ 5๋ฒ์งธ๋ก ์ค
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์ ํ์ด (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช 2. ์ ๊ทผ๋ฐฉ์1) ์คํ์ ์ฌ์ฉํ์ง ์๊ณ ํ๊ธฐ๋ฌธ์์ด์ ์ํํ๋ฉฐ ๋ซํ ๊ดํธ์ ์ด๋ฆฐ ๊ดํธ์ ๊ฐฏ์๋ฅผ ๋ณ์์ ์ ์ฅํ๊ณ ๊ฐ์๊ฐ ๊ฐ์ผ๋ฉด true, ํ๋ฆฌ๋ฉด false ๋ฅผ ๋ฐํํ๋ ๋ฐฉ๋ฒ 2) ์คํ์ ์ฌ์ฉํ์ฌ
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ธฐ๋ฅ๊ฐ๋ฐ (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์ ์ ์ํ ์ค์ ๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค. ๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ฐ์ ์ซ์๋ ์ซ์ด ๋ฌธ์ ํ์ด (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช ๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ
awesomepossum.tistory.com