+1 2022 KAKAO BLIND RECRUITMENT 주차 요금 계산

import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

class Solution {
    static int defaultMinute;
    static int defaultFee;
    static int unitMinute;
    static int unitFee;
    
    public static class Park{
        int enteredTime = 0;
        int accTime=0;
        boolean isIn = false;
    }
    
    public int[] solution(int[] fees, String[] records) {
        defaultMinute = fees[0]; defaultFee = fees[1]; unitMinute = fees[2]; unitFee=fees[3];
        Map<String, Park> inCar = new HashMap<>();
        
        List<String> cars = new ArrayList<>();
        
        for(int i=0; i<records.length; i++){
            String[] inputData =  records[i].split(" ");
            for(String el : inputData){
            }
            if(inputData[2].equals("IN")){
                Park park;
                if(inCar.containsKey(inputData[1])){
                    park = inCar.get(inputData[1]);
                }else{
                    park = new Park();
                    inCar.put(inputData[1],park);
                    cars.add(inputData[1]);
                }
                park.isIn=true;
                park.enteredTime = dateToNum(inputData[0]);
            }else{
                Park park = inCar.get(inputData[1]);
                
                int diff = dateToNum(inputData[0]) - park.enteredTime;    
                
                park.isIn=false;
                park.accTime += diff;
            }
        }
        
        Collections.sort(cars);
        
        int[] res = new int[cars.size()];
        
        for(int i=0; i<cars.size(); i++){
            String curCar = cars.get(i);
            Park park = inCar.get(curCar);
            int fee = 0;
            if(park.isIn){
                int end = dateToNum("23:59");
                int minute = end - park.enteredTime;
                fee = calcFee(minute+park.accTime);
            }else{
                fee = calcFee(park.accTime);
            }
            res[i] = fee;
        }
        System.out.println(Integer.parseInt("01"));
        System.out.println((int)Math.ceil(127)*3);
        return res;
        
    }
    public int dateToNum(String date){
        int res = 0;
        String[] time = date.split(":");
        res+= 60*Integer.parseInt(time[0]) + Integer.parseInt(time[1]);
        
        return res;
    }
    
    public int calcFee(int minute){
        int res = defaultFee;
        if(minute >defaultMinute){
            int diff;
            
            // Math.ceil로 하면 안되더라
            
            if((minute-defaultMinute)%unitMinute ==0){
                diff = (minute-defaultMinute)/unitMinute*unitFee;
            }else{
                diff = ((minute-defaultMinute)/unitMinute+1)*unitFee;
            }
            res+=diff;
        }
        return res;
    }
}

1. Collection 내부의 원소가 참조형(클래스, 다른 콜렉션등)일때
   한번 참조하면 재갱신 안해도된다.
   Map.put(참조함,갱신값) -> 불필요

2. 시간 비교할때 분으로 나타낸 값으로 비교하면 편하다./

두번째

import java.util.*;

class Solution {
    class ParkInfo implements Comparable{
        public int carNum = 0;
        public int inTime = 0;
        public boolean isIn = false;
        public int outTime = 23*60+59; // 출차시간 23:59로 초기화
        public int accTime = 0;
        public int fee=0;
        
        public ParkInfo(int inTime,int carNum,boolean isIn){
            this.inTime = inTime;
            this.carNum = carNum;
            this.isIn = isIn;
        }
        
        @Override 
        public int compareTo(Object o){
            ParkInfo p = (ParkInfo) o;
            return this.carNum-p.carNum;
        }
    }
    
    int[] fees;
    Map<Integer,ParkInfo> map = new HashMap<>();
    
    public int[] solution(int[] fees, String[] records) {
        this.fees = fees;
        for(String rec : records){
            String[] data = rec.split(" ");
            int carNum = Integer.parseInt(data[1]);
            if(data[2].equals("IN")){
                // 차량 진입할때
                int curInTime = toMin(data[0]);
                if(map.containsKey(carNum)){
                    ParkInfo curCar = map.get(carNum);
                    curCar.inTime = curInTime;
                    curCar.isIn = true;
                    curCar.outTime = 23*60+59; // 출차시간 다시 초기화
                }else
                    map.put(carNum,new ParkInfo(curInTime,carNum,true));
                
            }else{
                // 출차 할때 -> 누적시간 계산해준다.
                ParkInfo curCar = map.get(carNum);
                curCar.outTime = toMin(data[0]);
                curCar.isIn = false;
                curCar.accTime+=curCar.outTime - curCar.inTime;
            }
        }
        List<ParkInfo> list = new ArrayList<>();
        // 차 하나씩 요금 계산하기 
        for(Integer key : map.keySet()){
            list.add(map.get(key));
        }
        Collections.sort(list);
        
        int[] answer = new int[list.size()];
        for(int i=0; i<list.size(); i++){
            answer[i] = calcFee(list.get(i));
        }
        return answer;
    }
    public int toMin(String data){
        String[] tmpData = data.split(":");
        return Integer.parseInt(tmpData[0])*60 + Integer.parseInt(tmpData[1]);
    }
    public void setTime(ParkInfo parkInfo,int outTime){
        parkInfo.accTime+= outTime - parkInfo.inTime;
    }
    public int calcFee(ParkInfo parkInfo){
        if(parkInfo.isIn) parkInfo.accTime+=parkInfo.outTime-parkInfo.inTime;
        int total = parkInfo.accTime;
        if(total > fees[0]){
        
        // ****** 이 파트에서 오지게 많이 틀렸다 **********//
            return fees[1] + ((int) Math.ceil((double)(total-fees[0])/(double)fees[2])) * fees[3];
        }else return fees[1];
    }
}

Math.ceil() -> (int) /(int) 는 0으로 되어 버린다.
(double)/(double)로 치환해서 해줘야함