프로그래머스 - 주차 요금 계산

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

프로그래머스

 

 

 

 

 

📑 문제 요약

입력

• 입력값 : 주차 요금표(fees), 차량의 입차/출차 기록(records)
  • 예시
    • fees [180, 5000, 10, 600] : 기본 시간(분), 기본 요금(원), 단위 시간(분), 단위 요금(원)
    • records ["05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"] : 시각(시:분), 차량 번호, 내역
• 결과값 : 차량 번호가 작은 자동차부터 청구할 주차 요금
  • 예시
    • [14600, 34400, 5000]

 

조건

• 입차된 후 출차된 내역 없으면 23:59에 출차된 것으로 간주
• 차량별 누적 주차 시간을 계산하여 요금을 일괄로 정산
• 누적 주차 시간이 기본 시간이하라면, 기본 요금
  • 기본 시간을 초과하면, 기본 요금에 더해서, 초과한 시간에 대해서 단위 시간 마다 단위 요금을 청구
  • 초과한 시간이 단위 시간으로 나누어 떨어지지 않으면, 올림

제한

• fees의 길이 = 4
• 1 ≤ records의 길이 ≤ 1,000

 

 

 

💡 구현하기

자료 구조

• HashMap
  • 시간복잡도 : put - O(1), get - O(1), containskey - O(1)
    • ArrayList와 비교 : add - O(n), get - O(1), remov(1)
  • recordMap : 차량 번호를 key로 해서, 입차 시간을 저장
• TreeMap 
  • SortedMap 인터페이스를 상속받는 클래스
  • timeMap : 차량 번호를 key로 해서, 누적 주차 시간을 value에 저장

로직

1. records를 읽어서, 문자열 파싱
2. IN(입차)면 recordMap에 넣고,
3. OUT이면 recordMap에 저장된 입차 시간을 꺼내서 → 주차 시간을 계산
4. 누적 주차 시간 기록하기
   • timeMap에 있으면 요금 누적시키고
   • 없으면 timeMap에 새로 넣기
5. 출차된 내역이 없으면, 일괄 23:59로 적용해서 → 주차 시간 계산 → 누적 주차 시간에 기록하기
6. 요금표에 따라 요금 계산하기

 

 

 

 

👩🏻‍💻 코드

import java.util.*;

class Solution {
    static Map<String, Integer> timeMap; //key: 차량번호, value: 누적 주차 시간
    
    public int[] solution(int[] fees, String[] records) {
        //records
        HashMap<String, String> recordMap = new HashMap<>(); //key: 차량번호, value: 시각
        timeMap  = new TreeMap<>(); //차량 번호 작은 자동차 순으로 정렬되게
        
        for(int i = 0; i < records.length; i++) {
            String[] strs = records[i].split(" ");
            String time = strs[0];
            String num = strs[1];
            String status = strs[2];
            
            if(status.equals("IN")) { //입차
                recordMap.put(num, time); //맵에 넣기
            } else { //출차
                String inTime = recordMap.get(num);
                recordMap.remove(num);
                
                //주차시간 계산
                int parkTime = getParkTime(inTime, time); //입차시간, 출차시간
                
                //누적 주차 시간 기록
                if(timeMap.containsKey(num)) { //누적 주차 시간 기록에 있으면
                    int minSum = timeMap.get(num);
                    timeMap.put(num, minSum + parkTime); //요금 누적시키기
                } else { //시간 기록에 없으면
                    timeMap.put(num, parkTime); //새로 넣기
                }
            }
        }
        
        //출차된 내역이 없음
        for(String key : recordMap.keySet()) {
            String inTime = recordMap.get(key);
            
            //주차시간 계산
            int parkTime = getParkTime(inTime, "23:59"); //입차시간, 출차시간
                
            //누적 주차 시간 기록
            if(timeMap.containsKey(key)) { //요금 기록에 있으면
                int minSum = timeMap.get(key);
                timeMap.put(key, minSum + parkTime); //요금 누적시키기
            } else { //요금 기록에 없으면
                timeMap.put(key, parkTime); //새로 넣기
            }
        }
        
        //요금 계산하기
        int[] answer = new int[timeMap.size()];
        int idx = 0;
        for(String key : timeMap.keySet()) {
            int minSum = timeMap.get(key);
            
            System.out.println(minSum);
            
            int fee = calculateFee(fees, minSum);
            answer[idx] = fee;
            idx++;
        }
        
        return answer;
    }
    
    public int calculateFee(int[] fees, int minSum) { //요금표, 누적 주차 시간
        //fees
        int standardTime = fees[0];
        int standardFee = fees[1];
        int unitTime = fees[2];
        int unitFee = fees[3];
        
        int fee = 0;
        if(minSum <= standardTime) { //기본 시간이하
            fee = standardFee;
        } else { //기본 시간초과
            fee = standardFee + (int)Math.ceil((minSum - standardTime) / (double)unitTime) * unitFee;
        }
        
        return fee;
    }
    
    public int getParkTime(String inTime, String outTime) { //입차시간, 출차시간
        String[] inTimeStr = inTime.split(":");
        String[] outTimeStr = outTime.split(":");
        
        int inMinute = Integer.parseInt(inTimeStr[0]) * 60 + Integer.parseInt(inTimeStr[1]);
        int outMinute = Integer.parseInt(outTimeStr[0]) * 60 + Integer.parseInt(outTimeStr[1]);
        
        return outMinute - inMinute;
    }
}

 

 

 

 

 

🔎 결과

 

 

 

 

 

🎤 후기

• 시간복잡도 개선을 위한 자료구조 생각하기
  • 처음에는 ArrayList 쓰려고 했는데, 시간을 줄이기 위해 HashMap으로 구현으로 바꿈
• 익숙하지 않은 HashMap 메소드 사용
  • put, get, containsKey는 익숙함
  • HashMap 전체를 조회하기 위해 hashmap.keySet()으로 키로 조회하는 방식 사용
  • HashMap key로 정렬 : TreeMap은 SortedMap 인터페이스를 상속받는 클래스
  • IDE 없이 구현하려면 정렬이나 Iterator 등 메소드 더 공부해야겠다고 생각
• 올림함수 및 형변환
  • 나누기 결과로 실수를 얻기 위해 double로 형변환
  • 올림 함수 ceil 후, int로 형변환
• 같은 동작을 여러 번 수행하므로 함수화하려고 노력함