10/2 [donghyeon95]

BaekJoon/1162/도로 포장/donghyeon95.java

@@ -0,0 +1,71 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    static class Node implements Comparable<Node> {
+        int idx, used, cost;
+        Node(int idx, int used, int cost) {
+            this.idx = idx;
+            this.used = used; // 포장 사용 횟수
+            this.cost = cost;
+        }
+        @Override
+        public int compareTo(Node o) {
+            return Integer.compare(this.cost, o.cost);
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int N = Integer.parseInt(st.nextToken());
+        int M = Integer.parseInt(st.nextToken());
+        int K = Integer.parseInt(st.nextToken());
+
+        List<int[]>[] graph = new ArrayList[N + 1];
+        for (int i = 1; i <= N; i++) graph[i] = new ArrayList<>();
+
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int a = Integer.parseInt(st.nextToken());
+            int b = Integer.parseInt(st.nextToken());
+            int w = Integer.parseInt(st.nextToken());
+            graph[a].add(new int[]{b, w});
+            graph[b].add(new int[]{a, w});
+        }
+
+        // dp[node][k] = node까지 k개 포장했을 때 최소 비용
+        long[][] dp = new long[N + 1][K + 1];
+        for (int i = 0; i <= N; i++) Arrays.fill(dp[i], Long.MAX_VALUE);
+        dp[1][0] = 0;
+
+        PriorityQueue<Node> pq = new PriorityQueue<>(); // 원래는 간선이 짧은 순서지만 지금은 현재까지 중에서 Cost가 작은 순서대로
+        pq.offer(new Node(1, 0, 0));
+
+        while (!pq.isEmpty()) {
+            Node cur = pq.poll();
+            if (dp[cur.idx][cur.used] < cur.cost) continue;
+
+            for (int[] next : graph[cur.idx]) {
+                int nextNode = next[0];
+                int weight = next[1];
+
+                // 포장 안함
+                if (dp[nextNode][cur.used] > dp[cur.idx][cur.used] + weight) {
+                    dp[nextNode][cur.used] = dp[cur.idx][cur.used] + weight;
+                    pq.offer(new Node(nextNode, cur.used, (int) dp[nextNode][cur.used]));
+                }
+
+                // 포장 함
+                if (cur.used < K && dp[nextNode][cur.used + 1] > dp[cur.idx][cur.used]) {
+                    dp[nextNode][cur.used + 1] = dp[cur.idx][cur.used];
+                    pq.offer(new Node(nextNode, cur.used + 1, (int) dp[nextNode][cur.used + 1]));
+                }
+            }
+        }
+
+        long ans = Long.MAX_VALUE;
+        for (int i = 0; i <= K; i++) ans = Math.min(ans, dp[N][i]);
+        System.out.println(ans);
+    }
+}

BaekJoon/1446/src/donghyeon95.java

@@ -0,0 +1,65 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int N = Integer.parseInt(st.nextToken());
+        int D = Integer.parseInt(st.nextToken());
+        Set<Integer> set = new TreeSet<>();
+
+        // 2차원 배열 대신 Map 사용 (메모리 절감)
+        Map<Integer, Integer>[] distArr = new HashMap[10001];
+        for (int i = 0; i <= 10000; i++) distArr[i] = new HashMap<>();
+
+        for (int i = 0; i < N; i++) {
+            st = new StringTokenizer(br.readLine());
+            int start = Integer.parseInt(st.nextToken());
+            int end = Integer.parseInt(st.nextToken());
+            int dist = Integer.parseInt(st.nextToken());
+
+            if (end > D) continue;
+
+            set.add(start);
+            set.add(end);
+
+            // 최소 거리 유지 (distArr[start].put(end, dist))
+            distArr[start].merge(end, dist, Math::min);
+        }
+
+        set.add(D);
+
+        var sortedSet = set.stream().sorted().collect(Collectors.toList());
+
+        int[] answers = new int[D + 1];
+        Arrays.fill(answers, Integer.MAX_VALUE);
+        answers[0] = 0;
+
+        int lastedNode = 0;
+
+        for (int node : sortedSet) {
+            for (int i = 0; i <= node; i++) { // N → D
+                if (distArr[i].containsKey(node)) {
+                    int dist = distArr[i].get(node);
+                    if (answers[i] == Integer.MAX_VALUE)
+                        answers[node] = Math.min(answers[node], dist);
+                    else
+                        answers[node] = Math.min(anslwers[node], answers[i] + dist);
+                }
+            }
+
+            if (answers[lastedNode] == Integer.MAX_VALUE)
+                answers[node] = Math.min(answers[node], node - lastedNode);
+            else
+                answers[node] = Math.min(answers[node], answers[lastedNode] + (node - lastedNode));
+
+            lastedNode = node;
+        }
+
+        System.out.println(answers[D]);
+    }
+}

BaekJoon/14500/테트로미노/donghyeon95.java

@@ -0,0 +1,79 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    static int N, M;
+    static int[][] arr;
+    static boolean[][] visited;
+    static int max = 0;
+    static int[] dx = {1, -1, 0, 0};
+    static int[] dy = {0, 0, 1, -1};
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        N = Integer.parseInt(st.nextToken());
+        M = Integer.parseInt(st.nextToken());
+        arr = new int[N][M];
+        visited = new boolean[N][M];
+
+        for (int i = 0; i < N; i++) {
+            st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < M; j++) {
+                arr[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                visited[i][j] = true;
+                dfs(i, j, arr[i][j], 1);
+                visited[i][j] = false;
+                checkT(i, j); // 'ㅗ' 모양 예외 처리
+            }
+        }
+
+        System.out.println(max);
+    }
+
+    static void dfs(int x, int y, int sum, int cnt) {
+        if (cnt == 4) {
+            max = Math.max(max, sum);
+            return;
+        }
+        for (int d = 0; d < 4; d++) {
+            int nx = x + dx[d];
+            int ny = y + dy[d];
+            if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
+            if (!visited[nx][ny]) {
+                visited[nx][ny] = true;
+                dfs(nx, ny, sum + arr[nx][ny], cnt + 1);
+                visited[nx][ny] = false;
+            }
+        }
+    }
+
+    static void checkT(int x, int y) {
+        int[][] t = {
+                {0, -1, 0, 1, -1, 0},
+                {0, -1, 0, 1, 1, 0},
+                {-1, 0, 1, 0, 0, 1},
+                {-1, 0, 1, 0, 0, -1}
+        };
+
+        for (int[] shape : t) {
+            int sum = arr[x][y];
+            boolean valid = true;
+            for (int i = 0; i < 3; i++) {
+                int nx = x + shape[i * 2];
+                int ny = y + shape[i * 2 + 1];
+                if (nx < 0 || ny < 0 || nx >= N || ny >= M) {
+                    valid = false;
+                    break;
+                }
+                sum += arr[nx][ny];
+            }
+            if (valid) max = Math.max(max, sum);
+        }
+    }
+}

BaekJoon/19236/ 청소년 상어/donghyeon95.java

@@ -0,0 +1,106 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Main {
+	// 1~8 방향 (상, 좌상, 좌, 좌하, 하, 우하, 우, 우상)
+	static int[][] moves = {
+		{},
+		{0, -1}, {-1, -1}, {-1, 0}, {-1, 1},
+		{0, 1}, {1, 1}, {1, 0}, {1, -1}
+	};
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int[][] fishValue = new int[4][4]; // 물고기 번호
+		int[][] fishMove = new int[4][4];  // 물고기 방향
+
+		for (int j = 0; j < 4; j++) {
+			StringTokenizer st = new StringTokenizer(br.readLine());
+			for (int i = 0; i < 4; i++) {
+				int a = Integer.parseInt(st.nextToken()); // 물고기 번호
+				int b = Integer.parseInt(st.nextToken()); // 방향
+				fishValue[j][i] = a;
+				fishMove[j][i] = b;
+			}
+		}
+
+		System.out.println(dfs(fishValue, fishMove, 0, 0, 0));
+	}
+
+	public static int dfs(int[][] fishValue, int[][] fishMove, int sharkX, int sharkY, int sharkMove) {
+		// 벽을 넘거나 물고기가 없을 때는 종료
+		if (sharkX < 0 || sharkX > 3 || sharkY < 0 || sharkY > 3 || fishValue[sharkY][sharkX] == 0) {
+			return 0;
+		}
+
+		// 상어가 먹는다
+		int answer = fishValue[sharkY][sharkX];
+		int newSharkMove = fishMove[sharkY][sharkX];
+		fishValue[sharkY][sharkX] = 0;
+		fishMove[sharkY][sharkX] = 0;
+
+		// 물고기 이동
+		for (int i = 1; i <= 16; i++) {
+			int[] fish = findFish(fishValue, i);
+			if (fish == null) continue;
+
+			int move = fishMove[fish[1]][fish[0]];
+			int newFishX = fish[0] + moves[move][0];
+			int newFishY = fish[1] + moves[move][1];
+
+			// 회전해서 갈 수 있는 자리 찾기
+			for (int j = 0; j < 8; j++) {
+				if (newFishX < 0 || newFishX > 3 || newFishY < 0 || newFishY > 3 || (newFishX == sharkX && newFishY == sharkY)) {
+					move = (move == 8) ? 1 : move + 1; // 방향 회전
+					newFishX = fish[0] + moves[move][0];
+					newFishY = fish[1] + moves[move][1];
+				} else break;
+			}
+
+			// 물고기 스왑
+			int fishNum = fishValue[fish[1]][fish[0]];
+			int tempValue = fishValue[newFishY][newFishX];
+			int tempMove = fishMove[newFishY][newFishX];
+
+			fishValue[newFishY][newFishX] = fishNum;
+			fishMove[newFishY][newFishX] = move;
+			fishValue[fish[1]][fish[0]] = tempValue;
+			fishMove[fish[1]][fish[0]] = tempMove;
+		}
+
+		// 상어 이동 (최대 3칸)
+		int result = 0;
+		for (int i = 1; i <= 3; i++) {
+			int newSharkX = sharkX + (moves[newSharkMove][0] * i);
+			int newSharkY = sharkY + (moves[newSharkMove][1] * i);
+
+			result = Math.max(result,
+				dfs(cloneArr(fishValue), cloneArr(fishMove), newSharkX, newSharkY, newSharkMove));
+		}
+
+		return answer + result;
+	}
+
+	// 배열 깊은 복사
+	public static int[][] cloneArr(int[][] arr) {
+		int[][] newArr = new int[4][4];
+		for (int i = 0; i < 4; i++) {
+			newArr[i] = arr[i].clone();
+		}
+		return newArr;
+	}
+
+	// 특정 번호의 물고기 찾기
+	public static int[] findFish(int[][] fishValue, int fishNum) {
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				if (fishValue[i][j] == fishNum) {
+					return new int[]{j, i};
+				}
+			}
+		}
+		return null;
+	}
+}