[문제풀이] P92341 주차 요금 계산

주차 요금 계산 / 구현문제 🚀

---

  🪅. 'Class'를 이용해서 많은 양의 정보를 '하나의 단위'로 정리할 수 있어야 한다.
  🪅. 'Comparable 인터페이스'와 '오버라이딩 메서드 compareTo'를 이용하여 정렬기준을 설정할 수 있어야 한다.
  🪅. 올림 시, 'Math.ceil()'을 이용할 때, 'double로 계산'한 뒤 int로 '명시적 형변환'해서 사용해야 오차가 없다.
  🪅. 'Map'으로 정보를 연결할 때, 내장메서드 '.containsKey()'를 이용하여, 이미 연결된 정보인지 아닌지를 확인할 수 있다.
  🪅. Map의 모든 key를 순회할 때, 내장메서드 'keySet()'과 '개선된 for문'을 이용하는 것이 편리하다.

  import java.util.*;
  class CarInfo implements Comparable<CarInfo>{
      int carNum;
      int hour;
      int minutes;
      String message;
      int fee;
      CarInfo(int carNum, int hour, int minutes, String message) {
          this.carNum = carNum;
          this.hour = hour;
          this.minutes = minutes;
          this.message = message;
      }
      public String toString() {
          return hour + " " + minutes + " " + message;
      }
      public int compareTo(CarInfo o) {
          return this.carNum - o.carNum;
      }
  }
  class Solution {
      int BASIC_TIME;
      int BASIC_FEE;
      int UNIT_TIME;
      int UNIT_FEE;
      Map<String, CarInfo> map = new HashMap<>();
      Map<String, Integer> minMap = new HashMap<>();

      public void recal(String key) {
          CarInfo info = map.get(key);
          int hour = info.hour;
          int min = info.minutes;

          hour = 23 - hour;
          min = 59 - min;
          int transMin = (hour * 60) + min;
          if(minMap.containsKey(key)) {
              transMin += minMap.get(key);  
          }
          minMap.put(key, transMin);
      }
      public int calFee(int accMin) {
          ///////////////////요금cal
          int fee = 0;
          if(accMin <= BASIC_TIME) {
              fee += BASIC_FEE;
          } else { //기본시간 초과
              fee = BASIC_FEE + (int)Math.ceil((accMin-BASIC_TIME)/(double)UNIT_TIME) * UNIT_FEE;
          }
          System.out.println("fee: " + fee);
          return fee;
      }
      public void cal(String carNum, CarInfo prev, CarInfo cur) {
          // System.out.println("prev: " + prev);
          // System.out.println("cur: " + cur);
          ///////////////////시간cal
          int min = cur.minutes - prev.minutes; 
          if(min < 0) {
              min = cur.minutes + (60-prev.minutes);
              cur.hour = cur.hour-1;
          }
          int hour = cur.hour - prev.hour;
          // System.out.println("hour: " + hour + " min: " + min);
          int transMin = hour * 60 + min;
          if(minMap.containsKey(carNum)) {
              minMap.put(carNum, minMap.get(carNum)+transMin);
          } else {
              minMap.put(carNum, transMin);    
          }
      }
      public void insert(String record) {
          String[] recordBits = record.split(" ");
          String time = recordBits[0];
          String[] timeBits = time.split(":");
          int hour = Integer.parseInt(timeBits[0]);
          int minutes = Integer.parseInt(timeBits[1]);
          String carNum = recordBits[1];
          String message = recordBits[2];
          // System.out.println(hour + " " + minutes);
          CarInfo info = new CarInfo(Integer.parseInt(carNum), hour, minutes, message);
          if(message.equals("OUT") && map.containsKey(carNum)) {
              cal(carNum, map.get(carNum), info);
              map.get(carNum).message = "OUT";
          } else {
              map.put(carNum, info);    
          }
      }
      public int[] solution(int[] fees, String[] records) {

          BASIC_TIME = fees[0];
          BASIC_FEE = fees[1];
          UNIT_TIME = fees[2];
          UNIT_FEE = fees[3];
          for(String record : records) {
              insert(record);            
          }

          for(String key : map.keySet()) {
              if(map.get(key).message.equals("IN")) {
                  recal(key);
              }
          }
          CarInfo[] result = new CarInfo[minMap.size()];
          int i = 0;
          for(String key : minMap.keySet()) {
              int accMin = minMap.get(key);
              int fee = calFee(accMin);
              map.get(key).fee = fee;
              result[i] = map.get(key);
              i++;
          }

          Arrays.sort(result);

          int[] answer = new int[result.length];
          for(int t = 0; t < result.length; t++) {
              answer[t] = result[t].fee;
          }

          return answer;
      }
  }

💡. 문제 접근 방법
: 입력으로 주어진 정보가 너무 많고, 그 정보를 이용해서 계산을 또 해야하기 때문에,
Class를 이용해서 정보를 정리하고, 이를 Map을 통해 (고유한 값인)key와 매핑시킴으로써,
key만 알고있다면, 관련 정보를 모두 끌어올 수 있게 구조화했다.
Class를 이용해 묶은 정보를 최대한 이용해서, 이를 기준으로 문제의 조건에 따른 로직이
다르게 수행되도록 구현했고, 정렬 기준은 인터페이스 Comparable을 이용해여 설정했다.