https://programmers.co.kr/learn/courses/30/lessons/42584
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
์ฝ๋
class Solution {
public int[] solution(int[] prices) {
int[] answer = new int[prices.length];
answer[prices.length-1] = 0; // ๋ง์ง๋ง ๊ฐ๊ฒฉ์ ๋จ์ด์ง ์ ์์ผ๋ฏ๋ก 0
for(int i=0; i<prices.length-1; i++){
boolean flag = true;
if(prices[i] == 1){ // ์ฃผ์ ๊ฐ๊ฒฉ์ด 1์์ด๋ฉด ๊ฐ๊ฒฉ์ ๋๊น์ง ๋จ์ด์ง์ง ์๋๋ค.
answer[i] = prices.length - i - 1;
}
else{
// ํ์ฌ ์ฃผ์์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง๋ ์ง์ ์ฐพ๊ธฐ
for(int j=i+1; j<prices.length; j++){
if(prices[i] > prices[j]){
answer[i] = j-i; // j-i์ด๊ฐ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์๋๊ฒ์ผ๋ก ๋ณธ๋ค.
flag = false;
break;
}
}
// ๋ง์ฝ ํ์ฌ ์ฃผ์์ด ๋๊น์ง ๋จ์ด์ง์ง ์๋ ๊ฒฝ์ฐ
if(flag){
answer[i] = prices.length - i - 1;
}
}
}
return answer;
}
}
ํ์ด
๋ฌธ์ ๋ฅผ ์ดํดํ๋๊ฒ์ด ์ฝ๊ฐ ์ด๋ ค์ ๋ค.
์ฃผ์๊ฐ๊ฒฉ์ด ๋ด๊ธด ๋ฐฐ์ด prices = [1, 2, 3, 2, 3]์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ฐ, ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ธฐ๊ฐ์ด ๋ช์ด์ธ์ง
answer๋ฐฐ์ด์ ๋ด์์ ๋ฆฌํดํ๋ ๋ฌธ์ ์ด๋ค.
์ prices = [1, 2, 3, 2, 3] ์ ์๋ก ๋ค์ด๋ณด๋ฉด,
์ฒซ ๋ฒ์งธ ๊ฐ๊ฒฉ 1์ ๊ฒฝ์ฐ ์ดํ์ ๊ฐ๊ฒฉ[2, 3, 2, 3] ๋ณด๋ค ์๋ค. ๋ฐ๋ผ์ ์ฃผ์์ด ๋๋ ๋๊น์ง ๊ฐ๊ฒฉ์ ๋จ์ด์ง์ง ์์ผ๋ฉฐ,
๊ทธ๊ธฐ๊ฐ์ 4์ด๊ฐ ๋๋ค.
๋ ๋ฒ์งธ ๊ฐ๊ฒฉ 2์ ๊ฒฝ์ฐ๋ ์ดํ์ ๊ฐ๊ฒฉ[3, 2, 3] ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ผ๋ฏ๋ก. ์ฃผ์์ด ๋๋ ๋๊น์ง ๊ฐ๊ฒฉ์ ๋จ์ด์ง์ง ์์ผ๋ฉฐ,
๊ทธ ๊ธฐ๊ฐ์ 3์ด๊ฐ ๋๋ค.
์ธ ๋ฒ์งธ ๊ฐ๊ฒฉ 3์ ๊ฒฝ์ฐ, ๋ฐ๋ก ๋ค[2, 3]์ ๊ฐ๊ฒฉ๋ณด๋ค ์์ผ๋ฏ๋ก, 1์ด๋ค์ ๋จ์ด์ง๋ค. ๋ฐ๋ผ์ ๊ธฐ๊ฐ์ 1์ด
๋ค ๋ฒ์งธ ๊ฐ๊ฒฉ 2์ ๊ฒฝ์ฐ, ์ดํ์ ๊ฐ๊ฒฉ[3] ๋ณด๋ค ์์ผ๋ฏ๋ก, ์ฃผ์์ด ๋๋ ๋๊น์ง ๊ฐ๊ฒฉ์ ๋จ์ด์ง์ง ์์ผ๋ฉฐ,
๊ทธ ๊ธฐ๊ฐ์ 1์ด๊ฐ ๋๋ค.
๋ง์ง๋ง ๊ฐ๊ฒฉ 3์ ๊ฒฝ์ฐ, ์ดํ์๋ ์๋ฌด ๊ฐ๊ฒฉ์ด ์์ผ๋ฏ๋ก 0์ด๋ค.
์ฌ๊ธฐ์ ์๊ฐํ ์ ์๋์ ์ ๋ค์๊ณผ ๊ฐ๋ค.
prices์ ๊ฐ๊ฒฉ์ 1์ด์ 10,000 ์ดํ์ธ ์์ฐ์์ด๋ฏ๋ก,
1) ๋ฐฐ์ด์ ๊ฐ์ด 1์ผ๊ฒฝ์ฐ
- ๊ทธ ๋ฐฐ์ด์ ์ต์๊ฐ์ด ๋๋ฏ๋ก, ์ฃผ์์ด ๋๋ ๋๊น์ง ๊ฐ๊ฒฉ์ ๋จ์ด์ง์ง ์๋๋ค.
- ๋ฐ๋ผ์ ๊ทธ ๊ฒฝ์ฐ ๊ธฐ๊ฐ์ ๋ฐฐ์ด์๊ธธ์ด - i - 1์ด ๋๋ค.
- ์์์ ์ฒซ ๋ฒ์งธ ๊ฐ๊ฒฉ์ ๊ฒฝ์ฐ, ๋ฐฐ์ด์๊ธธ์ด(5) - i(0) - 1 = 4 ์ด๋ค.
2) ๋ฐฐ์ด์ ๋ง์ง๋ง ๊ฐ์ ํญ์ 0์ด๋ค.
3) ๊ทธ ์ธ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง๋ ์๊ฐ์ ์ฐพ๋๋ค.
- ํ์ฌ ์ฃผ์ ๊ฐ๊ฒฉ(i)๋ฒ์งธ๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ทธ ๋ค์ ์ฃผ์ ๊ฐ๊ฒฉ(j = i+1)๋ถํฐ ๋ฐฐ์ด์ ๋๊น์ง ํ์ํ๋ค.
- ๋ง์ฝ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง๋ ๊ณณ์ด ์์๊ฒฝ์ฐ(prices[i] > prices[j])
- ๊ทธ ์๊ฐ์ j - i ๊ฐ ๋๋ค. ์์ ์์์๋ [1, 2, 3, 2, 3] 2๋ฒ์งธ๊ฐ 3๊ณผ 3๋ฒ์งธ๊ฐ 2์ ์ฐจ์ด๋ 1์ด๋ค.
- ๊ทธ ํ ์ฒดํฌ๋ฅผ ํด์ฃผ๊ธฐ์ํด flag๋ณ์๋ฅผ false๋ก ์ค์ ํ๊ณ , break๋ฅผ ํตํด ํ์ถํ๋ค.
- ๋ง์ฝ for๋ฌธ์ ๋น ์ ธ๋์ flag๊ฐ true์ธ ๊ฒฝ์ฐ(ํ์ฌ ๊ฐ๊ฒฉ์ด ๋๋ ๋๊น์ง ๋จ์ด์ง์ง ์๋ ๊ฒฝ์ฐ)
- ์์ ๊ฒฝ์ฐ๋ ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ๊ธฐ์ค์ผ๋ก ์๊ฐ์ ๊ตฌํ๋ค.(prices.length - i - 1)
๋ค๋ฅธ ์ฝ๋
class Solution {
public int[] solution(int[] prices) {
int[] answer = new int[prices.length];
for(int i=0; i<answer.length; i++){
int sec = 0;
for(int j=i+1; j<answer.length; j++){
sec ++;
if(prices[i] > prices[j])
break;
}
answer[i] = sec;
}
return answer;
}
}
๊ฐ๋จํ๋ค...
์ฃผ์ ๊ฐ๊ฒฉ์ด ์ ์ง๋๋ ์๊ฐ sec๋ฅผ ์ค์ ํ๊ณ , ๋ฐฐ์ด์ ํ์ํ๋ฉด์ 1์ด์ฉ ์ฆ๊ฐ์์ผ์ค๋ค.
๋ง์ฝ ๊ฐ๊ฒฉ์ด ์ปค์ง๋ฉด for๋ฌธ์ ํ์ถํ๊ณ , sec์ ๊ฐ์ด ์๊ฐ์ด ๋๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Codeforces] 1005A: Tanya and Stairways (0) | 2020.03.17 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)์์ ๋์งํ (0) | 2020.03.16 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ์ฐพ๊ธฐ(DP) (0) | 2020.03.16 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)ํผ๋ณด๋์น ์(์ฌ๊ท , ๋น์ฌ๊ทDP) (0) | 2020.03.16 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)ํ (0) | 2020.03.16 |
๋๊ธ