기능개발 (HashMap, Arraylist) , (Queue)

문제 설명

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.

또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.

먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

제한 사항

• 작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
• 작업 진도는 100 미만의 자연수입니다.
• 작업 속도는 100 이하의 자연수입니다.
• 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

입출력 예

progresses	speeds	return
[93,30,55]	[1,30,5]	[2,1]

입출력 예 설명

첫 번째 기능은 93% 완료되어 있고 하루에 1%씩 작업이 가능하므로 7일간 작업 후 배포가 가능합니다.
두 번째 기능은 30%가 완료되어 있고 하루에 30%씩 작업이 가능하므로 3일간 작업 후 배포가 가능합니다. 하지만 이전 첫 번째 기능이 아직 완성된 상태가 아니기 때문에 첫 번째 기능이 배포되는 7일째 배포됩니다.
세 번째 기능은 55%가 완료되어 있고 하루에 5%씩 작업이 가능하므로 9일간 작업 후 배포가 가능합니다.

따라서 7일째에 2개의 기능, 9일째에 1개의 기능이 배포됩니다.

import java.util.*;

public class DelvelopFunction {

    public static void main(String[] args) {

        int programs[] = { 93, 30, 55, 46, 28 };

        int speeds[] = { 40, 20, 5, 30, 5 };

        Solution s = new Solution();

        // System.out.println(s.solution(b1, w1, t1));

        // System.out.println(s.solution(b2, w2, t2));

        System.out.println(Arrays.toString(s.solution(programs, speeds)));

    }

}

class Solution {

    public int[] solution(int[] progresses, int[] speeds) {

        Map<Integer, Integer> progress = new HashMap<>();

        ArrayList<Integer> progress_index = new ArrayList<>();

        ArrayList<Integer> complete_index = new ArrayList<>();

        ArrayList<Integer> answers = new ArrayList<>();

        // hashmap에 프로그램 담음

        for (int i = 0; i < progresses.length; i++) {

            progress.put(i, progresses[i]);

        }

        // hashmap이 비워질 때 까지 루프

        while (progress.size() > 0) {

            // 각 분기별로 정해진 속도로 프로그램상태(해쉬맵)를 증가시킴

            for (int i : progress.keySet()) {

                int temp = progress.get(i) + speeds[i];

                progress.put(i, temp);

            }

            // 프로그램의 배포우선순위를 구분하기 위해 프로그램상태(해쉬맵)을 key값(배포우선순위) 으로 정렬

            TreeMap<Integer, Integer> tm = new TreeMap<Integer, Integer>(progress);

            Set<Integer> keyset = progress.keySet();

            Iterator<Integer> keyiterator = tm.descendingKeySet().iterator(); // 키값 내림차순 정렬

            // 현재 프로그램 배포우선순위를 구분하기 위한 progress_index(ArrayList) 에 저장

            while (keyiterator.hasNext()) {

                progress_index.add(keyiterator.next());

            }

            int block = 0;

            // 우선순위가 낮은 애들부터 순회

            for (int i = 0; i < progress_index.size(); i++) {

                block = 0;

                // 만약 완료되었다면

                if (progress.get(progress_index.get(i)) > 99) {

                    // 우선순위가 맨 위인 경우 (인덱스 배열에선 가장 마지막 값)

                    if (i == progress_index.size() - 1) {

                        block = 0;

                    }

                    // 상위 프로그램이 있는 경우라면

                    else {

                        // 자신보다 우선순위가 높은애들의 완료여부 판별

                        for (int q = i + 1; q < progress_index.size(); q++) {

                            // 만약 하나라도 완료되지 않은 프로그램이 있다면

                            if (progress.get(progress_index.get(q)) < 100) {

                                block++; // 카운터 증가

                            }

                        }

                    }

                }

                // 완료되지 않았다면

                else {

                    block++;

                }

                // 자신이 완료되고 and 자신보다 우선순위가 높은 프로그램이 다 완료가 되었을때만 그 자신이 나갈 수 있다.

                if (block == 0) {

                    complete_index.add(progress_index.get(i)); // completed index에 추가

                }

            }

            // 빠져나간 프로그램들은 map에서 지워줌

            for (int i : complete_index) {

                progress.remove(i);

            }

            // 해당 분기에 완료된 프로그램 수를 기록

            if (complete_index.size() > 0) {

                answers.add(complete_index.size()); 

            }

            progress_index.clear();

            complete_index.clear();

        }

        // ArrayList --> Array 변환과정

        int[] answer = new int[answers.size()]; 

        for (int i = 0; i < answers.size(); i++) {

            answer[i] = answers.get(i);

        }

        return answer;

    }

}

import java.util.*;

public class DelvelopFunction_v2 {

    public static void main(String[] args) {

        int programs[] = { 93, 30, 55, 46, 28 };

        int speeds[] = { 40, 20, 5, 30, 5 };

        Solution s = new Solution();

        // System.out.println(s.solution(b1, w1, t1));

        // System.out.println(s.solution(b2, w2, t2));

        System.out.println(Arrays.toString(s.solution(programs, speeds)));

    }

}

class Solution {

    public int[] solution(int[] progresses, int[] speeds) {

        Queue<Integer> queue = new LinkedList<Integer>();

        ArrayList<Integer> answers = new ArrayList<Integer>();

        int index = 0;

        int count = 0;

        // index(프로그램완료수) 가 프로그램 수보다 작을때까지 루프

        while (index < progresses.length) {

            // 해당하는 속도만큼 프로그램 업데이트

            for (int i=0; i<progresses.length; i++) {

                int temp = progresses[i] + speeds[i];

                progresses[i] = temp;

            }

            // 한분기 업데이트 후 큐에 저장

            for (int i = index; i < progresses.length; i++) {

                queue.offer(progresses[i]);

            }

            System.out.println(queue);

            // 큐에 저장된 상태를 분석하는 루프

            int peek;

            while (queue.size() > 0) {

                peek = queue.peek();

                if (peek < 100)   {

                    break;

                }

                // 값이 99보다 크면 큐에서 지운 후 index를 증가

                else if(peek > 99){

                    queue.poll();

                    index++;

                    count++;

                }

            }

            // 해당 분기에서 일어난 프로그램 완료수(count) 를 기록

            if (count != 0) {

                answers.add(count);

            }

            queue.clear();

            count = 0;

        }

        int[] answer = new int[answers.size()]; // 0이 아닌 숫자만큼 answer 배열 선언

        // ArrayList --> Array 변환과정

        for (int i = 0; i < answers.size(); i++) {

            answer[i] = answers.get(i);

        }

        return answer;

    }

}