Merge branch 'main' into lkhyun

Author: lkhyun

.github/auto_assign.yml

@@ -0,0 +1,13 @@
+# Set to true to add reviewers to pull requests
+addReviewers: false
+
+# Set to true to add assignees to pull requests
+addAssignees: author 
+
+# A list of keywords to be skipped the process that add reviewers if pull requests include it 
+skipKeywords:
+  - wip
+
+# A number of reviewers added to the pull request
+# Set 0 to add all the reviewers (default: 0)
+numberOfReviewers: 0

.github/workflows/CI.yml

@@ -0,0 +1,33 @@
+name: 자동 통합 CI
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v2
+      with:
+        node-version: '14'  
+
+    - name: Install dependencies
+      run: npm install  
+
+    - name: Merge pull requests
+      run: |
+        TODAY=$(TZ='Asia/Seoul' date +%Y%m%d)
+
+        PRS=$(gh pr list --state open --base main --json number,title --jq '.[] | select(.title | startswith("[" + "'"$TODAY"'" + "]")) | .number')
+        for pr in $PRS; do
+          echo "Merging PR #$pr"
+          gh pr merge $pr --merge --admin
+        done
+      env:
+        GITHUB_TOKEN: ${{ secrets.TOKEN }}

03do-new30/202502/03 BOJ G5 모노톤길.md

@@ -0,0 +1,84 @@
+```java
+import java.util.*;
+import java.io.*;
+
+public class Main {
+	
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+		
+		int T = Integer.parseInt(br.readLine());
+		for (int tc = 1; tc <= T; tc++) {
+			int n = Integer.parseInt(br.readLine());
+
+            // TreeMap: 자동정렬(오름차순)을 보장하며, 키 기반 탐색 성능 logN
+			Map<Integer, List<Integer>> map = new TreeMap<>();
+			map.put(-1, new ArrayList<>(Arrays.asList(0)));
+			StringTokenizer st;
+			for (int i = 0; i < n; i++) {
+				st = new StringTokenizer(br.readLine());
+				int x = Integer.parseInt(st.nextToken());
+				int y = Integer.parseInt(st.nextToken());
+				
+				if (map.containsKey(x)) {
+					map.get(x).add(y);
+				} else {
+					List<Integer> val = new ArrayList<>();
+					val.add(y);
+					map.put(x, val);
+				}
+			}
+
+			int[] keys = map.keySet().stream().mapToInt(x -> x).toArray();
+			for (int i = 0; i < keys.length; i++) {
+				int key = keys[i];
+				
+				if (key == -1) continue;
+				
+				if (map.get(key).size() == 1) {
+					continue;
+				}
+				
+				// 이전 x좌표의 마지막 y좌표와 비교해서
+				// 같은 x좌표를 가진 좌표들 중 가장 먼저 도달하는 y좌표를 구한다.
+				int prevKey = keys[i-1];
+				int lastIndex = map.get(prevKey).size() - 1;
+				int firstY = map.get(prevKey).get(lastIndex);
+				
+				// 현재 x좌표의 y좌표들 중 가장 값이 큰 y좌표를 찾는다
+				int maxY = Collections.max(map.get(key));
+				
+				// firstY가 maxY라면 내림차순 정렬
+				// firstY가 maxY가 아니라면 오름차순 정렬
+				if (firstY == maxY) {
+					Collections.sort(map.get(key), Collections.reverseOrder());
+				}
+				else {
+					Collections.sort(map.get(key));
+				}
+			}
+			List<String> points = new ArrayList<>(n);
+			for (int x : keys) {
+				List<Integer> values = map.get(x);
+				for (int y : values) {
+					points.add(x + " " + y);
+				}
+			}
+			
+			int[] tmp = Arrays.stream(br.readLine().split(" "))
+							.mapToInt(x -> Integer.parseInt(x))
+							.toArray();
+			int total = tmp[0];
+			for (int i = 1; i <= total; i++) {
+				bw.write(points.get(tmp[i]) + "\n");
+			}
+		}
+		
+		br.close();
+		bw.flush();
+		bw.close();
+	}
+}
+```
+- `TreeMap` 사용

03do-new30/202502/04 BOJ G2 등산.md

@@ -0,0 +1,160 @@
+```java
+import java.io.*;
+import java.util.*;
+
+public class Main {
+	
+	private static class Node implements Comparable<Node>{
+		int r;
+		int c;
+		int weight;
+		public Node(int r, int c, int weight) {
+			this.r = r;
+			this.c = c;
+			this.weight = weight;
+		}
+		
+		public String toString() {
+			return "(" + r + ", " + c + ", time:" + weight + ")";
+		}
+
+		@Override
+		public int compareTo(Node o) {
+			return Integer.compare(this.weight, o.weight);
+		}
+	}
+	
+	private static int N;
+	private static int M;
+	private static int T;
+	private static int D;
+	private static int[][] arr;
+	private static int[] dr = {0, 0, -1, 1};
+	private static int[] dc = {-1, 1, 0, 0};
+	private static final int INF = Integer.MAX_VALUE;
+	private static List<List<Node>> graph;
+	
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+		
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		N = Integer.parseInt(st.nextToken());
+		M = Integer.parseInt(st.nextToken());
+		T = Integer.parseInt(st.nextToken());
+		D = Integer.parseInt(st.nextToken());
+		
+		arr = new int[N][M];
+		for (int i = 0; i < N; i++) {
+			char[] tmpChar = br.readLine().toCharArray();
+			for (int j = 0; j < M; j++) {
+				if (Character.isLowerCase(tmpChar[j])) {
+					arr[i][j] = tmpChar[j] - 'a' + 26;
+				} else {
+					arr[i][j] = tmpChar[j] - 'A';
+				}
+			}
+		}
+		
+		// 인접리스트 생성
+		graph = new ArrayList<>();
+		for (int i = 0; i < N * M; i++) {
+			graph.add(new ArrayList<>());
+		}
+		for (int r = 0; r < N; r++) {
+			for (int c = 0; c < M; c++) {
+				
+				int index = r * M + c;
+				
+				for (int i = 0; i < 4; i++) {
+					int nr = r + dr[i];
+					int nc = c + dc[i];
+					if (nr < 0 || nr >= N || nc < 0 || nc >= M) {
+						continue;
+					}
+					
+					// 높이의 차이가 T보다 크지 않은 곳으로만 다닐 수 있다.
+					if (Math.abs(arr[nr][nc] - arr[r][c]) > T) {
+						continue;
+					}
+					
+					int time;
+					if (arr[r][c] >= arr[nr][nc]) {
+						time = 1;
+					} else {
+						time = (int)Math.pow(arr[nr][nc] - arr[r][c], 2);
+					}
+					
+					graph.get(index).add(new Node(nr, nc, time));
+				}
+				
+			}
+		}
+		
+		// 시작점 0에서 각 점까지의 최단거리
+		int[] dist = dijkstra(new Node(0, 0, 0));
+		
+		// 시작점에서 최단경로가 존재하는 정점 중, 제한 시간 내에 다시 시작점으로 돌아올 수 있는 경우
+		int highest = arr[0][0];
+		for (int mountain = 1; mountain < N*M; mountain++) {
+			if (dist[mountain] != INF) {
+				int mountC = mountain % M;
+				int mountR = mountain / M;
+				
+				if (highest >= arr[mountR][mountC]) continue;
+				
+				int[] backDist = dijkstra(new Node(mountR, mountC, 0));
+				if (dist[mountain] + backDist[0] <= D) {
+					highest = arr[mountR][mountC];
+				}
+			}
+		}
+		
+		bw.write(highest + "\n");
+		
+		br.close();
+		bw.flush();
+		bw.close();
+	}
+	
+	private static int[] dijkstra(Node start) {
+		int[] dist = new int[N * M];
+		Arrays.fill(dist, INF);
+		
+		int startIdx = start.r * M + start.c;
+		dist[startIdx]= 0;
+		
+		PriorityQueue<Node> pq = new PriorityQueue<>();
+		pq.offer(start);
+		
+		while (!pq.isEmpty()) {
+			Node node = pq.poll();
+			int nodeIdx = node.r * M + node.c;
+			
+			List<Node> nextNodes = graph.get(nodeIdx);
+			for (Node nextNode : nextNodes) {
+				int nextIdx = nextNode.r * M + nextNode.c;
+				int nextDist = dist[nodeIdx] + nextNode.weight;
+				if (nextDist < dist[nextIdx]) {
+					dist[nextIdx] = nextDist;
+					pq.offer(new Node(nextNode.r, nextNode.c, nextDist));
+				}
+			}
+		}
+		
+		return dist;
+	}
+}
+```
+- 주어진 입력을 인접 리스트 형태의 그래프로 변환
+- 시작점에서 dijkstra로 최단경로를 구한 뒤, 각 정점에서 시작점으로 제한시간 내에 돌아올 수 있는지 한번 더 체크
+- 유의사항
+    - 시작점의 높이가 가장 높은 경우도 있을 수 있음
+    - `highest`를 0으로 초기화하는 것이 아니라 시작점의 높이로 초기화
+- 테스트케이스
+    ```
+    3 3 51 1000
+    zAA
+    AAA
+    AAA
+    ```

03do-new30/202502/05 BOJ S1 오목.md

@@ -0,0 +1,100 @@
+```java
+import java.util.*;
+import java.io.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int N = 20;
+        int[][] arr = new int[N][N];
+
+        // 검사 방향: 아래, 우상향, 좌하향, 우측
+        int[] dr = {1, -1, 1, 0};
+        int[] dc = {0, 1, 1, 1};
+
+        for (int i = 1; i < N; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int j = 1; j < N; j++) {
+                arr[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        int winner = 0;
+        int winnerR = 0;
+        int winnerC = 0;
+
+        for (int r = 1; r < N; r++) {
+            for (int c = 1; c < N; c++) {
+                
+                if (winner > 0) break; // 승부 결정 완료
+                if (arr[r][c] == 0) continue;
+
+                // 방향 체크
+                for (int i = 0; i < 4; i++) {
+
+                    int cnt = 1; // (r, c)에서 시작, 연속된 바둑돌 개수 카운트
+                    int nr = r + dr[i];
+                    int nc = c + dc[i];
+
+                    while (1 <= nr && nr < N && 1 <= nc && nc < N) {
+                        if (arr[nr][nc] != arr[r][c]) {
+                            break;
+                        }
+                        nr += dr[i];
+                        nc += dc[i];
+                        cnt++;
+                    }
+
+                    // i방향으로 연속된 바둑돌이 5개인 경우
+                    if (cnt == 5) {
+                        // (r, c) 이전의 바둑돌 색상을 확인하여 6개 이상인지 체크
+                        int prevR = r - dr[i];
+                        int prevC = c - dc[i];
+
+                        boolean isValid = false;
+                        if (1 <= prevR && prevR < N && 1 <= prevC && prevC < N) {
+                            if (arr[r][c] != arr[prevR][prevC]) {
+                                isValid = true;
+                            }
+                        }
+                        else { // 이전의 바둑돌이 없다면 5개임이 보장
+                            isValid = true;
+                        }
+
+                        if (isValid) {
+                            winner = arr[r][c];
+                            winnerR = r;
+                            winnerC = c;
+                            break; // 승부 결정 완료
+                        }
+                    }
+                }
+            }
+        }
+
+        bw.write(winner + "\n");
+        if (winner > 0) {
+            bw.write(winnerR + " " + winnerC);
+        }
+
+
+        br.close();
+        bw.flush();
+        bw.close();
+    }
+}
+
+```
+
+- (r, c)에서 ⬇↗↘➡ 방향으로 진행해서 같은 색 바둑돌 5개를 찾은 경우
+
+- 육목일 가능성이 없는지 진행 방향의 반대 방향으로 가서 확인
+
+- `틀렸습니다` 받은 이유
+    - 육목 가능성 체크하기 위해 반대 방향의 좌표 (prevR, prevC)룰 구할 때
+    - (prevR, prevC)가 범위를 벗어난다면 해당 케이스는 오목임이 보장됨
+    - 범위 벗어나는 경우 생각 못하고 `범위 내에 있을때, (r, c)와 같은 색 바둑돌인지`만 체크했던 실수💥
+
+- 가능한 케이스들을 꼼꼼히 생각해 보는 것이 중요