solve: week11 Gahyun

.gitignore

@@ -2,3 +2,12 @@
 /coding_test_study.iml
 /out/
 /coding_test_study/.idea/workspace.xml
+/build.gradle
+/gradlew
+/gradlew.bat
+/settings.gradle
+/src/main/java/week01/
+/src/main/java/week02/
+/src/main/java/week03/
+/src/main/java/week04/
+/src/main/java/week05/

src/main/java/week11/gahyun/p1/Solution.java

@@ -0,0 +1,88 @@
+package week11.gahyun.p1;
+
+/**
+ * 2x2이므로 dfs아닌 완전 탐색
+ * 헷갈린점:
+ * (1) 블록 내리기
+ * 	    - block[r] 아래부터 위로 탐색
+ * 	    	- writeRow는 어디까지 썼는지 나타내는 포인터 (r과 동일하게 아래부터)
+ * 			- if) block[r] 빈칸 아니면
+ * 				- block[writeRow] = block[r]
+ * 				- writeRow--;
+ * 		- writeRow ~ 0까지 빈칸으로 채우기
+ *  (2) mark 배열 둬야 함 하나의 배열로 처리 불가
+ */
+
+class Solution {
+	static char[][] block;
+	static boolean[][] marked;
+	public int solution(int m, int n, String[] board) {
+		int totalRemoveCnt = 0;
+		block = new char[m][n];
+		marked = new boolean[m][n];
+
+		initBlock(board,m,n); //board-> block
+
+		while (true){
+			//1) 2x2 체크
+			mark(m,n);
+
+			//2) 체크된 곳 빈칸 처리
+			int removeCnt = erase(m,n);
+			if (removeCnt==0) break;
+			totalRemoveCnt+=removeCnt;
+
+			//3) 지워진 곳 채우기
+			fall(m,n);
+		}
+
+		return totalRemoveCnt;
+	}
+
+	private static void fall(int m, int n) {
+		for (int c = 0; c < n; c++) {
+			int writeRow = m-1;
+			for (int r=m-1;r>=0;r--){
+				if (block[r][c]!=' '){
+					block[writeRow][c] = block[r][c];
+					writeRow--;
+				}
+			}
+			for (int r = writeRow;r>=0;r--){
+				block[r][c] = ' ';
+			}
+		}
+	}
+
+	private static int erase(int m, int n){
+		int removeCnt =0;
+		for (int r=0;r<m;r++){
+			for (int c=0;c<n;c++){
+				if (marked[r][c]) {
+					block[r][c] = ' ';
+					removeCnt++;
+				}
+			}
+		}
+		return removeCnt;
+	}
+
+	private static void mark(int m, int n){ //2x2 체크
+		marked = new boolean[m][n];
+
+		for (int r=0;r<m-1;r++){
+			for (int c=0;c<n-1;c++){
+				char key = block[r][c];
+				if (key==' ') continue;
+				if (block[r+1][c]!=key||block[r][c+1]!=key||block[r+1][c+1]!=key) continue;
+				marked[r][c] = true; marked[r+1][c] = true; marked[r][c+1] = true; marked[r+1][c+1] = true;
+			}
+		}
+	}
+
+	private static void initBlock(String[] board,int m, int n){
+		for (int r=0;r<m;r++){
+			block[r] = board[r].toCharArray();
+		}
+	}
+}

src/main/java/week11/gahyun/p2/Solution.java

@@ -0,0 +1,37 @@
+package week11.gahyun.p2;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 처음에는 truck클래스를 추가해서 time을 계속 차감해야 하나 고민함
+ * 큐를 만들고, 트럭을 추가할 수 없을 때는 0을 추가해서 관리하면 됐던 문제
+ */
+class Solution {
+	public int solution(int bridge_length, int weight, int[] truck_weights) {
+		//다리 초기화
+		Queue<Integer> bridge = new LinkedList<>();
+		for (int i=0;i<bridge_length;i++){
+			bridge.offer(0);
+		}
+
+		int ind = 0; //넣을 트럭
+		int time = 0; //경과 시간
+		int load_w = 0; // 다리 위 무게
+
+		// 다 건너지 않았거나, 다리 위에 트럭 있을 때까지 반복
+		while (ind<truck_weights.length||load_w>0){
+			time++;
+			load_w-=bridge.poll(); // 트럭 건넘 -> 무게 차감
+
+			if (ind<truck_weights.length&&truck_weights[ind]<=weight-load_w){//현재 트럭 건널 수 있음
+				bridge.offer(truck_weights[ind]);
+				load_w+=truck_weights[ind++]; //트럭 올리기 -> 무게 증가
+			}
+			else bridge.offer(0); //현재 트럭 건널 수 없음
+		}
+
+		return time;
+	}
+}
+

src/main/java/week11/gahyun/p3/Solution.java

@@ -0,0 +1,32 @@
+package week11.gahyun.p3;
+
+import java.util.*;
+
+/**
+ * 접근 방식
+ * - 처음에는 Queue로 풀었는데 split하는게 더 효율적
+ * - 0+는 0이 한개 이상인 것
+ * - n을 k진수로 변환: Intereger.toString(n,k)
+ */
+class Solution {
+	public int solution(int n, int k) {
+		int cnt = 0;
+
+		String numK = Integer.toString(n,k);
+		String[] subset = numK.split("0+");
+		for (String num : subset){
+			if (num.equals("")) continue;
+			if (isPrime(Long.parseLong(num))) cnt++;
+		}
+
+		return cnt;
+	}
+
+	private static boolean isPrime(long num){ //소수여부 판별
+		if (num<2) return false;
+		for (long i=2;i*i<=num;i++){
+			if (num%i==0) return false;
+		}
+		return true;
+	}
+}

src/main/java/week11/gahyun/p4/Solution.java

@@ -0,0 +1,34 @@
+package week11.gahyun.p4;
+
+import java.util.Stack;
+
+class Solution {
+	public int solution(int[] order) {
+		//박스 초기화
+		int[] boxes = new int[order.length];
+		Stack<Integer> stk = new Stack<>();
+		int boxInd = 0,cnt = 0;
+
+		for (int i=0;i<order.length;i++)
+			boxes[i] = i+1;
+
+
+		for (int orderInd=0;orderInd<order.length;orderInd++){
+			int target = order[orderInd];
+			if (!stk.isEmpty()&&stk.peek()==target){ //타깃이 스택 상단에 있을 경우
+				stk.pop(); cnt++;
+				continue;
+			}
+			while (boxInd<order.length&&boxes[boxInd]!=target){//타깃을 찾을 때까지 스택에 삽입
+				stk.push(boxes[boxInd]);
+				boxInd++;
+			}
+			if (boxInd<order.length&&boxes[boxInd]==target){
+				cnt++; boxInd++;
+			}
+			else break;
+		}
+
+		return cnt;
+	}
+}

src/main/java/week11/gahyun/p5/Solution.java

@@ -0,0 +1,83 @@
+package week11.gahyun.p5;
+
+import java.util.*;
+
+/**
+ * 차 객체 생성해서 시간 관리
+ * map : 차번호-차 객체
+ * 차번호로 정렬 -> TreeMap
+ */
+class Solution {
+	public int[] solution(int[] fees, String[] records) {
+
+		Map<String, Car> map = new TreeMap<>(); //차번호, 차
+		for (String record: records){
+			String[] data = record.split(" ");
+
+			String[] time = data[0].split(":");
+			int hour = Integer.valueOf(time[0]);
+			int min = Integer.valueOf(time[1]);
+
+			String carNum = data[1];
+			String cmd = data[2];
+			if (!map.containsKey(carNum)){
+				map.put(carNum,new Car());
+			}
+
+			Car car = map.get(carNum);
+			if (cmd.equals("IN")){
+				car.entry(hour,min);
+			}
+			else {
+				car.out(hour,min);
+			}
+
+		}
+
+		int[] answer = new int[map.size()];
+		int idx = 0;
+		for (Car car:map.values()){
+			answer[idx++] = calculateFee(fees, car);
+		}
+
+		return answer;
+	}
+
+	private int calculateFee(int[] fees, Car car){
+		int defaultMin = fees[0];
+		int defaultFee = fees[1];
+		int overMin = fees[2];
+		int overFee = fees[3];
+
+		int totalTime = car.getTotalTime();
+
+		if (totalTime<=defaultMin) return defaultFee;
+		else
+			return defaultFee+(int)Math.ceil((totalTime-defaultMin)*1.0/overMin)*overFee;
+	}
+}
+
+class Car {
+	boolean isEntry; //입차 여부
+	int entryHour; //입차 시간
+	int entryMin; //입차 분
+	int totalTime = 0;
+
+	public void entry(int entryHour, int entryMin){//입차
+		this.entryHour = entryHour;
+		this.entryMin = entryMin;
+		isEntry = true;
+	}
+
+	public void out(int outHour, int outMin){ //출차
+		totalTime+= (outHour-entryHour)*60+(outMin-entryMin); //주차 시간 누적
+		isEntry = false;
+	}
+
+	public int getTotalTime(){ //누적시간 반환
+		if (isEntry){//아직 출차 안함
+			totalTime+= (23-entryHour)*60+(59-entryMin);
+		}
+		return totalTime;
+	}
+}

src/main/java/week11/gahyun/p6/Solution.java

@@ -0,0 +1,49 @@
+package week11.gahyun.p6;
+
+import java.util.*;
+
+/**문제 요약
+ * 	- 알파벳으로 단어 초기화
+ * 	- 단어 일정 부분 자르기
+ *     - 해당 단어 있으면 한 글자 더해서 새로운 단어 만듦
+ * 	- 기존 단어의 사전 번호 출력
+ * 	- 새로운 단어 사전에 저장
+ * 헷갈린 점
+ * - w+=c를 하는 게 아니라 nextIdx계속 더해서 substring하기
+ */
+class Solution {
+	public int[] solution(String msg) {
+		Map<String, Integer> dict = new HashMap<>();
+		List<Integer> output = new ArrayList<>();
+		initDict(dict);
+		int curIdx = 0, dictIdx=27;
+
+		while (curIdx<msg.length()){
+			int nextIdx = curIdx+1;
+			String w = ""+msg.charAt(curIdx);
+			while (nextIdx<=msg.length()&&dict.containsKey(msg.substring(curIdx,nextIdx))){
+				w = msg.substring(curIdx,nextIdx);
+				nextIdx++;
+			}
+			output.add(dict.get(w)); // 기존 단어 찾기
+
+			if (nextIdx<=msg.length())
+				dict.put(msg.substring(curIdx,nextIdx),dictIdx++); //새로운 단어 추가
+			curIdx += w.length();
+		}
+
+		int[] answer = new int[output.size()];
+		for (int i=0;i<output.size();i++){
+			answer[i] = output.get(i);
+		}
+
+		return answer;
+	}
+
+	private static void initDict(Map<String, Integer> dict){
+		int dictIdx = 1;
+		for (char c = 'A';c<='Z';c++){
+			dict.put(c+"",dictIdx++);
+		}
+	}
+}

src/main/java/week11/gahyun/p7/Solution.java

@@ -0,0 +1,38 @@
+package week11.gahyun.p7;
+
+import java.util.*;
+
+/**
+ * 접근 방법: 각 분을 인덱스화하여 카운트
+ */
+class Solution {
+	static int maxCnt = 0;
+	public int solution(String[][] book_time) {
+		int limit = 23*60+59;
+		int[] cnt = new int[limit+1]; //00:00~23:59 점유 객실 수
+
+		for (int i=0;i<book_time.length;i++){
+			String startTime = book_time[i][0];
+			String endTime = book_time[i][1];
+
+			int startH = Integer.valueOf(startTime.split(":")[0]);
+			int startM = Integer.valueOf(startTime.split(":")[1]);
+			int endH = Integer.valueOf(endTime.split(":")[0]);
+			int endM = Integer.valueOf(endTime.split(":")[1]);
+
+			int startIdx = startH*60+startM;
+			int endIdx = endH*60+endM+9;
+			if (endIdx>limit) endIdx = limit;
+			occupy(startIdx, endIdx,cnt);
+		}
+
+		return maxCnt;
+	}
+
+	private static void occupy(int startIdx, int endIdx, int[] cnt){
+		for (int i=startIdx;i<=endIdx;i++){
+			cnt[i]++;
+			maxCnt = Math.max(cnt[i],maxCnt);
+		}
+	}
+}