Merge pull request #1646 from AlgorithmWithGod/Seol-JY

[20251211] BOJ / G4 / 알고리즘 수업 - 행렬 경로 문제 4 / 설진영

Author: ShinHeeEul

Seol-JY/202512/11 BOJ G4 알고리즘 수업 - 행렬 경로 문제 4.md

@@ -0,0 +1,62 @@
+```java
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine().trim());
+        
+        int[][] m = new int[n + 1][n + 1];
+        for (int i = 1; i <= n; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int j = 1; j <= n; j++) {
+                m[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+        
+        int p = Integer.parseInt(br.readLine().trim());
+        int[][] points = new int[p][2];
+        for (int i = 0; i < p; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            points[i][0] = Integer.parseInt(st.nextToken());
+            points[i][1] = Integer.parseInt(st.nextToken());
+        }
+        
+        long[][] fromStart = new long[n + 1][n + 1];
+        for (int i = 0; i <= n; i++) Arrays.fill(fromStart[i], Long.MIN_VALUE);
+        fromStart[0][1] = 0;
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= n; j++) {
+                long best = Long.MIN_VALUE;
+                if (fromStart[i - 1][j] != Long.MIN_VALUE) best = Math.max(best, fromStart[i - 1][j]);
+                if (fromStart[i][j - 1] != Long.MIN_VALUE) best = Math.max(best, fromStart[i][j - 1]);
+                if (best != Long.MIN_VALUE) fromStart[i][j] = best + m[i][j];
+            }
+        }
+        
+        long[][] toEnd = new long[n + 2][n + 2];
+        for (int i = 0; i <= n + 1; i++) Arrays.fill(toEnd[i], Long.MIN_VALUE);
+        toEnd[n + 1][n] = 0;
+        for (int i = n; i >= 1; i--) {
+            for (int j = n; j >= 1; j--) {
+                long best = Long.MIN_VALUE;
+                if (toEnd[i + 1][j] != Long.MIN_VALUE) best = Math.max(best, toEnd[i + 1][j]);
+                if (toEnd[i][j + 1] != Long.MIN_VALUE) best = Math.max(best, toEnd[i][j + 1]);
+                if (best != Long.MIN_VALUE) toEnd[i][j] = best + m[i][j];
+            }
+        }
+        
+        long answer = Long.MIN_VALUE;
+        for (int i = 0; i < p; i++) {
+            int r = points[i][0];
+            int c = points[i][1];
+            if (fromStart[r][c] != Long.MIN_VALUE && toEnd[r][c] != Long.MIN_VALUE) {
+                answer = Math.max(answer, fromStart[r][c] + toEnd[r][c] - m[r][c]);
+            }
+        }
+        
+        System.out.println(answer);
+    }
+}
+```