solve: 코딩테스트 문제 풀이 - 15일차

Author: OhChangEun

2025-08-27/오창은/[solved] 프로그래머스_미로 탈출.java

@@ -0,0 +1,83 @@
+import java.util.*;
+
+class Solution {
+    int[] dx = {0, 0, -1, 1};
+    int[] dy = {1, -1, 0, 0};
+    
+    int[] start;
+    int[] lever;
+    int[] end;
+    
+    int n,m;
+    char[][] map;
+   
+    public int solution(String[] maps) {
+        int answer = 0;
+       
+        n = maps.length;
+        m = maps[0].length();
+        map = new char[n][m];
+        for (int i=0; i<n; i++) {
+            char[] row = maps[i].toCharArray();
+            for (int j=0; j<m; j++) {
+            	map[i][j] = row[j];
+                
+                if (row[j] == 'S') {
+                    start = new int[] {i, j};
+                } else if (row[j] == 'L') {
+                    lever = new int[] {i, j};
+                } else if (row[j] == 'E') {
+                    end = new int[] {i, j};
+                }
+                
+            }
+        }
+       
+        int toLever = bfs(start, lever);
+        if (toLever == -1) return -1;
+        
+        int toEnd = bfs(lever, end);
+        if (toEnd == -1) return -1;
+        
+        // System.out.println(start[0] + " " + start[1]);
+        // System.out.println(lever[0] + " " + lever[1]);
+        
+        return toLever + toEnd;
+    }
+   
+    public int bfs(int[] start, int[] end) {
+    	int[][] distance = new int[n][m];
+      	for (int i=0; i<n; i++) {
+            Arrays.fill(distance[i], -1);
+        } 
+        
+        Queue<int[]> queue = new LinkedList<>();
+        int startY = start[0];
+        int startX = start[1];
+       	queue.offer(new int[] {startY, startX});
+      	distance[startY][startX] = 0;
+        
+        while (!queue.isEmpty()) {
+            int[] curr = queue.poll();
+         	int cx = curr[1];
+         	int cy = curr[0];
+           
+            if (cx == end[1] && cy == end[0]) {
+                return distance[cy][cx];
+            }
+            
+            for (int i=0; i<4; i++) {
+            	int ny = cy + dy[i];
+            	int nx = cx + dx[i];
+                
+                if (nx >= 0 && nx < m && ny >=0 && ny < n) {
+                    if (map[ny][nx] != 'X' && distance[ny][nx] == -1) {
+                       	distance[ny][nx] = distance[cy][cx] + 1;
+                        queue.offer(new int[]{ny, nx});
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+}

2025-08-27/오창은/[solved] 프로그래머스_순위_BFS.java

@@ -0,0 +1,56 @@
+import java.util.*;
+
+class Solution {
+    List<List<Integer>> winGraph = new ArrayList<>();
+    List<List<Integer>> loseGraph = new ArrayList<>();
+    
+    public int solution(int n, int[][] results) {
+        for (int i=0; i<=n; i++) {
+            winGraph.add(new ArrayList<>());
+            loseGraph.add(new ArrayList<>());
+        }
+
+        for (int[] result: results) {
+            int win = result[0];
+            int lose = result[1];
+            
+            winGraph.get(win).add(lose);
+            loseGraph.get(lose).add(win);
+        }
+
+        int answer = 0;
+        for (int i=1; i<=n; i++) {
+            int winCount = bfs(i, winGraph, n);
+            int loseCount = bfs(i, loseGraph, n);
+            
+            if (winCount + loseCount == n-1) {
+                answer++;
+            }
+        }
+
+        return answer;
+    }
+    public int bfs(int start, List<List<Integer>> graph, int n) {
+        boolean[] visited = new boolean[n+1];
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(start);
+		visited[start] = true;
+       
+        int count = 0;
+        while (!queue.isEmpty()) {
+            int curr = queue.poll();
+            for (int next: graph.get(curr)) {
+                if (!visited[next]) {
+                    visited[next] = true;
+                    queue.offer(next);
+                    count++;
+                }
+            }
+
+
+
+        }
+        return count;
+
+    }
+}

2025-08-27/오창은/[solved] 프로그래머스_순위_플루이드 워셜.java

@@ -0,0 +1,38 @@
+class Solution {
+    public int solution(int n, int[][] results) {
+        boolean[][] graph = new boolean[n+1][n+1];
+        
+        for (int[] result: results) {
+            int win = result[0];
+            int lose = result[1];
+        	
+            graph[win][lose] = true;
+        }
+        
+        for (int k=1; k<=n; k++) { // 경유 선수 
+            for (int i=1; i<=n; i++) { // 출발 선수 
+                for (int j=1; j<=n; j++) { // 도착 선수
+                    if (graph[i][k] && graph[k][j]) {
+                        graph[i][j] = true;
+                    }
+                }
+            }
+        }
+        
+        int answer = 0; 
+        for (int i=1; i<=n; i++) {
+            int count = 0;
+            for (int j=1; j<=n; j++) {
+                if (i == j) continue; 
+                if (graph[i][j] || graph[j][i]) {
+                    count++;
+                }
+            }
+            if (count == n-1) {
+                answer++;
+            }
+        }
+        
+        return answer;
+    }
+}