ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ์ Lv1 ๊ณผ์ผ ์ฅ์ ๋ฌธ์ ๋ฅผ ์๋์ ๊ฐ์ด ํ์๋๋ฐ ์๊ฐ์ด๊ณผ๊ฐ ๋ด๋ค.
class Solution {
public int solution(int k, int m, int[] score) {
int answer = 0;
List<Integer> intList = Arrays.stream(score)
.boxed()
.collect(Collectors.toList());
Collections.sort(intList, Collections.reverseOrder());
Stack<Object> stack = new Stack<>();
for (int i = 0; i < score.length - (score.length % m); i++) {
stack.push(intList.remove(0));
if (stack.size() == m) {
answer += (m * Integer.parseInt(stack.peek().toString()));
stack.clear();
}
}
return answer;
}
}
๋ด๊ฐ ์๊ฐํ ๋ก์ง์ ์๋์ ๊ฐ๋ค.
1. intํ ๋ฐฐ์ด์ List๋ก ๋ณํ ํ, ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํด์ค๋ค.
2. ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํด์ค List๋ฅผ ์ฒซ๋ฒ์งธ index๋ถํฐ (๋ฆฌ์คํธ ๊ธธ์ด - ๋ฆฌ์คํธ ๊ธธ์ด์์ m๊ฐ์ ๋๋ ๋๋จธ์ง)๊น์ง ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ ์ฐจ๋ก๋๋ก stack์ pushํ๋ค.
3. stack์ size๊ฐ m์ด ๋๋ฉด, stack์์ ์ ์ผ ๋ง์ง๋ง์ ๋ฃ์ ๊ฐ(๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ ํ๊ธฐ์ ์ต์๊ฐ์ด ๋จ)์ ๊ฐ์ ธ์์ m๊ณผ ๊ณฑํด์ answer์ ๋ํด์ค๋ค.
4. stack์ clearํ๊ณ ๊ณ์ ๋ฐ๋ณตํ๋ค.
์ ์๊ฐ์ด๊ณผ๊ฐ ๋ด์๊น ์๊ฐ์ ํด๋ณด์๋๋ฐ,
intํ ๋ฐฐ์ด์์ Integerํ ๋ฆฌ์คํธ๋ก ๋ณํํ๋ ๊ณผ์ ์์ ์๊ฐ์ ๋ง์ด ์ฌ์ฉํ ๊ฒ ๊ฐ๊ณ ,
๊ตณ์ด stack์ ์ฌ์ฉ์ํด๋ ๋ ๋ฌธ์ ์๊ณ , ๋ฆฌ์คํธ ๊ธธ์ด ๋งํผ ์ ์ฒด ๋ฐ๋ณต์ ์ํด๋ ๋ ๋ฌธ์ ์ธ๋ฐ ํด์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ ๊ฒ ๊ฐ๋ค.
๊ทธ๋์ ๋ด๊ฐ ๋ค์ ์๊ฐํ ๋ก์ง์ ์๋์ ๊ฐ๋ค.
1. ๋ฐฐ์ด ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
2. ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ํ๊ธฐ ๋๋ฌธ์, ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ m์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ i์ ์์๊ฐ์ผ๋ก ์ค์ ํ๋ค
=> ์๋ฅผ ๋ค์ด, m์ 4์ด๊ณ , [1, 2, 3, 1, 2, 3, 1]๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์ ํ๋ฉด [1, 1, 1, 2, 2, 3, 3]์ด ๋๋๋ฐ [2, 2, 3, 3]์ผ๋๊ฐ ์ต์๊ฐ์ด ๊ฐ์ฅ ํฌ๋ฏ๋ก, ๋ฐฐ์ด์ ๊ธธ์ด(=7)์ m(=4)์ผ๋ก ๋๋ ๋๋จธ์ง๋ 3์ด๊ณ ๊ทธ๋งํผ ๋ฒ๋ ค์ผ ํ๋ค. ๋ฐ๋ผ์ ์์์ ์ ๋๋จธ์ง์ ์ธ๋ฑ์ค๋ก ์ค์ ํ๋๊ฒ์ด๋ค.
3. ๊ทธ๋ฆฌ๊ณ ๋ฐ๋ณต๋ฌธ์ด ๋๋ฉด์ ๋ํด์ง๋ i์ ๊ฐ์ +1์ด ์๋, m๋งํผ ๋ํด์ค๋ค.
=> ์ธ๋ฑ์ค๋ฅผ ๋ค ํ์ํ ํ์์์ด, ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ด๊ธฐ์ ์ต์๊ฐ๋ง ๊ตฌํด์ฃผ๋ฉด ๋๊ธฐ๋๋ฌธ
4. ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ ํด๋น ๋ฐฐ์ด์ ์ธ๋ฑ์ค ๊ฐ * m์ answer์ ๋ํด์ค๋ค.
//๋ก์ง์ ์ฝ๋๋ก ๊ตฌํ
import java.util.Arrays;
class Solution {
public int solution(int k, int m, int[] score) {
int answer = 0;
Arrays.sort(score);
for (int i = score.length % m; i < score.length; i= i+m) {
answer += score[i]*m;
}
return answer;
}
}
ํจ์ฌ ๊ฐ๋จํ ๋ฌธ์ ์๋ค.