19-jung0115

jung0115/.gitignore

@@ -1,2 +1,3 @@
 *.jars
-*.jar
+*.jar
+*.class

jung0115/README.md

@@ -12,4 +12,12 @@
 | 8차시 | 2024.08.19.월 | 이분 탐색 | [입국심사(Lv.3)](https://school.programmers.co.kr/learn/courses/30/lessons/43238) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/148 |
 | 9차시 | 2024.08.27.화 | 수학 | [음식 평론가(1188)](https://www.acmicpc.net/problem/1188) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/150 |
 | 10차시 | 2024.08.28.수 | 브루트포스 | [램프(1034)](https://www.acmicpc.net/problem/1034) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/151 |
-| 11차시 | 2024.09.04.수 | 수학 | [축구(1344)](https://www.acmicpc.net/problem/1344) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/153 |
+| 11차시 | 2024.09.04.수 | 수학 | [축구(1344)](https://www.acmicpc.net/problem/1344) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/153 |
+| 12차시 | 2024.09.07.토 | 다이나믹 프로그래밍 | [개근상(1563)](https://www.acmicpc.net/problem/1563) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/157 |
+| 13차시 | 2024.09.23.월 | 다이나믹 프로그래밍 | [사전(1256)](https://www.acmicpc.net/problem/1256) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/162 |
+| 14차시 | 2024.09.25.수 | 그리디 알고리즘 | [컵라면(1781)](https://www.acmicpc.net/problem/1781) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/165 |
+| 15차시 | 2024.09.28.토 | 이분 탐색 | [가장 긴 증가하는 부분 수열 2(12015)](https://www.acmicpc.net/problem/12015) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/169 |
+| 16차시 | 2024.10.05.토 | 시뮬레이션 | [주차 요금 계산(Lv.2)](https://school.programmers.co.kr/learn/courses/30/lessons/92341) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/173 |
+| 17차시 | 2024.10.11.금 | 그리디 알고리즘 | [마법의 엘리베이터(Lv.2)](https://school.programmers.co.kr/learn/courses/30/lessons/148653) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/175 |
+| 18차시 | 2024.10.12.토 | 다이나믹 프로그래밍 | [뉴스 전하기(1135)](https://www.acmicpc.net/problem/1135) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/177 |
+| 19차시 | 2024.10.16.수 | 분할정복 | [괄호 변환(Lv.2)](https://school.programmers.co.kr/learn/courses/30/lessons/60058) | https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/178 |

jung0115/그리디알고리즘/Baekjoon_1781.java

@@ -0,0 +1,66 @@
+// 14차시 2024.09.25.수 : 백준 - 컵라면(1781)
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Baekjoon_1781 {
+  static class CupNoodle implements Comparable<CupNoodle> {
+    int deadLine;
+    int count;
+
+    public CupNoodle(int deadLine, int count) {
+      this.deadLine = deadLine;
+      this.count = count;
+    }
+
+    @Override
+    public int compareTo(CupNoodle o) {
+      // 데드라인을 기준으로 오름차순 정렬
+      return this.deadLine - o.deadLine;
+    }
+  }
+
+  public static void main(String[] args) throws IOException {
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    int N = Integer.parseInt(br.readLine());
+
+    CupNoodle[] cupNoodles = new CupNoodle[N];
+
+    for (int i = 0; i < N; i++) {
+      StringTokenizer st = new StringTokenizer(br.readLine());
+
+      int deadLine = Integer.parseInt(st.nextToken()); // 데드라인
+      int count = Integer.parseInt(st.nextToken());    // 맞힐 때 받는 컵라면 수
+
+      cupNoodles[i] = new CupNoodle(deadLine, count);
+    }
+
+    // 데드라인을 기준으로 정렬 (오름차순)
+    Arrays.sort(cupNoodles);
+
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+
+    for (CupNoodle cn : cupNoodles) {
+      // 만약 현재 데드라인 내에 풀 수 있는 문제라면 큐에 추가
+      pq.offer(cn.count);
+
+      // 큐의 크기가 데드라인을 초과하면 가장 적은 컵라면 수를 제거
+      if (pq.size() > cn.deadLine) {
+        pq.poll();
+      }
+    }
+
+    int answer = 0;
+
+    // 큐에 남아 있는 컵라면의 총합을 구함
+    while (!pq.isEmpty()) {
+      answer += pq.poll();
+    }
+
+    System.out.println(answer);
+  }
+}

jung0115/그리디알고리즘/Baekjoon_1781_fail.java

@@ -0,0 +1,37 @@
+// 14차시 2024.09.25.수 : 백준 - 컵라면(1781)
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.HashMap;
+import java.util.Iterator;
+
+public class Baekjoon_1781_fail {
+  public static void main(String[] args) throws IOException {
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    int N = Integer.parseInt(br.readLine());
+
+    HashMap<Integer, Integer> cupNoodles = new HashMap<Integer, Integer>();
+
+    for(int i = 0; i < N; i++) {
+      StringTokenizer st = new StringTokenizer(br.readLine());
+
+      int deadLine = Integer.parseInt(st.nextToken()); // 데드라인
+      int count = Integer.parseInt(st.nextToken());    // 맞힐 때 받는 컵라면 수
+
+      int current = cupNoodles.getOrDefault(deadLine, 0);
+      if(current < count) cupNoodles.put(deadLine, count);
+    }
+
+    int answer = 0;
+
+    Iterator<Integer> keys = cupNoodles.keySet().iterator();
+    while(keys.hasNext()){
+      int key = keys.next();
+      answer += cupNoodles.get(key);
+    }
+
+    System.out.print(answer);
+  }
+}

jung0115/그리디알고리즘/Programmers_148653.kt

@@ -0,0 +1,26 @@
+// 17차시 2024.10.11.금 : 프로그래머스 - 마법의 엘리베이터(Lv.2)
+class Solution {
+  fun solution(storey: Int): Int {
+    var answer: Int = 0
+    var storeyClone = storey
+
+    while (storeyClone > 0) {
+      val num = storeyClone % 10
+      storeyClone /= 10
+
+      if (num < 5) {
+        answer += num
+      } else if (num == 5) {
+        // 5일 때, 다음 자릿수를 확인
+        if (storeyClone % 10 >= 5) storeyClone++
+
+        answer += 5
+      } else {
+        answer += (10 - num)
+        storeyClone++
+      }
+    }
+
+    return answer
+  }
+}

jung0115/다이나믹프로그래밍/Baekjoon_1135.kt

@@ -0,0 +1,46 @@
+// 18차시 2024.10.12.토 : 백준 - 뉴스 전하기(1135)
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.util.StringTokenizer
+
+lateinit var employees: Array<MutableList<Int>>
+lateinit var dp: Array<Int>
+
+fun main() {
+  val br = BufferedReader(InputStreamReader(System.`in`))
+
+  var N = br.readLine().toInt() // 직원의 수
+
+  val st = StringTokenizer(br.readLine())
+  employees = Array(N) { mutableListOf<Int>() }
+  dp = Array<Int>(N) { -1 }
+
+  st.nextToken()
+  for(i: Int in 1..N-1) {
+    employees[st.nextToken().toInt()].add(i)
+  }
+
+  println(dfs(0))
+}
+
+fun dfs(employee: Int): Int {
+  if (dp[employee] != -1) return dp[employee]
+
+  // 더 이상 전화할 사람이 없음
+  if (employees[employee].isEmpty()) return 0
+
+  // 자식들에게 전화하는 시간
+  // 내림차순 정렬
+  val times = employees[employee].map { dfs(it) }.sortedDescending()
+
+  // 각 자식에게 전화 거는 시간 계산
+  var maxTime = 0
+  for (i in times.indices) {
+    // 자식에게 전화 + 그 자식이 전화 거는 시간
+    maxTime = maxOf(maxTime, times[i] + i + 1)
+  }
+
+  dp[employee] = maxTime
+
+  return dp[employee]
+}

jung0115/다이나믹프로그래밍/Baekjoon_1256.java

@@ -0,0 +1,55 @@
+package jung0115.다이나믹프로그래밍;
+// 13차시 2024.09.23.월 : 백준 - 사전(1256)
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Baekjoon_1256 {
+  public static void main(String[] args) throws IOException {
+    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+    StringTokenizer st = new StringTokenizer(bf.readLine());
+
+    int N = Integer.parseInt(st.nextToken()); // a의 개수
+    int M = Integer.parseInt(st.nextToken()); // z의 개수
+    int K = Integer.parseInt(st.nextToken()); // 몇 번째 문자열을 찾아야 하는지
+
+    StringBuilder answer = new StringBuilder();
+
+    long[][] dp = new long[ N + M + 1 ][ N + M + 1 ];
+    dp[0][0] = 1;
+
+    for(int i = 1;i <= N + M; i++){
+      dp[i][0] = 1;
+      dp[i][i] = 1;
+      for(int j = 1; j < i; j++){
+        dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
+
+        if(dp[i][j] > 1000000000)
+          dp[i][j] = 1000000001;
+      }
+    }
+
+    // 사전에 수록되어 있는 문자열의 개수가 K보다 작을 경우
+    if(dp[N + M][M] < K) {
+      answer.append("-1");
+    }
+    else {
+      while (N != 0 || M != 0) {
+        if(dp[N + M - 1][M] >= K) {
+          answer.append("a");
+          N--;
+        }
+        else {
+          answer.append("z");
+          K -= dp[N + M - 1][M];
+          M--;
+        }
+      }
+    }
+
+    System.out.print(answer);
+
+  }
+}

jung0115/다이나믹프로그래밍/Baekjoon_1563.kt

@@ -0,0 +1,37 @@
+// 12차시 2024.09.07.토 : 백준 - 개근상(1563)
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+
+fun main() {
+  // ✅ Input
+  val br = BufferedReader(InputStreamReader(System.`in`))
+
+  val N = br.readLine().toInt()
+
+  // ✅ Solve
+  // 출석 일수, 지각 일수, 연속 결석 일수
+  val dp = Array(N + 1, {Array(2, {Array(3, {0})})})
+
+  dp[1][0][0] = 1
+  dp[1][1][0] = 1
+  dp[1][0][1] = 1
+
+  for(i: Int in 2..N) {
+    dp[i][0][0] = (dp[i-1][0][0] + dp[i-1][0][1] + dp[i-1][0][2]) % 1000000;
+    dp[i][0][1] = dp[i-1][0][0] % 1000000;
+    dp[i][0][2] = dp[i-1][0][1] % 1000000;
+    dp[i][1][0] = (dp[i][0][0] + dp[i-1][1][0] + dp[i-1][1][1] + dp[i-1][1][2]) % 1000000;
+    dp[i][1][1] = dp[i-1][1][0] % 1000000;
+    dp[i][1][2] = dp[i-1][1][1] % 1000000;
+  }
+
+  var answer = 0
+  for(i: Int in 0..1) {
+    for(j: Int in 0..2) {
+      answer += dp[N][i][j]
+    }
+  }
+
+  print(answer % 1000000)
+}

jung0115/분할정복/Programmers_60058.kt

@@ -0,0 +1,77 @@
+// 프로그래머스 - 괄호 변환(Lv.2)
+class Solution {
+  fun solution(p: String): String {
+    // 괄호를 숫자로 변환
+    val numP = mutableListOf<Int>()
+    for(i: Int in 0..p.length - 1) {
+      if(p[i] == '(') numP.add(1)
+      else numP.add(-1)
+    }
+
+    var answerList = divideString(numP)
+
+    var answer = ""
+
+    for(str in answerList) {
+      if(str == 1) answer += "("
+      else answer += ")"
+    }
+
+    return answer
+  }
+
+  fun divideString(w: MutableList<Int>): MutableList<Int> {
+    // w가 빈 문자열이거나 올바른 괄호문자열인 경우 그대로 반환
+    if(w.size == 0 || isCollect(w)) return w
+
+    // 균형잡힌 괄호 문자열 u, v로 분리하기
+    var checkSum: Int = 0
+
+    for(i: Int in 0..w.size - 1) {
+      checkSum += w[i]
+
+      // 균형잡힌 괄호 문자열로 나뉘는 지점
+      if(checkSum == 0) {
+        var u = w.subList(0, i + 1)
+        val v = divideString(w.subList(i + 1, w.size).toMutableList())
+
+        // u가 올바른 문자열일 경우
+        if(isCollect(u)) {
+          u.addAll(v)
+          return u
+        }
+        // u가 올바른 문자열이 아닐 경우
+        else {
+          var result = mutableListOf<Int>()
+          result.add(1)    // 4-1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다.
+          result.addAll(v) // 4-2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다.
+          result.add(-1)   // 4-3. ')'를 다시 붙입니다.
+
+          // 4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다.
+          u.removeAt(0)
+          u.removeAt(u.size - 1)
+          for(i: Int in 0..u.size - 1) {
+            u[i] *= -1
+          }
+
+          result.addAll(u)
+
+          return result
+        }
+      }
+    }
+
+    return w
+  }
+
+  // 올바른 괄호 문자열인지 판단하는 함수
+  fun isCollect(str: MutableList<Int>): Boolean {
+    var checkSum: Int = 0
+    for(i: Int in 0..str.size - 1) {
+      checkSum += str[i]
+
+      if(checkSum < 0) return false
+    }
+    return true
+  }
+}