pull

youtube/BOJ2749.java

@@ -0,0 +1,67 @@
+import java.io.*;
+
+public class Main {
+    // 문제에서 요구한 나누는 수
+    final static long MOD = 1000000;
+
+    public static void main(String[] args) throws IOException {
+        // 입력 속도를 위해 BufferedReader 사용
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        // n은 최대 100경(10^18)이므로 long 사용
+        long n = Long.parseLong(br.readLine());
+
+        // F_0 = 0
+        if (n == 0) {
+            System.out.println(0);
+            return;
+        }
+
+        // 피보나치 Q-행렬 기본값
+        long[][] A = {{1, 1}, {1, 0}};
+
+        // 행렬 거듭제곱으로 Fn 구하기
+        long[][] result = power(A, n);
+
+        // M^n의 [0][1] 성분이 F_n임
+        System.out.println(result[0][1] % MOD);
+    }
+
+    // 분할 정복을 이용한 거듭제곱 (O(logN))
+    private static long[][] power(long[][] A, long n) {
+        // 지수가 1이면 자기 자신 반환 (Base Case)
+        if (n == 1) {
+            // 반환할 때도 모듈러 연산 안전하게 한 번 해줌
+            return new long[][] {
+                {A[0][0] % MOD, A[0][1] % MOD},
+                {A[1][0] % MOD, A[1][1] % MOD}
+            };
+        }
+
+        // 1. 반으로 쪼개서 구함 (Divide)
+        long[][] half = power(A, n / 2);
+
+        // 2. 구한 것을 제곱함 (Conquer)
+        long[][] result = multiply(half, half);
+
+        // 3. 홀수라면 A를 한 번 더 곱해줌
+        if (n % 2 == 1) {
+            result = multiply(result, A);
+        }
+
+        return result;
+    }
+
+    // 행렬 곱셈 함수 (나머지 연산 포함)
+    private static long[][] multiply(long[][] o1, long[][] o2) {
+        long[][] ret = new long[2][2];
+
+        // 2x2 행렬 곱셈 공식 + 모듈러 연산
+        ret[0][0] = (o1[0][0] * o2[0][0] + o1[0][1] * o2[1][0]) % MOD;
+        ret[0][1] = (o1[0][0] * o2[0][1] + o1[0][1] * o2[1][1]) % MOD;
+        ret[1][0] = (o1[1][0] * o2[0][0] + o1[1][1] * o2[1][0]) % MOD;
+        ret[1][1] = (o1[1][0] * o2[0][1] + o1[1][1] * o2[1][1]) % MOD;
+
+        return ret;
+    }
+}

그래프/P1325_효율적인해킹.java

@@ -1,59 +1,59 @@
 import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.IOException;
 import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.Queue;
-import java.util.StringTokenizer;
+import java.util.*;
 public class P1325_효율적인해킹 {
-  static int N, M;
-  static boolean visited[];
-  static int answer[];
-  static ArrayList<Integer> A[];
-  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());
-    A = new ArrayList[N + 1];
-    answer = new int[N + 1];
-    for (int i = 1; i <= N; i++)
-      A[i] = new ArrayList<>();
-    for (int i = 0; i < M; i++) {
-      st = new StringTokenizer(br.readLine());
-      int S = Integer.parseInt(st.nextToken());
-      int E = Integer.parseInt(st.nextToken());
-      A[S].add(E);
-    }
-    for (int i = 1; i <= N; i++) { //모든 정점에 대하여 BFS 실행
-      visited = new boolean[N + 1];
-      BFS(i);
-    }
-    int maxVal = 0;
-    for (int i = 1; i <= N; i++) {
-      maxVal = Math.max(maxVal, answer[i]);
-    }
-    for (int i = 1; i <= N; i++) {
-      if (answer[i] == maxVal) //answer배열에서 maxVal와 같은 값을 가진 index를 정답으로 출력
-        System.out.print(i + " ");
+    static boolean visited[]  = new boolean[10001];;
+    static int answer[] = new int[10001];;
+    static ArrayList<Integer> A[] = new ArrayList[10001];;
+
+    static Queue<Integer> queue = new ArrayDeque<Integer>();
+    public static void main(String[] args) throws Exception {
+        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());
+
+        for (int i = 1; i <= N; i++)
+            A[i] = new ArrayList<>();
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int S = Integer.parseInt(st.nextToken());
+            int E = Integer.parseInt(st.nextToken());
+            A[S].add(E);
+        }
+        for (int i = 1; i <= N; i++) { //모든 정점에 대하여 BFS 실행
+            for (int j = 1; j <= N; j++) {
+                visited[j] = false;
+            }
+
+            BFS(i);
+        }
+
+        int maxVal = 0;
+        for (int i = 1; i <= N; i++) {
+            if (maxVal < answer[i]) {
+                maxVal = answer[i];
+            }
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 1; i <= N; i++) {
+            if (answer[i] == maxVal) //answer배열에서 maxVal와 같은 값을 가진 index를 정답으로 출력
+                sb.append(i).append(" ");
+        }
+        System.out.println(sb);
     }
-  }
-  public static void BFS(int index) {
-    Queue<Integer> queue = new LinkedList<Integer>();
-    queue.add(index);
-    visited[index] = true;
-    while (!queue.isEmpty()) {
-      int now_node = queue.poll();
-      for (int i : A[now_node]) {
-        if (visited[i] == false) {
-          visited[i] = true;
-          answer[i]++; //신규 정점인덱스의 정답 배열 값을 증가 시키기  
-          queue.add(i);
+    public static void BFS(int index) {
+        queue.add(index);
+        visited[index] = true;
+        while (!queue.isEmpty()) {
+            int now_node = queue.poll();
+            for (int i : A[now_node]) {
+                if (visited[i]) continue;
+                visited[i] = true;
+                answer[i]++; //신규 정점인덱스의 정답 배열 값을 증가 시키기
+                queue.add(i);
+            }
         }
-      }
     }
-  }
-}
+}

그래프/P1916_최소비용구하기.java

@@ -6,70 +6,88 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 import java.util.StringTokenizer;
-public class P1916_최소비용구하기 {
-  static int N, M;
-  static ArrayList<Node_1916>[] list; // 인접리스트로 그래프 표현하기.
-  static int[] dist; // 최단거리 배열.
-  static boolean[] visit; // 사용노드인지 확인하는 배열.
-  public static void main(String[] args) throws Exception {
-    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
-    StringTokenizer st;
-    N = Integer.parseInt(br.readLine());
-    M = Integer.parseInt(br.readLine());
-    list = new ArrayList[N + 1];
-    dist = new int[N + 1];
-    visit = new boolean[N + 1];
-    Arrays.fill(dist, Integer.MAX_VALUE);
-    for (int i = 0; i <= N; i++) {
-      list[i] = new ArrayList<Node_1916>();
+
+class node implements Comparable<node> {
+    int targetNode;
+    int value;
+
+    node(int targetNode, int value) {
+        this.targetNode = targetNode;
+        this.value = value;
     }
-    for (int i = 0; i < M; i++) { // 주어진 그래프의 간선들을 인접리스트 자료구조에 넣는 부분
-      st = new StringTokenizer(br.readLine());
-      int start = Integer.parseInt(st.nextToken());
-      int end = Integer.parseInt(st.nextToken());
-      int weight = Integer.parseInt(st.nextToken());
-      list[start].add(new Node_1916(end, weight));
+
+    @Override
+    public int compareTo(node o) {
+        return value - o.value;
     }
-    st = new StringTokenizer(br.readLine());
-    int startIndex = Integer.parseInt(st.nextToken());
-    int endIndex = Integer.parseInt(st.nextToken());
-    // 다익스트라 알고리즘 수행
-    bw.write(dijkstra(startIndex, endIndex) + "\n");
-    bw.flush();
-    bw.close();
-    br.close();
-  }
-  public static int dijkstra(int start, int end) {   // 다익스트라 알고리즘
-    PriorityQueue<Node_1916> pq = new PriorityQueue<>();
-    pq.offer(new Node_1916(start, 0));
-    dist[start] = 0;
-    while (!pq.isEmpty()) {
-      Node_1916 nowNode_1916 = pq.poll();
-      int now = nowNode_1916.targetNode_1916;
-      if (!visit[now]) {
-        visit[now] = true;
-        for (Node_1916 n : list[now]) { // 선택노드 + 비용 < 타켓노드인 경우 값을 갱신하는 부분
-          if (!visit[n.targetNode_1916] && dist[n.targetNode_1916] > dist[now] + n.value) {
-            dist[n.targetNode_1916] = dist[now] + n.value;
-            pq.add(new Node_1916(n.targetNode_1916, dist[n.targetNode_1916]));
-          }
+
+}
+
+public class P1916_최소비용구하기 {
+    static int N, M;
+    static ArrayList<node>[] list; // 인접리스트로 그래프 표현하기.
+    static int[] dist; // 최단거리 배열.
+    static boolean[] check; // 사용노드인지 확인하는 배열.
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        StringTokenizer st;
+        N = Integer.parseInt(br.readLine());
+        M = Integer.parseInt(br.readLine());
+
+        list = new ArrayList[N+1];
+        dist = new int[N + 1];
+        check = new boolean[N + 1];
+
+        Arrays.fill(dist, Integer.MAX_VALUE);
+
+        for (int i = 0; i <= N; i++) {
+        	list[i] = new ArrayList<node>();
+        }
+
+        // 주어진 그래프의 간선들을 인접리스트 자료구조에 넣는 부분
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int start = Integer.parseInt(st.nextToken());
+            int end = Integer.parseInt(st.nextToken());
+            int weight = Integer.parseInt(st.nextToken());
+
+            list[start].add(new node(end, weight));
         }
-      }
+
+        st = new StringTokenizer(br.readLine());
+        int startIndex = Integer.parseInt(st.nextToken());
+        int endIndex = Integer.parseInt(st.nextToken());
+
+        //다익스트라 알고리즘 수행 
+        bw.write(dijkstra(startIndex, endIndex) + "\n");
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+    // 다익스트라 알고리즘
+    public static int dijkstra(int start, int end) {
+        PriorityQueue<node> pq = new PriorityQueue<>();
+        boolean[] check = new boolean[N + 1];
+        pq.offer(new node(start, 0));
+        dist[start] = 0;
+
+        while (!pq.isEmpty()) {
+        	node nowNode = pq.poll();
+            int now = nowNode.targetNode;
+
+            if (!check[now]) {
+                check[now] = true;
+                for (node n : list[now]) {  //선택노드 + 가중치 < 타켓노드인 경우 값을 갱신하는 부분
+                    if (dist[n.targetNode] > dist[now] + n.value) {
+                        dist[n.targetNode] = dist[now] + n.value;
+                        pq.add(new node(n.targetNode, dist[n.targetNode]));
+                    }
+                }
+            }
+        }
+        return dist[end];
     }
-    return dist[end];
-  }
-}
-class Node_1916 implements Comparable<Node_1916> {
-  int targetNode_1916;
-  int value;
-
-  Node_1916(int targetNode_1916, int value) {
-    this.targetNode_1916 = targetNode_1916;
-    this.value = value;
-  }
-  @Override
-  public int compareTo(Node_1916 o) {
-    return value - o.value;
-  }
 }

동적계획법/P13398_연속된정수의합.java → 동적계획법/P13398_연속합2.java

@@ -1,7 +1,7 @@
 import java.io.*;
 import java.util.StringTokenizer;
 
-public class P13398_연속된정수의합 {
+public class P13398_연속합2 {
   public static void main(String[] args) throws IOException {
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
@@ -36,3 +36,4 @@ public static void main(String[] args) throws IOException {
     br.close();
   }
 }
+

동적계획법/P2098_외판원순회.java

@@ -2,41 +2,38 @@
 import java.io.InputStreamReader;
 import java.util.StringTokenizer;
 class P2098_외판원순회 {
-    private static final int INF = 1000000*16+1;
     private static int N;
     private static int[][] W;
     private static int[][] d;
+    private static final int INF = 1000000*16+1;
     public static void main(String[] args) throws Exception {
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = null;
         N = Integer.parseInt(br.readLine().trim());
         W = new int[16][16];
+        d = new int[16][1 << 16];
         for (int i = 0; i < N; i++) {
             st = new StringTokenizer(br.readLine().trim());
             for (int j = 0; j < N; j++) {
                 W[i][j] = Integer.parseInt(st.nextToken());
             }
         }
-        d = new int[16][1 << 16];
-        for (int i = 0; i < N; i++) {
-            for (int j = 0; j < 1 << N; j++) {
-                d[i][j] = INF; //모든 비용을 충분히 큰수로 저장
-            }
-        }
         System.out.println(tsp(0, 1));
     }
     private static int tsp(int c, int v) { //모든 경우의 수에 대한 완전 탐색, 재귀 구현
         if (v == (1 << N) - 1) {    // 모든 노드를 방문한 경우
             return W[c][0] == 0 ? INF : W[c][0];
         }
-        if (d[c][v] != INF) {  //이미 방문한 노드인 경우 -> 이미 계산한 경우 바로 리턴 (메모이제이션)
+        if (d[c][v] != 0) {  //이미 방문한 노드인 경우 -> 이미 계산한 경우 바로 리턴 (메모이제이션)
             return d[c][v];
         }
+        int min_val = INF;
         for (int i = 0; i < N; i++) {
             if ((v & (1 << i)) == 0 && W[c][i] != 0) {   //방문한적이 없고 갈 수 있는 도시인 경우
-                d[c][v] = Math.min(d[c][v], tsp(i, (v | (1 << i))) + W[c][i]);
+                min_val = Math.min(min_val, tsp(i, (v | (1 << i))) + W[c][i]);
             }
         }
+        d[c][v] = min_val;
         return d[c][v];
     }
-}
+}