Merge remote-tracking branch 'origin/main' into hexeong

Author: Hexeong

.github/workflows/auto-weekly-issue.yml

@@ -16,14 +16,12 @@ jobs:
       - name: Calculate week number and dates
         id: calc
         run: |
-          # 현재 날짜 기준 주차 계산 (1월 1일 기준)
           WEEK_NUM=$(date +%U)
-          # 주차를 2자리로 포맷 (01, 02, ...)
-          WEEK_NUM_FORMATTED=$(printf "%02d" $((WEEK_NUM + 1)))
+          
+          WEEK_NUM_FORMATTED=$(printf "%02d" $((10#$WEEK_NUM + 1)))
 
-          # 이번 주 월요일과 일요일 계산
           START_DATE=$(date -d "monday" +%Y.%m.%d)
-          END_DATE=$(date -d "sunday" +%Y.%m.%d)
+          END_DATE=$(date -d "monday + 6 days" +%Y.%m.%d)
 
           echo "week_number=$WEEK_NUM_FORMATTED" >> $GITHUB_OUTPUT
           echo "start_date=$START_DATE" >> $GITHUB_OUTPUT

personal/JAEHEE25/BOJ/BOJ15988.java

@@ -0,0 +1,27 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        //dp
+        long[] dp = new long[1000001];
+        dp[1] = 1;
+        dp[2] = 2;
+        dp[3] = 4;
+        for (int i = 4; i <= 1000000; i++) {
+            dp[i] = (dp[i - 3] + dp[i - 2] + dp[i - 1]) % 1_000_000_009;
+        }
+
+        //정답 출력
+        StringBuilder answer = new StringBuilder();
+        int T = Integer.parseInt(br.readLine());
+        for (int i = 0; i < T; i++) {
+            int t = Integer.parseInt(br.readLine());
+            answer.append(dp[t] % 1_000_000_009).append("\n");
+        }
+        System.out.println(answer);
+    }
+}

personal/JAEHEE25/BOJ/BOJ2156.java

@@ -0,0 +1,24 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class BOJ2156 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(br.readLine());
+        int[] wines = new int[N+1];
+        for (int i = 1; i <= N; i++) {
+            wines[i] = Integer.parseInt(br.readLine());
+        }
+
+        int[] dp = new int[N+1]; //dp[i] = i까지 최대로 마실 수 있는 포도주의 양
+        for (int i = 1; i <= N; i++) {
+            if (i == 1) dp[1] = wines[1];
+            else if (i == 2) dp[2] = wines[1] + wines[2];
+            else dp[i] = Math.max(dp[i-1], wines[i] + Math.max(dp[i-2], dp[i-3] + wines[i-1]));
+        }
+
+        System.out.println(dp[N]);
+
+    }
+}

personal/JAEHEE25/PGS/디스크_컨트롤러.java

@@ -0,0 +1,58 @@
+import java.util.*;
+
+class Solution {
+    public int solution(int[][] jobs) {
+        Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]); //요청 시각 기준 정렬
+
+        PriorityQueue<Job> waitQueue = new PriorityQueue<>(); //대기 큐
+
+        int totalTime = 0;
+        int ji = 0; //jobs 인덱스
+        int time = 0; //현재 시간
+        int endCnt = 0; //종료한 작업 수
+
+        while (endCnt < jobs.length) {
+            //현재 시간 전까지의 작업 모두 대기 큐에 삽입
+            while (ji < jobs.length && jobs[ji][0] <= time) {
+                waitQueue.add(new Job(ji, jobs[ji][0], jobs[ji][1]));
+                ji++;
+            }
+
+            //대기 큐에서 꺼내서 작업 시작
+            if (!waitQueue.isEmpty()) {
+                Job job = waitQueue.poll();
+                time += job.processTime;
+                totalTime += (time - job.requestTime);
+                endCnt++;
+            } else {
+                time = jobs[ji][0]; //처리할 작업이 없으면 다음 작업 요청 시간으로 이동
+            }
+        }
+
+        return totalTime / jobs.length;
+    }
+}
+
+class Job implements Comparable<Job> {
+    int num;
+    int requestTime;
+    int processTime;
+
+    Job(int num, int requestTime, int processTime) {
+        this.num = num;
+        this.requestTime = requestTime;
+        this.processTime = processTime;
+    }
+
+    @Override
+    public int compareTo(Job o) {
+        //소요시간이 짧은 것 -> 요청 시각이 빠른 것 -> 번호가 작은 것
+        if (this.processTime == o.processTime) {
+            if (this.requestTime == o.requestTime) {
+                return this.num - o.num;
+            }
+            return this.requestTime - o.requestTime;
+        }
+        return this.processTime - o.processTime;
+    }
+}

personal/JAEHEE25/PGS/문자열_압축.java

@@ -0,0 +1,46 @@
+import java.util.*;
+
+class Solution {
+    public int solution(String s) {
+        int answer = Integer.MAX_VALUE;
+        int len = 1; //단위
+        int N = s.length();
+
+        while (len <= N) {
+            StringBuilder resultBuilder = new StringBuilder();
+            StringBuilder wordBuilder = new StringBuilder();
+            String prev = "";
+            String word = "";
+            int cnt = 0;
+            for (int i = 0; i <= N; i++) {
+                word = wordBuilder.toString();
+                if (word.length() == len) {
+                    if (prev.equals("")) { //맨 처음일 경우 prev에 저장
+                        prev = word;
+                        cnt++;
+                    } else if (prev.equals(word)) { //연속된 단어일 경우 개수 카운트
+                        cnt++;
+                    } else { //새로운 단어일 경우 이전 단어 기록
+                        if (cnt <= 1) resultBuilder.append(prev);
+                        else resultBuilder.append(cnt + prev);
+                        prev = word;
+                        cnt = 1;
+                    }
+                    wordBuilder = new StringBuilder(); //초기화
+                }
+                if (i < N) wordBuilder.append(s.charAt(i));
+            }
+
+            //마지막 처리
+            if (cnt <= 1) resultBuilder.append(prev);
+            else resultBuilder.append(cnt + prev);
+            resultBuilder.append(wordBuilder.toString()); //남은 글자들
+
+            //정답 구하기
+            answer = Math.min(resultBuilder.length(), answer);
+            len++;
+        }
+
+        return answer;
+    }
+}

personal/JAEHEE25/PGS/수식_최대화.java

@@ -0,0 +1,81 @@
+import java.util.*;
+class Solution {
+    public long solution(String expression) {
+        List<String> list = toList(expression); //리스트로 분리
+
+        //우선순위별 계산
+        String[] prior = {"*-+", "*+-", "+-*", "+*-", "-*+", "-+*"};
+        long answer = 0;
+        for (String p : prior) {
+            answer = Math.max(getResult(list, p), answer); //해당 우선순위로 계산했을 때의 결과로 최댓값 찾기
+        }
+        return answer;
+    }
+
+    long getResult(List<String> list, String p) {
+        Deque<String> dq = new ArrayDeque<>();
+        for (int i = 0; i < list.size(); i++) { //리스트로 덱 초기화
+            dq.offerLast(list.get(i));
+        }
+        dq.offerLast("last"); //마지막 원소임을 표시
+
+        int pi = 0;
+        char op = '.'; //.으로 초기화
+        while (pi < 3) {
+            String val = dq.pollFirst();
+
+            if (val.equals("last")) { //마지막 원소일 경우
+                pi++;
+                if (dq.size() == 1) { //1개만 남았을 경우 최종 결과 반환
+                    return Math.abs(Long.parseLong(dq.pollLast()));
+                }
+                dq.offerLast("last");
+                continue;
+            }
+
+            if (op != '.') { //계산
+                long num1 = Long.parseLong(dq.pollLast());
+                long num2 = Long.parseLong(val);
+                long result = calculate(num1, num2, op);
+                dq.offerLast(String.valueOf(result)); //연산 결과 삽입
+                op = '.';
+                continue;
+            }
+
+            if (val.charAt(0) == p.charAt(pi)) { //우선순위에 해당하는 연산자라면
+                op = val.charAt(0);
+            } else {
+                dq.offerLast(val);
+            }
+        }
+
+        return 0;
+    }
+
+    long calculate(long num1, long num2, char op) {
+        if (op == '*') {
+            return num1 * num2;
+        } else if (op == '+') {
+            return num1 + num2;
+        } else {
+            return num1 - num2;
+        }
+    }
+
+    List<String> toList(String expression) {
+        List<String> list = new ArrayList<>();
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < expression.length(); i++) {
+            char c = expression.charAt(i);
+            if (!Character.isDigit(c)) { //연산자라면
+                list.add(sb.toString());
+                sb = new StringBuilder();
+                list.add(String.valueOf(c));
+            } else {
+                sb.append(c);
+            }
+        }
+        list.add(sb.toString());
+        return list;
+    }
+}

weekly/week02/BOJ_15486_퇴사2/JAEHEE25.java

@@ -0,0 +1,32 @@
+package week02.BOJ_15486_퇴사2;
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class BOJ15486 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(br.readLine());
+        int[] T = new int[N];
+        int[] P = new int[N];
+        for (int i = 0; i < N; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int t = Integer.parseInt(st.nextToken());
+            int p = Integer.parseInt(st.nextToken());
+            T[i] = t;
+            P[i] = p;
+        }
+
+        int max = 0;
+        int[] dp = new int[N + 1];
+        for (int i = 0; i < N; i++) {
+            max = Math.max(dp[i], max);
+            if (i + T[i] <= N) { //기간 초과 제외
+                dp[i + T[i]] = Math.max(P[i] + max, dp[i + T[i]]);
+            }
+        }
+
+        System.out.println(Math.max(dp[N], max));
+    }
+}

weekly/week02/BOJ_15486_퇴사2/gyuhyeok99.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int n, ret;
+int arr[1500001][2];
+int dp[1500001];
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+
+    cin >> n;
+
+    for (int i = 0; i < n; i++) {
+        cin >> arr[i][0] >> arr[i][1];
+    }
+
+    for (int i = n - 1; i >= 0; i--) {
+        if (i + arr[i][0] <= n) {
+            dp[i] = max(dp[i + 1], arr[i][1] + dp[i + arr[i][0]]);
+        } else {
+            dp[i] = dp[i + 1];
+        }
+    }
+
+    cout << dp[0] << '\n';
+    return 0;
+}

weekly/week02/BOJ_15486_퇴사2/sukangpunch.java

@@ -0,0 +1,39 @@
+package stduy.week02;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+// 퇴사 2
+// 답 확인
+public class BOJ_15486 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int N = Integer.parseInt(br.readLine());
+        int[] T = new int[N + 1];
+        int[] P = new int[N + 1];
+
+        for(int i = 1; i <= N; i++){
+            String[] s = br.readLine().split(" ");
+            T[i] = Integer.parseInt(s[0]);
+            P[i] = Integer.parseInt(s[1]);
+        }
+
+        int[] dp = new int[N + 2]; // N+1일에 끝나는 상담을 위해 N+2 크기
+
+        for(int i = 1; i <= N; i++){
+            // i 일에 상담을 하지 않으면, i일의 수익이 i+1 에도 그대로 유지
+            dp[i + 1] = Math.max(dp[i + 1], dp[i]);
+
+            // i일에 상담을 하는 경우
+            int endDay = i + T[i];
+            if(endDay <= N + 1){
+                dp[endDay] = Math.max(dp[endDay], dp[i] + P[i]); // 수익이 발생하는 날에 바로 P값을 적용한 결과 저장
+            }
+        }
+
+        System.out.println(dp[N + 1]);
+    }
+}

weekly/week02/BOJ_15486_퇴사2/whqtker.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int dp[1500051];
+pair<int, int> consult[1500001]; // consult[i] = { x, y } : i일의 상담은 x일이 걸리며 수익은 y
+
+int main() {
+	int n;
+	cin >> n;
+	for (int i = 1; i <= n; i++) {
+		int x, y;
+		cin >> x >> y;
+		consult[i] = { x, y };
+	}
+
+    for (int i = 1; i <= n; i++) {
+        dp[i + 1] = max(dp[i + 1], dp[i]);
+
+        if (i + consult[i].first <= n + 1) {
+            dp[i + consult[i].first] = max(dp[i + consult[i].first], dp[i] + consult[i].second);
+        }
+    }
+
+    cout << dp[n + 1] << "\n";
+}