๐ง ํ๋ก๊ทธ๋๋จธ์ค LV2. ๊ธฐ๋ฅ๊ฐ๋ฐ
๋ฌธ์ ์ค๋ช
ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์ ์ ์ํ ์ค์ ๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด ์์ ์๋ ๊ธฐ๋ฅ๋ณด๋ค ๋จผ์ ๊ฐ๋ฐ๋ ์ ์๊ณ , ์ด๋ ๋ค์ ์๋ ๊ธฐ๋ฅ์ ์์ ์๋ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ ๋ ํจ๊ป ๋ฐฐํฌ๋ฉ๋๋ค.
๋จผ์ ๋ฐฐํฌ๋์ด์ผ ํ๋ ์์๋๋ก ์์ ์ ์ง๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด progresses์ ๊ฐ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด speeds๊ฐ ์ฃผ์ด์ง ๋ ๊ฐ ๋ฐฐํฌ๋ง๋ค ๋ช ๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์ฌํญ
- ์์ ์ ๊ฐ์(progresses, speeds๋ฐฐ์ด์ ๊ธธ์ด)๋ 100๊ฐ ์ดํ์ ๋๋ค.
- ์์ ์ง๋๋ 100 ๋ฏธ๋ง์ ์์ฐ์์ ๋๋ค.
- ์์ ์๋๋ 100 ์ดํ์ ์์ฐ์์ ๋๋ค.
- ๋ฐฐํฌ๋ ํ๋ฃจ์ ํ ๋ฒ๋ง ํ ์ ์์ผ๋ฉฐ, ํ๋ฃจ์ ๋์ ์ด๋ฃจ์ด์ง๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์ง๋์จ์ด 95%์ธ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ํ๋ฃจ์ 4%๋ผ๋ฉด ๋ฐฐํฌ๋ 2์ผ ๋ค์ ์ด๋ฃจ์ด์ง๋๋ค.
์ ์ถ๋ ฅ ์์
progresses | speeds | return |
[93, 30, 55] | [1, 30, 5] | [2, 1] |
[95, 90, 99, 99, 80, 99] | [1, 1, 1, 1, 1, 1] | [1, 3, 2] |
https://school.programmers.co.kr/learn/courses/30/lessons/42586?language=java
๐ก ๋ฌธ์ ํ์ด
๋จ์ ๋ฐ๋ณต๋ฌธ์ ํ๋ฅผ ์กฐ๊ธ ์ฌ์ฉํ๋ฉด ๊ธ๋ฐฉ ํ๋ฆฌ๋ ๋ฌธ์ ์๋ค.
ํ์ progress์ speed ์ ๋ณด๋ฅผ ์ถ๊ฐํ๊ณ , ์งํ๋ฅ ์ด ์๋ฃ๋๋ฉด ์ฐจ๋ก๋๋ก ๋ฐฐํฌ๋ ์์ ์ ๊ฐ์๋ฅผ ๊ณ์ฐํด์ answer ๋ฐฐ์ด์ ์ถ๊ฐํ๋ฉด ๋๋ค.
progress์ speed ์ ๋ณด๋ฅผ ํ ๋ฒ์ ์ ์ฅํ๊ธฐ ์ํด์ ํด๋์ค๋ฅผ ์ ์ํด์ฃผ์๋ค.
static class Work {
int progress;
int speed;
Work(int progress, int speed) {
this.progress = progress;
this.speed = speed;
}
public int getTotalProgress(int day) { // ํน์ ์ผ ์(day)๊ฐ ์ง๋ ํ ์งํ๋ฅ
return this.progress + this.speed * day;
}
}
์งํ๋ฅ ์ธ progress์ ๊ฐ๋ฐ ์๋์ธ speed ์ ๋ณด๋ฅผ ์ ์ฅํ๊ณ ์๊ณ ,
getTotalProgress ๋ฉ์๋์์ ํน์ ์ผ ์(day)๊ฐ ์ง๋ ํ์ ์งํ๋ฅ ์ ๊ตฌํ ์ ์๋ค.
progresses์ speeds์ ์ ๋ณด๋ฅผ ํ์ ์ ์ฅํ๋ค.
Queue<Work> queue = new LinkedList<>();
for (int i = 0; i < progresses.length; i++) {
queue.add(new Work(progresses[i], speeds[i]));
}
์ด์ ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์์ ํด๋์ค ๊ฐ์ฒด๋ฅผ ์ฒ๋ฆฌํ๊ณ , ๊ฒฐ๊ณผ๋ฅผ ๊ตฌํ๋ค.
List<Integer> al = new ArrayList<>(); // ๊ฐ ๋ฐฐํฌ์ ์์
๊ฐ์๋ฅผ ํฌํจํ๋ ๋ฆฌ์คํธ
int day = 0, count = 0; // day: ์ง๋ ์ผ ์, count: ๋ฐฐํฌ ๋๊ธฐ ์์
๊ฐ์
while (!queue.isEmpty()) {
Work work = queue.peek(); // ๋จ์ ์์
์ค ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ์์
if (work.getTotalProgress(day) >= 100) { // ์งํ ์๋ฃ(๋ฐฐํฌ)
queue.poll();
count++; // ๋ฐฐํฌ ๊ฐ์ ์ฆ๊ฐ
} else { // ์งํ ์ค
if (count > 0) { // ๋ฐฐํฌ ์์
์ด ์์ผ๋ฉด ๋ฐ์ ํ ์ด๊ธฐํ
al.add(count);
count = 0;
}
day++; // ์ผ ์ ์ฆ๊ฐ
}
}
if (count > 0) al.add(count); // ๋ฐฐํฌ๋ ์์
์ด ์์ผ๋ฉด ๋ง์ง๋ง ๋ฐ์
์ฐ์ ์์๊ฐ ๋์ ์์ ์์๋๋ก ๋ฐฐํฌ ์ฌ๋ถ๋ฅผ ํ๋จํ๊ณ ์ฒ๋ฆฌํ๋ค.
๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํ๋ค๋ฉด, ํ์์ ๊บผ๋ด๊ณ ๋ฐฐํฌ ๊ฐ์๋ฅผ ์ฆ๊ฐ์ํจ๋ค.
๋ฐฐํฌ ์ ์ด๋ผ๋ฉด, ๋ฐฐํฌ ํ ์์ ์ด ์๋ค๋ฉด(count > 0) ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ๋ฐ์ํด์ฃผ๊ณ ๊ฐ์ 0์ผ๋ก ์ด๊ธฐํํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ผ ์๋ฅผ ์ฆ๊ฐ์ํจ๋ค.
๋ฐ๋ณต๋ฌธ์ด ๋๋ ํ, ๋ฐฐํฌํ ์์ ์ด ์๋ค๋ฉด ๋ง์ง๋ง์ผ๋ก ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ๋ฐ์ํด์ค๋ค.
์ ํ์ด ๋ฐฉ์์ ์ ์ฒด ์ฝ๋๋ก ํ์ด๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
import java.util.*;
class Solution {
static class Work {
int progress;
int speed;
Work(int progress, int speed) {
this.progress = progress;
this.speed = speed;
}
public int getTotalProgress(int day) {
return this.progress + this.speed * day;
}
}
public int[] solution(int[] progresses, int[] speeds) {
Queue<Work> queue = new LinkedList<>();
for (int i = 0; i < progresses.length; i++) {
queue.add(new Work(progresses[i], speeds[i]));
}
List<Integer> al = new ArrayList<>();
int day = 0, count = 0;
while (!queue.isEmpty()) {
Work work = queue.peek();
if (work.getTotalProgress(day) >= 100) { // ์งํ ์๋ฃ
queue.poll();
count++;
} else { // ์งํ ์ค
if (count > 0) { // ๋ฐฐํฌ ์์
์ด ์์ผ๋ฉด ๋ฐ์ ํ ์ด๊ธฐํ
al.add(count);
count = 0;
}
day++;
}
}
if (count > 0) al.add(count);
int[] answer = new int[al.size()];
for (int i = 0; i < al.size(); i++) {
answer[i] = al.get(i);
}
return answer;
}
}
โจ ํฌ์คํ ์ ๋ง์น๋ฉฐ
์ด๋ฒ ๋ฌธ์ ๋ ์กฐ๊ฑด์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ๋ง ์ ์ดํดํ๊ณ ์ ๋ฆฌํ๋ฉด ๊ธ๋ฐฉ ์ฝ๊ฒ ํ ์ ์์๋ค. ์ฝ๋ฉํ ์คํธ์์๋ ์ ํ๋ ์๊ฐ์ด ์์ผ๋ฏ๋ก ๋ฌธ์ ๋ฅผ ๋น ๋ฅด๊ฒ ์ฝ๊ณ ์ดํดํ๋ ๊ฒ์ ์ต์ํด๋ ๊ฒ์ด ์ค์ํ๋ค๊ณ ์๊ฐ๋์๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค LV3] ๋์คํฌ ์ปจํธ๋กค๋ฌ(Heap, ํ) (1) | 2023.10.18 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค LV2] ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญ(Queue, ํ) (2) | 2023.10.17 |
[๋ฐฑ์ค 1162] ๋๋กํฌ์ฅ (Dijkstra, ๋ค์ต์คํธ๋ผ) (2) | 2023.10.16 |
[๋ฐฑ์ค 1446] ์ง๋ฆ๊ธธ (Dijkstra, ๋ค์ต์คํธ๋ผ) (0) | 2023.10.15 |
[ํ๋ก๊ทธ๋๋จธ์ค LV3] ๋ฒ ์คํธ ์จ๋ฒ (Hash, ํด์) (2) | 2023.10.14 |