๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

Algorithm/Programmers

[1์ฃผ์ฐจ] ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์ฃผ์‹๊ฐ€๊ฒฉ

์ฃผ์‹๊ฐ€๊ฒฉ ๋ฌธ์ œ ํ’€์ด

๐Ÿ’ป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;
    }
}โ€‹