2022 카카오 인턴 코딩테스트 공부

문제 설명
[본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.]

당신은 코딩 테스트를 준비하기 위해 공부하려고 합니다. 코딩 테스트 문제를 풀기 위해서는 알고리즘에 대한 지식과 코드를 구현하는 능력이 필요합니다.

알고리즘에 대한 지식은 알고력, 코드를 구현하는 능력은 코딩력이라고 표현합니다. 알고력과 코딩력은 0 이상의 정수로 표현됩니다.

문제를 풀기 위해서는 문제가 요구하는 일정 이상의 알고력과 코딩력이 필요합니다.

예를 들어, 당신의 현재 알고력이 15, 코딩력이 10이라고 가정해보겠습니다.

A라는 문제가 알고력 10, 코딩력 10을 요구한다면 A 문제를 풀 수 있습니다.
B라는 문제가 알고력 10, 코딩력 20을 요구한다면 코딩력이 부족하기 때문에 B 문제를 풀 수 없습니다.
풀 수 없는 문제를 해결하기 위해서는 알고력과 코딩력을 높여야 합니다. 알고력과 코딩력을 높이기 위한 다음과 같은 방법들이 있습니다.

알고력을 높이기 위해 알고리즘 공부를 합니다. 알고력 1을 높이기 위해서 1의 시간이 필요합니다.
코딩력을 높이기 위해 코딩 공부를 합니다. 코딩력 1을 높이기 위해서 1의 시간이 필요합니다.
현재 풀 수 있는 문제 중 하나를 풀어 알고력과 코딩력을 높입니다. 각 문제마다 문제를 풀면 올라가는 알고력과 코딩력이 정해져 있습니다.
문제를 하나 푸는 데는 문제가 요구하는 시간이 필요하며 같은 문제를 여러 번 푸는 것이 가능합니다.
당신은 주어진 모든 문제들을 풀 수 있는 알고력과 코딩력을 얻는 최단시간을 구하려 합니다.

초기의 알고력과 코딩력을 담은 정수 alp와 cop, 문제의 정보를 담은 2차원 정수 배열 problems가 매개변수로 주어졌을 때, 모든 문제들을 풀 수 있는 알고력과 코딩력을 얻는 최단시간을 return 하도록 solution 함수를 작성해주세요.

모든 문제들을 1번 이상씩 풀 필요는 없습니다. 입출력 예 설명을 참고해주세요.

https://school.programmers.co.kr/learn/courses/30/lessons/118668

1. 이 문제는 첫 시작인 alp, cop와 
maxAlp, maxCop를 계산하는 것으로 
점수의 범위를 한정짓는다. (메모라이제이션하기위해)

2. 점수의 범위인 DP[maxAlp][maxCop]를 정의한다.
다익스트라는 낮은 cost일 때만 갱신한다.

3. 능력을 더해가지만 maxAlp와 maxCop를 넘어가는 능력치는
범위를 넘어서고 필요도 없기 때문에
maxAlp = min(maxAlp, num) 해준다.

4. 풀 필요 없는 아이는 풀지 않아도 된다. cost > num1 + num2

import java.util.*;
class Solution {
    public int solution(int alp, int cop, int[][] problems) {
        int alMax = alp;
        int coMax = cop;
        int answer = 0;
        ArrayList<int[]> probArrays = new ArrayList<>();
        probArrays.add(new int[]{0, 0, 1, 0, 1});
        probArrays.add(new int[]{0, 0, 0, 1, 1});
        for(int arr[] : problems) {
            probArrays.add(arr);
            int proA = arr[0];
            int proB = arr[1];
            alMax = Math.max(proA, alMax);
            coMax = Math.max(proB, coMax);
        }
        // 최고 높은 것이 0이면 시간이 들지 않는다
        if(alMax == 0 && coMax == 0) {
            return 0;
        }
        // 최고 높은 것이 alp, cop이면 시간이 들지 않는다
        if(alMax == alp && coMax == cop) {
            return 0;
        }

        // 그렇지 않으면 최단 시간을 찾아야 한다

  

        // cost가 작은 친구를 항상 갱신해줄 것
        int DP[][] = new int[alMax + 1][coMax + 1];
        for(int arr[] : DP) {
            Arrays.fill(arr, Integer.MAX_VALUE);
        }
        DP[alp][cop] = 0;



        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(0, alp, cop));
        while(!pq.isEmpty()) {
            Node nd = pq.poll();
            if(nd.curAlgo == alMax && nd.curCode == coMax) {
                answer = nd.time;
                break;
            }
           
            for(int arr[] : probArrays) {
                int n1 = arr[0];
                int n2 = arr[1];
                int n3 = arr[2];
                int n4 = arr[3];
                int cost = arr[4];
                if(n1 > nd.curAlgo || n2 > nd.curCode) {
                    continue;
                }
                int num1 = nd.curAlgo + n3;
                int num2 = nd.curCode + n4;
                num1 = Math.min(alMax, num1);
                num2 = Math.min(coMax, num2);


                if(DP[nd.curAlgo][nd.curCode] + cost < DP[num1][num2]) {
                    DP[num1][num2] = DP[nd.curAlgo][nd.curCode] + cost;
                    pq.add(new Node( DP[num1][num2], num1 , num2));
                }

            }


        }


        return answer;
    }
    
    static class Node implements Comparable<Node> {
        int time;
        int curAlgo;
        int curCode;

        public Node(int time, int curAlgo, int curCode) {
            this.time = time;
            this.curAlgo = curAlgo;
            this.curCode = curCode;
        }



        @Override
        public int compareTo(Node o) {
            return this.time - o.time;
        }
    }
}