[programmers] ์ผ๊ทผ ์ง์ - Java
ํ์ฌ์ Demi์ ์ผ๊ทผ ํผ๋ก๋๋ฅผ ์ต์ํํ๋ ๋ฌธ์ ์์, ์ด๊ธฐ ์ฝ๋๋ ๋ฐฐ์ด์ ์ ๋ ฌํ์ฌ ์ต๋ ์์
๋์์ 1์ ๋นผ๋ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ์์ผ๋, ํจ์จ์ฑ ํ
์คํธ๋ฅผ ํต๊ณผํ์ง ๋ชปํ๋ค. ์ด๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ์ฌ ์์
๋์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ , ๊ฐ์ฅ ๋ง์ ์์
๋์ ๊ฐ์ ธ์์ 1์ ๋นผ๋ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ์๋ค. ์ด ๋ฐฉ๋ฒ์ ํ ๊ตฌ์กฐ๋ฅผ ํ์ฉํ์ฌ O(log n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
Apr 22, 2024
์ผ๊ทผ ์ง์
๋ฌธ์ ์ค๋ช
ํ์ฌ์ Demi๋ ๊ฐ๋์ ์ผ๊ทผ์ ํ๋๋ฐ์, ์ผ๊ทผ์ ํ๋ฉด ์ผ๊ทผ ํผ๋ก๋๊ฐ ์์
๋๋ค. ์ผ๊ทผ ํผ๋ก๋๋ ์ผ๊ทผ์ ์์ํ ์์ ์์ ๋จ์ ์ผ์ ์์
๋์ ์ ๊ณฑํ์ฌ ๋ํ ๊ฐ์
๋๋ค. Demi๋ N์๊ฐ ๋์ ์ผ๊ทผ ํผ๋ก๋๋ฅผ ์ต์ํํ๋๋ก ์ผํ ๊ฒ๋๋ค.Demi๊ฐ 1์๊ฐ ๋์ ์์
๋ 1๋งํผ์ ์ฒ๋ฆฌํ ์ ์๋ค๊ณ ํ ๋, ํด๊ทผ๊น์ง ๋จ์ N ์๊ฐ๊ณผ ๊ฐ ์ผ์ ๋ํ ์์
๋ works์ ๋ํด ์ผ๊ทผ ํผ๋ก๋๋ฅผ ์ต์ํํ ๊ฐ์ ๋ฆฌํดํ๋ ํจ์ solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ
works
๋ ๊ธธ์ด 1 ์ด์, 20,000 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
works
์ ์์๋ 50000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
n
์ 1,000,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
works | n | result |
[4, 3, 3] | 4 | 12 |
[2, 1, 2] | 1 | 6 |
[1,1] | 3 | 0 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
n=4 ์ผ ๋, ๋จ์ ์ผ์ ์์
๋์ด [4, 3, 3] ์ด๋ผ๋ฉด ์ผ๊ทผ ์ง์๋ฅผ ์ต์ํํ๊ธฐ ์ํด 4์๊ฐ๋์ ์ผ์ ํ ๊ฒฐ๊ณผ๋ [2, 2, 2]์
๋๋ค. ์ด ๋ ์ผ๊ทผ ์ง์๋ 22 + 22 + 22 = 12 ์
๋๋ค.
์
์ถ๋ ฅ ์ #2
n=1์ผ ๋, ๋จ์ ์ผ์ ์์
๋์ด [2,1,2]๋ผ๋ฉด ์ผ๊ทผ ์ง์๋ฅผ ์ต์ํํ๊ธฐ ์ํด 1์๊ฐ๋์ ์ผ์ ํ ๊ฒฐ๊ณผ๋ [1,1,2]์
๋๋ค. ์ผ๊ทผ์ง์๋ 12 + 12 + 22 = 6์
๋๋ค.
์
์ถ๋ ฅ ์ #3
๋จ์ ์์
๋์ด ์์ผ๋ฏ๋ก ํผ๋ก๋๋ 0์
๋๋ค.
์ฒ์ ์๋ํ ์ฝ๋
import java.util.*;
class Solution {
public long solution(int n, int[] works) {
long answer = 0;
for(int i=n; i>0; i--){
Arrays.sort(works);
if(works[works.length-1]>0){
works[works.length-1]--;
}
}
for(int i=0; i<works.length; i++){
answer += Math.pow(works[i], 2);
}
return answer;
}
}
๊ฐ์ ํ ์ฝ๋
import java.util.PriorityQueue;
import java.util.Collections;
class Solution {
public long solution(int n, int[] works) {
PriorityQueue<Integer> overtime = new PriorityQueue<>(Collections.reverseOrder());
for (int work : works) {
overtime.offer(work);
}
for (int i = 0; i < n; i++) {
int max = (int)overtime.poll();
if (max <= 0) break;
overtime.offer(max - 1);
}
return sumPow(overtime);
}
long sumPow(PriorityQueue<Integer> works) {
long sum = 0;
while (!works.isEmpty()) {
sum += Math.pow(works.poll(), 2);
}
return sum;
}
}
ํต์ฌ ํค์๋
- ์ฒ์ ์๋ํ ์ฝ๋๋
n
๋งํผ ๋ฐ๋ณตํ ๋๋ง๋ค ๋ฐฐ์ด์ ์ ๋ ฌํด์ ๋ฐฐ์ด์ ์ต๋๊ฐ์์ 1์ ๋นผ๋ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ๋ค. - ์ด ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋๋
O(nlogn)
์ด๊ณ , ํจ์จ์ฑ ํ ์คํธ๋ฅผ ํต๊ณผํ์ง ๋ชปํ๋ค.
- ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํด์ ์์ ๋์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ ์ ์ฅํ๋ค.
- ์ฃผ์ด์ง ๋ฐฐ์ด์ ์ํํ๋ฉด์ ๊ฐ ์์
๋์ ์ฐ์ ์์ ํ์ ์ ์ฅํ๊ณ ,
n
๋งํผ ๋ฐ๋ณต๋ฌธ์ ์ํํ๋ค. - ์ฐ์ ์์ ํ์์ ๊ฐ์ฅ ๋ง์ ์์
๋์ ๊ฐ์ ธ์ค๊ณ
max
๋ณ์์ ์ ์ฅํ๋ค. - ๋ง์ฝ
max
๊ฐ 0 ์ดํ๋ผ๋ฉด ๋ ์ด์ ์์ ์ ํ ์ ์์ผ๋ฏ๋ก ๋ฐ๋ณต์ ์ข ๋ฃํ๋ค. - ์์
์ ํ ์ ์๋ค๋ฉด
max
์์ 1์ ๋นผ๊ณ ๋ค์ ์ฐ์ ์์ ํ์ ๋ฃ์ด์ค๋ค. - ๊ทธ ํ ์ฐ์ ์์ ํ์ ์๋ ๊ฐ๋ค์ ์ ๊ณฑ์ ํฉ์ ๋ฐํํ๋ค.
๊ฒฐ๋ก !
ํด๋น ๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์ฐ์ ์์ ํ๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํ ์ ์๋ค๋ ๊ฒ์ ์๊ฒ ๋์๊ณ , ํ ๊ตฌ์กฐ๋ก ์ธํด
O(log n)
์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค๋ ๊ฒ์ ์๊ฒ ๋์๋ค.Share article