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

public class Solution {
	
	// 주차 요금 계산
	
	public static int calcMin(String time1, String time2) {
		String[] time1Arr = time1.split(":");
		String[] time2Arr = time2.split(":");
		
		int min = (Integer.parseInt(time2Arr[0]) * 60 + Integer.parseInt(time2Arr[1])) - (Integer.parseInt(time1Arr[0]) * 60 + Integer.parseInt(time1Arr[1]));
		
		return min;
	}
	
	public static int[] solution(int[] fees, String[] records) {
		int[] answer = {};
		String[] tempArr = new String[3];
        
		// 차량 번호로 기록 구분 필요
		// 0000 : 06:00 IN, 06:34 OUT, 18:59 IN, 23:59 OUT // 34 + 300
		// 0148 : 07:59 IN, 19:09 OUT // 670
		// 5961 : 05:34 IN, 07:59 OUT, 22:59 IN, 23:00 OUT // 145 + 1
		// IN과 OUT은 담을 필요없다. 기록이 짝수 개 존재하는 것이 중요하며, 이 문제에서는 무조건 IN, OUT, IN, OUT 순서이다.
        
		HashMap<String, ArrayList<String>> hmlist = new HashMap<>();
		ArrayList<String> numberList = new ArrayList<>();
        
		for (int i = 0; i < records.length; i++) {
			tempArr = records[i].split(" "); // "06:00", "0000", "IN"
        	
			if (!hmlist.containsKey(tempArr[1])) { // "0000"
				hmlist.put(tempArr[1], new ArrayList<String>()); // key 등록 // "0000"
        		
				numberList.add(tempArr[1]); // key값만 담아둘 리스트 // "0000"
			}
        	
			hmlist.get(tempArr[1]).add(tempArr[0]); // "06:00"
		}
        
        // numberList에 현재 넘버 리스트 담겨있음
        
        Collections.sort(numberList); // key값 리스트 오름차순 정렬
        
        for (String str : numberList) { // 0000, 0148, 5961
        	
        	System.out.println(str);
        	
        	if (hmlist.get(str).size() % 2 == 1) { // 짝이 안맞는다면, 즉 마지막 출차 기록이 없다면
        		hmlist.get(str).add("23:59"); // 마지막 출차 기록은 23:59로
        	}
        }
        
        int[] totalTimeArr = {}; // 차량 번호별 총 시간 담기 위한 배열
        
        totalTimeArr = new int[numberList.size()]; // 시간 담을 배열 크기는 차량 번호 수만큼
        answer = new int[numberList.size()]; // 금액 담을 배열 크기는 차량 번호 수만큼
        
        String[] tempTimeArr = new String[2]; // 시간 두 개씩 잘라서 분으로 바꾸기 위한 임시 배열
        
        int j = 0; // 차량 번호 수만큼 증가시킬 변수
        
        for (String str : numberList) {
        	
        	int i = 0; // 시간 두 개를 담기 위한 인덱스 i
        	int timeSum = 0;
        	
        	for (String time : hmlist.get(str)) {
        		tempTimeArr[i] = time; // 0, 1
        		i++;
        		
        		if (i == 2) { // 0, 1을 넘어가면
        			timeSum += calcMin(tempTimeArr[0], tempTimeArr[1]); // 분 계산 함수
        			i = 0; // 시간 두 개씩 끊기 위해 0으로 초기화
        		}
        	}
        	
        	totalTimeArr[j] = timeSum; // 해당 차량 번호의 총 시간
        	j++; // 0 ~ 2
        }
        
        double d = 0;
        
        for (int i = 0; i < totalTimeArr.length; i++) {
        	
        	if (totalTimeArr[i] <= fees[0]) { // 180분을 넘지 않았다면
        		answer[i] = fees[1]; // 5000원
        	} else { // 180분을 초과했다면
        		d = (double)(totalTimeArr[i] - fees[0]) / fees[2]; // 소수점 올림을 위해 double형으로 받기
        		answer[i] = (int)Math.ceil(d) * fees[3] + fees[1]; // 초과한 금액 + 5000원
        	}
        }
        
        for (int i = 0; i <answer.length; i++) {
        	System.out.println(answer[i]);
        }
        
        return answer;
    }

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] fees = {180, 5000, 10, 600}; // 기본시간(분), 기본요금(원), 단위시간(분), 단위요금(원)
		String[] 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"}; // 시:분 차 번호 IN/OUT // 마지막 나간 기록 없으면 23:59 나간 것으로 간주
		
		System.out.println(solution(fees, records)); // 14600, 34400, 5000
	}
}

프로그래머스 주차 요금 계산 문제 풀이 Java

첫 시도에서 런타임 에러가 발생해 다른 방법으로 풀이하였다.

import java.util.HashSet;

public class Solution {
	
	// 등대
	
	public static int solution(int n, int[][] lighthouse) {
		int answer = 0;
		int[] linkedCntArr; // 각 등대에 연결된 등대의 수를 입력받기 위한 배열
		
		HashSet<Integer> edgeHs = new HashSet<>(); // 가장자리(둘레나 끝에 해당되는 부분)에 위치한 등대의 번호를 담을 HashSet
		HashSet<Integer> turnOnHs = new HashSet<>(); // 가장자리(둘레나 끝에 해당되는 부분)에 위치한 등대와 연결된, 반드시 켜야 하는 등대의 번호를 담을 HashSet
		int[][] remainingLightHouse; // 반드시 켜야 하는 등대를 킨 후 남은 등대 쌍을 담을 2차원 배열
		int remainingCnt; // remainingLightHouse에 담긴 등대 쌍의 수
		
		// CASE 1을 기준으로 설명
		
		for (int a = 0; a < n; a++) { // 과정 반복
			
			// 현재 turnOnHs가 비어있지 않은 상황이라면, turnOnHs에 담긴 번호의 등대를 킨 상황으로, 켜진 등대의 영향을 받는 등대는 고려해야 할 대상에서 제외한다.(lighthouse의 길이가 줄었을 것)
			
			linkedCntArr = new int[n + 1]; // linkedCntArr 초기화 // 0 ~ n
			remainingLightHouse = new int[lighthouse.length][2]; // remainingLightHouse 초기화
			remainingCnt = 0; // remainingCnt 초기화
			
			for (int i = 0; i < lighthouse.length; i++) {
				linkedCntArr[lighthouse[i][0]]++;
				linkedCntArr[lighthouse[i][1]]++;
			}
			
			// linkedCntArr : {0, 4, 2, 1, 1, 3, 3, 1, 1, 2, 2, 1, 3, 1, 1}
			
			for (int i = 0; i < linkedCntArr.length; i++) {
				
				if (linkedCntArr[i] == 1) { // 연결된 등대가 하나뿐이라면 가장자리(둘레나 끝에 해당되는 부분)에 위치한 등대
					edgeHs.add(i); // edgeHs에 등대 번호 담기
				}
			}
			
			// edgeHs : [3, 4, 7, 8, 11, 13, 14]
			
			for (int i = 0; i < lighthouse.length; i++) {
				
				// 가장자리(둘레나 끝에 해당되는 부분)에 위치한 등대와 연결된 등대 번호를 turnOnHs에 담기 // 반드시 켜야 하는 등대 번호
				
				if (edgeHs.contains(lighthouse[i][0]) || edgeHs.contains(lighthouse[i][1])) {
					
					if (edgeHs.contains(lighthouse[i][0])) {
						turnOnHs.add(lighthouse[i][1]);
					} else {
						turnOnHs.add(lighthouse[i][0]);
					}
				}
			}
			
			// turnOnHs : [1, 6, 10, 12]
			
			for (int i = 0; i < lighthouse.length; i++) {
				
				// turnOnHs에 담긴 켜진 등대의 영향으로 밝힐 수 없는 등대 쌍이 있는지 확인
				
				if (!turnOnHs.contains(lighthouse[i][0]) && !turnOnHs.contains(lighthouse[i][1])) {
					remainingLightHouse[remainingCnt] = lighthouse[i];
					remainingCnt++;
				}
			}
			
			// remainingLightHouse : {{2, 9}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}
			// remainingCnt == 1
			
			if (remainingCnt == 0) { // 현재 켜진 등대로 모든 등대를 밝힐 수 있다면
				break;
			}
			
			if (remainingCnt == 1) { // 현재 켜진 등대의 영향으로 밝힐 수 없는 등대 쌍이 1쌍 존재한다면
				answer += 1; // 남은 1쌍의 등대 중 어떤 등대를 켜도 되기 때문에 1만 증가
				break;
			}
			
			if (remainingCnt < lighthouse.length) { // 현재 켜진 등대의 영향으로 밝힐 수 없는 등대 쌍의 수가 2 이상 lighthouse.length 미만이라면
				lighthouse = new int[remainingCnt][2]; // lighthouse의 길이 줄이기
				
				for (int i = 0; i < remainingCnt; i++) { // 현재 켜진 등대의 영향으로 밝힐 수 없는 등대 쌍만 고려하면 된다.
					lighthouse[i] = remainingLightHouse[i];
				}
			}
			
			// 다시 for문으로 가 과정 반복
		}
		
		answer += turnOnHs.size(); // 켜진 등대의 수를 더해준다.
		
		return answer;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// CASE 1
		int n = 14;
		int[][] lighthouse = {{4, 1}, {5, 1}, {5, 6}, {7, 6}, {1, 2}, {1, 3}, {6, 8}, {2, 9}, {9, 10}, {10, 11}, {5, 12}, {12, 13}, {12, 14}};
		// CASE 2
//		int n = 10;
//		int[][] lighthouse = {{4, 1}, {5, 1}, {5, 6}, {7, 6}, {1, 2}, {1, 3}, {6, 8}, {2, 9}, {9, 10}};
		// CASE 3
//		int n = 8;
//		int[][] lighthouse = {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {5, 6}, {5, 7}, {5, 8}};
		
		System.out.println(solution(n, lighthouse));
	}
}

 

 

2022.11.17 기준 정답률이 6%밖에 안되는 문제이기 때문일까? 점수를 13점이나 준다.

 

 

내가 풀이한 방법은 이렇다.

STEP 1. 반드시 켜야 하는 등대의 기준

가장자리(둘레나 끝에 해당되는 부분)에 위치한 등대와 연결된 등대는 반드시 켜야 한다.

가장자리(둘레나 끝에 해당되는 부분)에 위치한 등대는 lighthouse 배열의 원소들 중 하나만 존재하는 번호에 해당하며,

그 번호와 쌍을 이루는 번호는 반드시 켜야 하는 등대의 번호를 의미한다.

STEP 2. 반드시 켜야 하는 등대의 번호를 HashSet에 담고, lighthouse 배열의 원소들 중 HashSet에 존재하는 번호가

있을 경우, 그 번호를 포함한 등대 쌍(배열)을 제거한다. => 현재 켜진 등대로 밝힐 수 없는 등대 쌍만 남게 된다.

STEP 3. STEP 2에서 남은 등대 쌍으로 lighthouse 배열을 다시 만든다.

STEP 4. STEP 1부터 과정을 반복한다.

 

프로그래머스 등대 문제 풀이 Java

[Java] PCCP 모의고사 1회 외톨이 알파벳 : https://dev-skill.tistory.com/15

 

[Java] PCCP 모의고사 1회 외톨이 알파벳

import java.util.*; public class PccpTest1_1 { // PCCP 모의고사 1회 1번 외톨이 알파벳 public static String solution(String input_string) { String answer = ""; char tempChar; int tempCnt = 0; int repeatCnt = 0; Queue q = new LinkedList(); HashMa

dev-skill.tistory.com

[Java] PCCP 모의고사 1회 체육대회 : https://dev-skill.tistory.com/16

 

[Java] PCCP 모의고사 1회 체육대회

public class PccpTest1_2 { // PCCP 모의고사 1회 2번 체육대회 static int answer = 0; // 최대값 담을 answer 변수 static boolean[] selectStudentNumArr; // 대표로 뽑힌 학생인지 확인을 위한 boolean 배열 static int studentCnt = 0

dev-skill.tistory.com

[Java] PCCP 모의고사 1회 유전법칙 : https://dev-skill.tistory.com/17

 

[Java] PCCP 모의고사 1회 유전법칙

public class PccpTest1_3 { // PCCP 모의고사 1회 3번 유전법칙 public static String solve(int generation, long number) { long upperCaseLastNum = 0; long centerGroupLastNum = 0; String strRoot = "Rr"; long tempNum = 0; if (generation == 1) { return

dev-skill.tistory.com

[Java] PCCP 모의고사 1회 운영체제 : https://dev-skill.tistory.com/18

 

[Java] PCCP 모의고사 1회 운영체제

import java.util.PriorityQueue; public class PccpTest1_4 { // PCCP 모의고사 1회 4번 운영체제 public static long[] solution(int[][] program) { long[] answer = {}; long callTime = 0; // OS 호출 시각 int runningTime = 0; // OS 수행 시간 long

dev-skill.tistory.com

프로그래머스 PCCP 모의고사 문제 풀이 Java

import java.util.PriorityQueue;

public class PccpTest1_4 {
	
	// PCCP 모의고사 1회 4번 운영체제
	
	public static long[] solution(int[][] program) {
		long[] answer = {};
		long callTime = 0; // OS 호출 시각
		int runningTime = 0; // OS 수행 시간
		long totalRunningTime = 0; // 전체 OS 종료까지 총 소요 시간
		long blankTime = 0; // OS가 실행중이지 않은 시간
		
		answer = new long[11]; // 크기 11 고정
		
		// STEP 1. ORDER BY 호출 시각, 점수인 우선순위 큐 만들기(전체 OS 담을 우선순위 큐)
		PriorityQueue<Os> osQ = new PriorityQueue<>();
		
		// STEP 2. 1번 우선순위 큐에 program 배열의 OS 담기
		for (int i = 0; i < program.length; i++) {
			osQ.add(new Os(program[i][0], program[i][1], program[i][2]));
		}
		
		// STEP 3. ORDER BY 점수, 호출 시각인 우선순위 큐 만들기(호출 시각 지난 OS 담을 우선순위 큐) => 호출 시각이 지난 OS들은 점수가 낮은 순서대로 실행된다.
		PriorityQueue<WaitingOs> waitingOsQ = new PriorityQueue<>();
		
		// STEP 4. 시간 계산에 사용될 임시 Os, WaitingOs 변수 선언
		Os tempOs = null;
		WaitingOs tempWaitingOs = null;
		
		// STEP 5. 제일 처음 실행될 OS 꺼내기
		Os os = osQ.poll();
		
		callTime = os.getCallTime();
		runningTime = os.getRunningTime();
		
		blankTime = callTime; // 0초에 바로 실행되지 않는 경우도 있을 수 있기 때문에 blankTime 계산해주기
		
		totalRunningTime += blankTime; // 총 소요 시간에 blankTime 더하기
		totalRunningTime += runningTime; // 총 소요 시간에 수행 시간 더하기
		
		// STEP 6. 두 개의 큐가 모두 비워질 때까지 반복
		while (!osQ.isEmpty() || !waitingOsQ.isEmpty()) { // 두 개의 큐 중 어느 하나라도 OS가 담겨있다면 반복
			
			// osQ에 OS가 담겨있다면
			if (!osQ.isEmpty()) {
				
				// 실행 중인 OS로 인해 호출 시각이 지난 OS가 있다면 waitingOsQ(호출 시각이 지난 OS들만 모여있으며, 이 경우 점수가 낮은 OS가 우선적으로 실행될 수 있게 배치)로 보내기
				if (totalRunningTime >= osQ.peek().getCallTime()) {
					tempOs = osQ.poll();
					waitingOsQ.offer(new WaitingOs(tempOs.getGrade(), tempOs.getCallTime(), tempOs.getRunningTime()));
					continue; // 더 있다면 반복 수행되도록 처리
				}
				
				// 이 곳으로 내려왔다는 것은 osQ에 OS가 남아 있으며, waitingOsQ로 보낼 조건에 부합하는 OS가 없다는 것을 의미
				// 여기서 waitingOsQ가 비어있다면 => 즉, 다음 실행될 osQ의 OS가 바로 이어서 실행되지 않기 때문에 waitingOsQ에 보내지 못한 거라면
				if (waitingOsQ.isEmpty()) {
					// blankTime과 runningTime 계산
					tempOs = osQ.poll();
					
					blankTime = (tempOs.getCallTime() - totalRunningTime); // blankTime이 있다는 것을 의미하므로 blankTime 계산해주기
					
					totalRunningTime += (blankTime + tempOs.getRunningTime()); // 총 소요 시간에 blankTime과 수행 시간 더하기
				}
			}
			
			// waitingOsQ에 OS가 담겨있다면
			if (!waitingOsQ.isEmpty()) {
				tempWaitingOs = waitingOsQ.poll();
				
				answer[tempWaitingOs.getGrade()] += (totalRunningTime - tempWaitingOs.getCallTime()); // 해당 점수의 대기 시간 더하기
				
				totalRunningTime += tempWaitingOs.getRunningTime(); // 총 소요 시간에 해당 점수의 수행 시간 더하기
			}
		}
		
		answer[0] = totalRunningTime; // answer[0]에는 총 소요 시간을 넣어준다.
		
		for (int i = 0; i < answer.length; i++) {
			System.out.print(answer[i] + " ");
		}
		
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][] program = {{2, 0, 10}, {1, 5, 5}, {3, 5, 3}, {3, 12, 2}}; // 점수, 호출 시각, 수행 시간 // 20, 5, 0, 16, 0, 0, 0, 0, 0, 0, 0 // 종료 시각, 점수 1 ~ 10 총 대기 시간
//		int[][] program = {{3, 6, 4}, {4, 2, 5}, {1, 0, 5}, {5, 0, 5}}; // 19 0 0 4 3 14 0 0 0 0 0
//		int[][] program = {{3, 6, 4}, {4, 2, 5}, {1, 0, 5}, {4, 1, 10}, {5, 0, 5}, {2, 0, 8}}; // 37 0 5 7 41 32 0 0 0 0 0
		
		System.out.println(solution(program));
	}
}
public class Os implements Comparable<Os> { // 호출 시각, 점수 기준
	
	private int grade = 0; // 점수
	private long callTime = 0; // 호출 시각
	private int runningTime = 0; // 수행 시간
	
	public Os(int grade, long callTime, int runningTime) {
		this.grade = grade;
		this.callTime = callTime;
		this.runningTime = runningTime;
	}
	
	public int getGrade() {
		return this.grade;
	}
	
	public long getCallTime() {
		return this.callTime;
	}
	
	public int getRunningTime() {
		return this.runningTime;
	}

	@Override
	public int compareTo(Os otherNode) { // ORDER BY callTime, grade
		// TODO Auto-generated method stub
		if (this.callTime == otherNode.callTime) { // callTime이 같을 경우
			
			if (this.grade - otherNode.grade >= 0) { // grade 기준 오름차순 정렬
				return 1;
			} else {
				return -1;
			}
		} else { // callTime이 같지 않을 경우
			
			if (this.callTime - otherNode.callTime >= 0) { // callTime 기준 오름차순 정렬
				return 1;
			} else {
				return -1;
			}
		}
	}
}
public class WaitingOs implements Comparable<WaitingOs> { // 점수, 호출 시각 기준
	
	private int grade = 0; // 점수
	private long callTime = 0; // 호출 시각
	private int runningTime = 0; // 수행 시간
	
	public WaitingOs(int grade, long callTime, int runningTime) {
		this.grade = grade;
		this.callTime = callTime;
		this.runningTime = runningTime;
	}
	
	public int getGrade() {
		return this.grade;
	}
	
	public long getCallTime() {
		return this.callTime;
	}
	
	public int getRunningTime() {
		return this.runningTime;
	}

	@Override
	public int compareTo(WaitingOs otherNode) { // ORDER BY grade, callTime
		// TODO Auto-generated method stub
		if (this.grade == otherNode.grade) { // grade가 같을 경우
			
			if (this.callTime - otherNode.callTime >= 0) { // callTime 기준 오름차순 정렬
				return 1;
			} else {
				return -1;
			}
		} else { // grade가 같지 않을 경우
			
			if (this.grade - otherNode.grade >= 0) { // grade 기준 오름차순 정렬
				return 1;
			} else {
				return -1;
			}
		}
	}
}

 

제출 후 채점하기에서 실패로 뜨는 테스트 케이스들이 많았고, solution 메소드에 문제가 있는 것인지 여러 차례 확인했다.

결론은 solution 메소드에는 문제가 없었고 WaitingOs의 정렬 기준을 '점수'로만 했던 것이 원인이었다.

호출 시각이 지난 OS들은 '점수'가 낮은 순서대로 실행되는 것이 맞지만, '호출 시각' 또한 고려해야 했다는 것을 뒤늦게

깨닫고 WaitingOs의 정렬 기준을 '점수', '호출 시각'으로 변경하여 문제를 해결하였다.

 

프로그래머스 PCCP 모의고사 문제 풀이 Java

public class PccpTest1_3 {
	
	// PCCP 모의고사 1회 3번 유전법칙
	
	public static String solve(int generation, long number) {
		long upperCaseLastNum = 0;
		long centerGroupLastNum = 0;
		String strRoot = "Rr";
		long tempNum = 0;
		
		if (generation == 1) {
			return strRoot;
		}
		
		upperCaseLastNum = (long) Math.pow(4, generation - 2);
		centerGroupLastNum = upperCaseLastNum + (2 * upperCaseLastNum);
		
		if (number <= upperCaseLastNum) {
			return "RR";
		} else if (upperCaseLastNum < number && number <= centerGroupLastNum) {
			tempNum = number % ((centerGroupLastNum - upperCaseLastNum) / 2) == 0 ?
			(centerGroupLastNum - upperCaseLastNum) / 2 : number % ((centerGroupLastNum - upperCaseLastNum) / 2);
			return solve(generation - 1, tempNum);
		} else { // centerGroupLastNum < number
			return "rr";
		}
	}
	
	public static String[] solution(int[][] queries) {
		String[] answer = {};
		int generation = 0;
		long number = 0;
		
		answer = new String[queries.length];
		
		for (int i = 0; i < queries.length; i++) {
			generation = queries[i][0];
			number = queries[i][1];
			
			answer[i] = solve(generation, number);
		}
		
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][] queries = {{3, 1}, {2, 3}, {3, 9}}; // RR, Rr, RR
		
		System.out.println(solution(queries));
	}
}

 

그림으로 패턴 확인

 

 

위 규칙을 이용해 내가 알고자 하는 형질의 세대와 번호를 전 세대로 가져가며 범위를 줄여가는 방식을 사용했다.

즉, 내가 알고자 하는 형질이 3세대의 10번째 번호라면

A. 3세대의 대문자 그룹 마지막 번호는 4, 3세대의 2세대 2개의 그룹 마지막 번호는 12

=> 10번은 2세대 그룹 범위에 속한다는 것

B. 2세대 2개의 그룹은 총 12 - 4 = 8개로 구성되며, 2로 나눈 4의 값을 이용한다. (2개의 중복되는 그룹이므로)

C. 10 % 4의 값이 2이므로, 3세대의 10번째 번호 형질은 2세대의 2번째 번호 형질과 같다는 것을 의미한다.

주의해야 할 점은 4로 나눴을 경우 1, 2, 3, 4가 나오도록 10 % 4의 값이 0일 경우 4를 넣어줘야 한다는 점이다.

아래 코드에서 밑줄 친 부분이 이에 해당한다.

 

 

다음 코드는 parent를 자가 수분했을 때 다음 세대 형질을 출력하는 코드이다.

 

public static void selfPollination(String parent) { // parent를 자가 수분했을 때 다음 세대 형질 출력해보기
	char leftChar = parent.charAt(0);
	char rightChar = parent.charAt(1);
		
	Queue<Character> leftQ = new LinkedList<>();
	Queue<Character> rightQ = new LinkedList<>();
		
	rightQ.offer(leftChar);
		
	for (int i = 0; i < 3; i++) {
		leftQ.offer(leftChar);
		rightQ.offer(rightChar);
	}
		
	leftQ.offer(rightChar);
		
	for (int i = 0; i < 4; i++) {
		System.out.print(leftQ.poll().toString() + rightQ.poll().toString() + " ");
	}
}

 

parent가 "Rr"일 경우 => "RR", "Rr", "Rr", "rr" 출력

 

프로그래머스 PCCP 모의고사 문제 풀이 Java

public class PccpTest1_2 {
	
	// PCCP 모의고사 1회 2번 체육대회
	
	static int answer = 0; // 최대값 담을 answer 변수
	static boolean[] selectStudentNumArr; // 대표로 뽑힌 학생인지 확인을 위한 boolean 배열
	static int studentCnt = 0; // 총 학생 수
	static int sportsCnt = 0; // 총 종목 수
	
	public static void dfs(int depth, int sum, int[][] ability) { // 종목 index, 합계 점수, 학생별 능력치가 담긴 배열
		
		if (depth == sportsCnt) { // 세 번째 종목 점수까지 합산된 후라면
			answer = Math.max(answer, sum); // 세 번째 종목 점수까지 합산된 결과 중 최대값을 answer 변수에 넣기
		} else { // depth가 0, 1, 2인 경우
			
			for (int i = 0; i < studentCnt; i++) { // 0 ~ 4
				
				if (selectStudentNumArr[i] == false) { // 아직 선택되지 않은 학생이라면
					selectStudentNumArr[i] = true; // 해당 학생 선택
					dfs(depth + 1, sum + ability[i][depth], ability); // 해당 학생의 종목 중 index가 depth인 종목의 점수를 합계에 더하고, 다음 종목 확인을 위해 dfs
					selectStudentNumArr[i] = false; // dfs 빠져나온 이후 해당 학생은 다시 선택 전 상태로
				}
			}
		}
	}
	
	public static int solution(int[][] ability) {
		selectStudentNumArr = new boolean[ability.length]; // {false, false, false, false, false}
		studentCnt = ability.length; // 5
		sportsCnt = ability[0].length; // 3
		
		dfs(0, 0, ability); // 종목 index 0, 합계 점수 0, 학생별 능력치가 담긴 배열
		
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][] ability = {{40, 10, 10}, {20, 5, 0}, {30, 30, 30}, {70, 0, 70}, {100, 100, 100}}; // 5명의 학생, 3개의 종목
		
		System.out.println(solution(ability)); // 40(0, 0) + 100(4, 1) + 70(3, 2) // 210
	}
}

프로그래머스 PCCP 모의고사 문제 풀이 Java

import java.util.*;

public class PccpTest1_1 {
	
	// PCCP 모의고사 1회 1번 외톨이 알파벳
    
	public static String solution(String input_string) {
		String answer = "";
		char tempChar;
		int tempCnt = 0;
		int repeatCnt = 0;
        
		Queue<Character> q = new LinkedList<>();
		HashMap<Character, Integer> originHm = new HashMap<>();
		HashMap<Character, Integer> repeatChkHm = new HashMap<>();
		ArrayList<Character> list = new ArrayList<>();
        
		for (int i = 0; i < input_string.length(); i++) {
			q.offer(input_string.charAt(i)); // e d e a a a b b c c d
		}
        
		while (!q.isEmpty()) {
        	
			tempChar = q.poll();
        	
			if (originHm.get(tempChar) == null) { // originHm에는 key값으로 알파벳이, value값으로 해당 알파벳의 총 카운트가 들어갈 것이다.
				originHm.put(tempChar, 1);
				repeatChkHm.put(tempChar, 1);
			} else {
				tempCnt = originHm.get(tempChar) + 1;
				originHm.put(tempChar, tempCnt);
			}
        	
			if (!q.isEmpty()) { // AABBAA일 경우 // originHm A : 4, B : 2 // repeatChkHm A : 3, B : 2
        		
				if (tempChar == q.peek()) { // 연속되는 알파벳이라면
					repeatCnt = repeatChkHm.get(tempChar) + 1;
					repeatChkHm.put(tempChar, repeatCnt);
				}
			}
		}
        
		for (char key : originHm.keySet()) {
        	
			if (originHm.get(key) != repeatChkHm.get(key) && originHm.get(key) > 1) {
				list.add(key);
			}
		}
        
		if (list.size() == 0) {
			answer = "N";
		} else {
			Collections.sort(list);
        	
			StringBuilder sb = new StringBuilder();
             
			for (int i = 0; i < list.size(); i++) {
				sb.append(list.get(i));
			}
             
			answer = sb.toString();
		}
        
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String input_string = "edeaaabbccd";
		
		System.out.println(solution(input_string));
	}
}

프로그래머스 PCCP 모의고사 문제 풀이 Java

public class Solution {
	
    // 땅따먹기
	
    public static int solution(int[][] land) {
        int answer = 0;
        int[][] sumArr = new int[land.length][land[0].length];
        
        sumArr = land;

        for (int i = 1; i < land.length; i++) { // 행
        	
        	for (int j = 0; j < 4; j++) { // 열
        		
        		int max = sumArr[i][j]; // 비교 대상 행의 열 값을 max로 지정
        		
        		for (int z = 0; z < 4; z++) { // 비교 열
        			
        			if (j == z) { // 같은 행에선 비교x
        				continue;
        			}
        			
        			if (max < sumArr[i - 1][z] + land[i][j]) {
        				max = sumArr[i - 1][z] + land[i][j]; // 더 큰 값이 존재한다면 max값 변경
        			}
        		}
        		
        		sumArr[i][j] = max; // 비교가 끝났다면 이번 행, 이번 열이 가질 수 있는 최대값 갱신
        	}	
        }
        
//        for (int i = 0; i < land.length; i++) {
//        	
//        	for (int j = 0; j < 4; j++) {
//        		System.out.print(sumArr[i][j] + " ");
//        	}	
//        	System.out.println();
//        }
        
        int sumMax = sumArr[sumArr.length - 1][0];
        
        for (int i = 1; i < 4; i++) {
        	
        	if (sumMax < sumArr[sumArr.length - 1][i]) {
        		sumMax = sumArr[sumArr.length - 1][i];
        	}
        }
        
        answer = sumMax;

        return answer;
    }

    public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][] land = {{1,2,3,5},{5,6,7,8},{4,3,2,1}};
		
		System.out.println(solution(land)); // 16
    }
}

프로그래머스 땅따먹기 문제 풀이 Java

+ Recent posts