Merge remote-tracking branch 'origin/main' into jiyoung1814/algorithm

Author: jiyoung1814

ahma0/BOJ_1389.java

@@ -0,0 +1,72 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+
+    private static int[][] arr;
+    private static int min = Integer.MAX_VALUE, ans = -1;
+
+    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());
+
+        arr = new int[N + 1][N + 1];
+
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+
+            int a = Integer.parseInt(st.nextToken());
+            int b = Integer.parseInt(st.nextToken());
+
+            arr[a][b] = arr[b][a] = 1;
+        }
+
+        for (int i = 1; i <= N; i++) {
+            bfs(i);
+        }
+
+        System.out.println(ans);
+        br.close();
+    }
+
+    private static void bfs(int index) {
+        Queue<Node> q = new LinkedList<>();
+        boolean[] visited = new boolean[arr.length];
+        q.add(new Node(index, 0));
+        visited[index] = true;
+
+        int res = 0;
+
+        while (!q.isEmpty()) {
+            Node now = q.poll();
+
+            for (int i = 1; i < arr.length; i++) {
+                if (!visited[i] && arr[now.index][i] == 1) {
+                    q.add(new Node(i, now.count + 1));
+                    visited[i] = true;
+                    res += now.count + 1;
+                }
+            }
+        }
+
+        if (res < min) {
+            min = res;
+            ans = index;
+        }
+    }
+
+    static class Node {
+        int index;
+        int count;
+
+        public Node(int index, int count) {
+            this.index = index;
+            this.count = count;
+        }
+    }
+}

ahma0/BOJ_16395.java

@@ -0,0 +1,28 @@
+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));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        int n = Integer.parseInt(st.nextToken());
+        int k = Integer.parseInt(st.nextToken());
+
+        int[][] arr = new int[n + 1][n + 1];
+        arr[1][1] = 1;
+        for (int i = 2; i <= n; i++) {
+            for (int j = 1; j <= i; j++) {
+                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
+            }
+        }
+
+        bw.write(arr[n][k] + "");
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+}

ahma0/BOJ_28278.java

@@ -0,0 +1,43 @@
+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));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        StringTokenizer st;
+        int n = Integer.parseInt(br.readLine());
+
+        Deque<Integer> stack = new ArrayDeque<>();
+
+        for (int i = 0; i < n; i++) {
+            st = new StringTokenizer(br.readLine());
+
+            int t = Integer.parseInt(st.nextToken());
+
+            switch (t) {
+                case 1:
+                    stack.push(Integer.parseInt(st.nextToken()));
+                    break;
+                case 2:
+                    bw.write((stack.isEmpty() ? -1 : stack.pop()) + "\n");
+                    break;
+                case 3:
+                    bw.write(stack.size() + "\n");
+                    break;
+                case 4:
+                    bw.write((stack.isEmpty() ? 1 : 0) + "\n");
+                    break;
+                case 5:
+                    bw.write((stack.isEmpty() ? -1 : stack.peek()) + "\n");
+                    break;
+            }
+        }
+
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+}

chaeryeon823/BOJ_1012.js

@@ -0,0 +1,64 @@
+// 유기농 배추
+// S2
+// 그래프, DFS
+
+const readline = require("readline");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const input = [];
+rl.on("line", (line) => {
+  input.push(line.trim());
+}).on("close", () => {
+  let index = 0;
+  const T = parseInt(input[index++]);
+
+  for (let t = 0; t < T; t++) {
+    const [W, H, K] = input[index++].split(" ").map(Number);
+    let graph = Array.from({ length: W }, () => Array(H).fill(0));
+    let visited = Array.from({ length: W }, () => Array(H).fill(0));
+    let answer = 0;
+
+    // 배추 위치 설정
+    for (let i = 0; i < K; i++) {
+      const [x, y] = input[index++].split(" ").map(Number);
+      graph[x][y] = 1;
+    }
+
+    // DFS 수행
+    const dfs = (nowX, nowY) => {
+      visited[nowX][nowY] = 1;
+      const directions = [
+        [-1, 0],
+        [1, 0],
+        [0, -1],
+        [0, 1],
+      ]; // 상하좌우
+
+      for (const [dx, dy] of directions) {
+        const nextX = nowX + dx;
+        const nextY = nowY + dy;
+
+        if (nextX >= 0 && nextX < W && nextY >= 0 && nextY < H) {
+          if (graph[nextX][nextY] === 1 && visited[nextX][nextY] === 0) {
+            dfs(nextX, nextY);
+          }
+        }
+      }
+    };
+
+    // 모든 좌표 순회
+    for (let x = 0; x < W; x++) {
+      for (let y = 0; y < H; y++) {
+        if (graph[x][y] === 1 && !visited[x][y]) {
+          dfs(x, y);
+          answer++;
+        }
+      }
+    }
+    console.log(answer);
+  }
+});

chaeryeon823/BOJ_9623.js

@@ -0,0 +1,39 @@
+// BABBA
+// S5
+
+const readline = require("readline");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const cnt = new Array(46).fill(0);
+
+function fn(n) {
+  if (cnt[n] === 0) {
+    if (n <= 2) {
+      cnt[n] = 1;
+    } else {
+      cnt[n] = fn(n - 1) + fn(n - 2);
+    }
+  }
+  return cnt[n];
+}
+
+rl.question("", (num) => {
+  num = parseInt(num);
+  let a = 0;
+  let b = 0;
+
+  if (num === 1) {
+    a = 0;
+    b = 1;
+  } else {
+    a = fn(num - 1);
+    b = fn(num);
+  }
+
+  console.log(`${a} ${b}`);
+  rl.close();
+});

chaeryeon823/PGS_138476.py

@@ -0,0 +1,17 @@
+# 귤 고르기
+# Lv 2
+
+from collections import Counter
+
+def solution(k, tangerine):
+    answer = 0
+    cnt = sorted(Counter(tangerine).values(), reverse=True)
+    tmp = 0
+    for c in cnt:
+        if tmp < k:
+            tmp += c
+            answer += 1
+        else:
+            break
+    
+    return answer

hh830/BOJ_11055.java

@@ -0,0 +1,36 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(bufferedReader.readLine());
+
+        int dp[] = new int[N];
+        int arr[] = new int[N];
+
+        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
+
+        for(int i=0;i<N;i++){
+            arr[i] = Integer.parseInt(stringTokenizer.nextToken());
+            dp[i] = arr[i];
+        }
+        
+        for (int i=1;i<N;i++) {
+            for (int j=0;j<i;j++) {
+                if (arr[i] > arr[j]) {
+                    dp[i] = Math.max(dp[i], dp[j] + arr[i]);
+                }
+            }
+        }
+
+        int max = 0;
+        for (int i=0;i<N;i++) {
+            if (dp[i] > max) {
+                max = dp[i];
+            }
+        }
+
+        System.out.println(max);
+    }
+}

hh830/BOJ_2193.java

@@ -0,0 +1,23 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(bufferedReader.readLine());
+
+        long dp[] = new long[N];
+
+        dp[0] = 1;
+
+        if(N >= 2) {
+            dp[1] = 1;
+        }
+
+        for (int i = 2; i < N; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+
+        System.out.println(dp[N-1]);
+    }
+}

hh830/BOJ_2468.java

@@ -0,0 +1,59 @@
+import java.io.*;
+import java.util.*;
+
+public class BOJ_2468 {
+    static int n;
+    static int[][] map;
+    static boolean[][] visited;
+    static int[] dx = {-1, 1, 0, 0};
+    static int[] dy = {0, 0, -1, 1};
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
+        n = Integer.parseInt(bufferedReader.readLine());
+        map = new int[n][n];
+
+        int max = 0;
+        int result = 0;
+
+        for (int i = 0; i < n; i++) {
+            StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
+            for (int j = 0; j < n; j++) {
+                map[i][j] = Integer.parseInt(stringTokenizer.nextToken());
+                max = Math.max(max, map[i][j]);
+            }
+        }
+
+        for (int h = 0; h <= max; h++) {
+            visited = new boolean[n][n];
+            int count = 0;
+
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (!visited[i][j] && map[i][j] > h) {
+                        dfs(i, j, h);
+                        count++;
+                    }
+                }
+            }
+            result = Math.max(result, count);
+        }
+
+        System.out.println(result);
+    }
+
+    static void dfs(int x, int y, int height) {
+        visited[x][y] = true;
+
+        for (int i = 0; i < 4; i++) {
+            int nx = x + dx[i];
+            int ny = y + dy[i];
+
+            if (nx >= 0 && ny >= 0 && nx < n && ny < n) {
+                if (!visited[nx][ny] && map[nx][ny] > height) {
+                    dfs(nx, ny, height);
+                }
+            }
+        }
+    }
+}