[한태희] 수레움직이기, 소형기관차

한태희/0430/Main_bj_g3_2616_소형기관차.java

@@ -0,0 +1,43 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+
+public class Main_bj_g3_2616_소형기관차 {
+    static int[] passengers; 
+    static Integer[][] dp;
+    static int[] sum;
+    static int maxCarry;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int n = Integer.parseInt(br.readLine());
+        passengers = new int[n+1];
+        dp = new Integer[n+1][4];
+        sum = new int[n+1];
+
+        String[] input = br.readLine().split(" ");
+        for (int i = 1; i <= n; i++) {
+            passengers[i] = Integer.parseInt(input[i-1]);
+            sum[i] = sum[i-1] + passengers[i];
+        }
+
+        maxCarry = Integer.parseInt(br.readLine());
+
+        System.out.println(findMaxPassenger(0, 3));
+    }
+
+    public static int findMaxPassenger(int start, int trainCount) {
+        if (trainCount == 0) return 0;
+
+        if (dp[start][trainCount] == null) {
+            dp[start][trainCount] = 0;
+
+            for (int i = start + 1; i <= passengers.length - maxCarry * trainCount; i++) {
+                dp[start][trainCount] = Math.max(dp[start][trainCount], findMaxPassenger(i + maxCarry - 1, trainCount - 1) + (sum[i + maxCarry - 1] - sum[start]));
+            }
+        }
+
+        return dp[start][trainCount];
+    }
+}

한태희/0430/PGMS_수레_움직이기.java

@@ -0,0 +1,109 @@
+import java.util.*;
+
+class Solution {
+    int N, M;
+    int[][] maze;
+    boolean[][] rV, bV;
+    int answer = Integer.MAX_VALUE;
+
+    final int[] dr = {1, -1, 0, 0};
+    final int[] dc = {0, 0, 1, -1};
+
+    public int solution(int[][] m) {
+        maze = m;
+        N = maze.length;
+        M = maze[0].length;
+
+        int redR=-1, redC=-1, blueR=-1, blueC=-1;
+
+        for(int i=0;i<N;i++){
+            for(int j=0;j<M;j++){
+                if(maze[i][j]==1){
+                    maze[i][j] = 0;
+                    redR = i;
+                    redC = j;
+                }
+                if(maze[i][j]==2){
+                    maze[i][j] = 0;
+                    blueR = i;
+                    blueC = j;
+                }
+            }
+        }
+
+        rV = new boolean[N][M]; bV = new boolean[N][M];
+        rV[redR][redC] = true;
+        bV[blueR][blueC] = true;
+        dfs(0, redR, redC, blueR, blueC, false, false);
+
+        if(answer==Integer.MAX_VALUE) answer=0;
+
+        return answer;
+    }
+
+    void dfs(int step, int redR, int redC, int blueR, int blueC, boolean redEnd, boolean blueEnd){
+        if (answer <= step) return;
+
+        if (redEnd && blueEnd){
+            answer = step;
+            return;
+        }
+
+        List<int[]> nextRedCords = new ArrayList<>();
+        List<int[]> nextBlueCords = new ArrayList<>();
+
+        if(redEnd){
+            nextRedCords.add(new int[]{redR, redC});
+        }
+        else{
+            for(int k=0;k<4;k++){
+                int nr = redR + dr[k];
+                int nc = redC + dc[k];
+                if(isValid(nr, nc)==false || rV[nr][nc]==true || maze[nr][nc]==5) continue;
+                nextRedCords.add(new int[]{nr, nc});
+            }
+        }
+        if(blueEnd){
+            nextBlueCords.add(new int[]{blueR, blueC});
+        }
+        else{
+            for(int k=0;k<4;k++){
+                int nr = blueR + dr[k];
+                int nc = blueC + dc[k];
+                if(isValid(nr, nc)==false || bV[nr][nc]==true || maze[nr][nc]==5) continue;
+                 nextBlueCords.add(new int[]{nr, nc});
+            }
+        }
+
+        for(int[] nextRedCord: nextRedCords){
+            for(int[] nextBlueCord: nextBlueCords){
+
+                int rnr = nextRedCord[0], rnc = nextRedCord[1], bnr = nextBlueCord[0], bnc = nextBlueCord[1];
+
+                //위치가 교환 되는 경우 스킵
+                if(rnr==blueR && rnc==blueC && bnr==redR && bnc==redC) continue;
+
+                //두 공의 위치가 겹칠 경우 스킵
+                if(rnr==bnr && rnc==bnc) continue;
+
+                rV[rnr][rnc] = true;
+                bV[bnr][bnc] = true;
+
+                boolean nextRedEnd = false, nextBlueEnd = false;
+                if(maze[rnr][rnc]==3) nextRedEnd = true;
+                if(maze[bnr][bnc]==4) nextBlueEnd = true;
+
+                dfs(step+1, rnr, rnc, bnr, bnc, nextRedEnd, nextBlueEnd);
+
+                rV[rnr][rnc] = false;
+                bV[bnr][bnc] = false;
+            }
+        }
+
+    }
+
+    boolean isValid(int r, int c){
+        if(0<=r && r<N && 0<=c && c<M) return true;
+        else return false;
+    }
+}