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

Author: jiyoung1814

ahma0/BOJ_1789.java

@@ -0,0 +1,28 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        BigInteger n = new BigInteger(br.readLine());
+        BigInteger answer = BigInteger.ZERO;
+        BigInteger one = BigInteger.ONE;
+
+        while (true) {
+            if (n.compareTo(answer) < 0) {
+                answer = answer.subtract(one);
+                break;
+            }
+            n = n.subtract(answer);
+            answer = answer.add(one);
+        }
+
+        System.out.println(answer);
+        br.close();
+    }
+
+}

ahma0/BOJ_2583.java

@@ -0,0 +1,88 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+
+    private static int N, M, K;
+    private static int[] dx = {0, 0, 1, -1};
+    private static int[] dy = {1, -1, 0, 0};
+    private static boolean[][] visited;
+    private static int[][] arr;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        M = Integer.parseInt(st.nextToken());
+        N = Integer.parseInt(st.nextToken());
+        K = Integer.parseInt(st.nextToken());
+
+        arr = new int[M][N];
+        visited = new boolean[M][N];
+
+        for (int i = 0; i < K; i++) {
+            st = new StringTokenizer(br.readLine());
+
+            int x1 = Integer.parseInt(st.nextToken());
+            int y1 = Integer.parseInt(st.nextToken());
+            int x2 = Integer.parseInt(st.nextToken());
+            int y2 = Integer.parseInt(st.nextToken());
+
+            for (int y = y1; y < y2; y++) {
+                for (int x = x1; x < x2; x++) {
+                    arr[y][x] = 1;
+                }
+            }
+
+        }
+
+        List<Integer> answer = new ArrayList<>();
+        for (int i = 0; i < M; i++) {
+            for (int j = 0; j < N; j++) {
+                if (!visited[i][j] && arr[i][j] == 0) {
+                    answer.add(bfs(i, j));
+                }
+            }
+        }
+        Collections.sort(answer);
+
+        System.out.println(answer.size());
+        for (int i : answer) {
+            System.out.print(i + " ");
+        }
+        br.close();
+    }
+
+    private static int bfs(int x, int y) {
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[]{x, y});
+        visited[x][y] = true;
+
+        int count = 1;
+        while (!queue.isEmpty()) {
+            int[] cur = queue.poll();
+
+            for (int i = 0; i < 4; i++) {
+                int newX = cur[0] + dx[i];
+                int newY = cur[1] + dy[i];
+
+                if (newX < 0 || newY < 0 || newX >= M || newY >= N) {
+                    continue;
+                }
+
+                if (visited[newX][newY] || arr[newX][newY] == 1) {
+                    continue;
+                }
+
+                queue.offer(new int[]{newX, newY});
+                visited[newX][newY] = true;
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+}

chaeryeon823/BOJ_2606.js

@@ -0,0 +1,38 @@
+// 바이러스
+// S3
+const fs = require("fs");
+const input = fs.readFileSync(0, "utf-8").trim().split("\n");
+
+// 컴퓨터 수 (노드 수)
+const N = parseInt(input[0]);
+// 연결 수 (간선 수)
+const M = parseInt(input[1]);
+
+let answer = 0;
+const graph = Array.from({ length: N + 1 }, () => []);
+const visited = new Array(N + 1).fill(false);
+
+// 그래프 구성 (2번 줄부터 M+1번 줄까지)
+for (let i = 2; i < M + 2; i++) {
+  const [a, b] = input[i].split(" ").map(Number);
+  graph[a].push(b);
+  graph[b].push(a); // 양방향 연결
+}
+
+// DFS 함수
+function dfs(now) {
+  visited[now] = true;
+  answer++;
+
+  for (const node of graph[now]) {
+    if (!visited[node]) {
+      dfs(node);
+    }
+  }
+}
+
+// 1번 컴퓨터부터 시작
+dfs(1);
+
+// 1번 컴퓨터 제외하고 출력
+console.log(answer - 1);

chaeryeon823/PGS_42883.js

@@ -0,0 +1,18 @@
+// 큰 수 만들기
+// lv 2
+// 그리디
+// 스택
+
+function solution(number, k) {
+  const stack = [];
+
+  for (let digit of number) {
+    while (k > 0 && stack.length && stack[stack.length - 1] < digit) {
+      stack.pop();
+      k--;
+    }
+    stack.push(digit);
+  }
+
+  return stack.slice(0, stack.length - k).join("");
+}

chaeryeon823/PGS_84512.js

@@ -0,0 +1,14 @@
+// 모음 사전
+// lv 2
+// 완전탐색
+// 경우의 수
+
+function solution(word) {
+  let answer = 0;
+  let cnt = [781, 156, 31, 6, 1];
+  let arr = ["A", "E", "I", "O", "U"];
+  for (let i = 0; i < word.length; i++) {
+    answer += arr.indexOf(word[i]) * cnt[i] + 1;
+  }
+  return answer;
+}

hh830/BOJ_11725.java

@@ -0,0 +1,50 @@
+import java.io.*;
+import java.util.*;
+
+public class BOJ_11725 {
+    static ArrayList<Integer>[] tree;
+    static int[] parent;
+    static boolean[] visited;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int n = Integer.parseInt(br.readLine());
+
+        tree = new ArrayList[n + 1];
+        parent = new int[n + 1];
+        visited = new boolean[n + 1];
+
+        for (int i = 1; i <= n; i++) {
+            tree[i] = new ArrayList<>();
+        }
+        
+        for (int i = 0; i < n - 1; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int a = Integer.parseInt(st.nextToken());
+            int b = Integer.parseInt(st.nextToken());
+
+            tree[a].add(b);
+            tree[b].add(a);
+        }
+
+        dfs(1); // 루트 노드
+        
+        StringBuilder sb = new StringBuilder();
+        for (int i = 2; i <= n; i++) {
+            sb.append(parent[i]).append('\n');
+        }
+
+        System.out.print(sb);
+    }
+
+    static void dfs(int node) {
+        visited[node] = true;
+        for (int child : tree[node]) {
+            if (!visited[child]) {
+                parent[child] = node; 
+                dfs(child);
+            }
+        }
+    }
+}

hh830/BOJ_1541.java

@@ -0,0 +1,29 @@
+import java.io.*;
+import java.util.*;
+
+public class BOJ_1541 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
+
+        String arr[] = bufferedReader.readLine().split("-");
+        
+        int total=0;
+        
+        for(int i=0;i<arr.length;i++){
+            int sum = 0;
+            String arr2[] = arr[i].split("\\+");
+            
+            for(String num : arr2){
+                sum += Integer.parseInt(num);
+            }
+            
+            if(i==0){
+                total += sum;
+            } else{
+                total -= sum;
+            }
+        }
+
+        System.out.println(total);
+    }
+}

julia8024/PGS_42860.py

@@ -0,0 +1,23 @@
+# 프로그래머스
+# Lv2 조이스틱
+
+def solution(name):
+    
+    pos_a = ord('A')
+    pos_z = ord('Z')
+    
+    answer = float('inf')
+    
+    for i in range(len(name)//2 + 1):
+        l_r = name[-i:] + name[:-i] # 왼쪽 먼저 + 오른쪽
+        r_l = name[i::-1] + name[i+1:][::-1] # 기준점에서 뒤로 + 왼쪽
+        
+        for n in [l_r, r_l]:
+            # 끝의 A 자르기 (필요없음)
+            while n and n[-1] == 'A':
+                n = n[:-1]
+            
+            cnt = [min(ord(c) - pos_a, (pos_z + 1) - ord(c)) for c in n]
+            answer = min(answer, i + (len(cnt) -1) + sum(cnt))
+    
+    return answer

julia8024/PGS_87694.py

@@ -0,0 +1,42 @@
+# 프로그래머스
+# Lv3 아이템 줍기
+
+from collections import deque
+
+def solution(rectangle, characterX, characterY, itemX, itemY):
+    answer = 0
+    graph = [[-1 for _ in range(102)] for _ in range(102)]
+    visited = [[1 for _ in range(102)] for _ in range(102)]
+    direction = [(0, -1), (1, 0), (0, 1), (-1, 0)]
+    dq = deque()
+    
+    
+    # 테두리 =1, 내부 =0, 외부 =-1로 만들기
+    for r in rectangle:
+        x1, y1, x2, y2 = map(lambda x: x*2, r)
+        for i in range(x1, x2+1):
+            for j in range(y1, y2+1):
+                if x1 < i < x2 and y1 < j < y2:
+                    graph[i][j] = 0
+                # 다른 직사각형의 내부가 아니면서 테두리일 때 1로 채우기
+                elif graph[i][j] != 0:
+                    graph[i][j] = 1
+    
+    cx, cy, ix, iy = 2*characterX, 2*characterY, 2*itemX, 2*itemY
+    
+    dq.append((cx, cy))
+    
+    while dq:
+        x, y = dq.popleft()
+        
+        if x == ix and y == iy:
+            answer = visited[x][y] // 2
+            break
+        for k in range(4):
+            nx, ny = x + direction[k][0], y + direction[k][1]
+            
+            if graph[nx][ny] == 1 and visited[nx][ny] == 1:
+                visited[nx][ny] += visited[x][y]
+                dq.append((nx, ny))
+                
+    return answer

youbbin/PGS_42885.py

@@ -0,0 +1,15 @@
+def solution(people, limit):
+    people.sort()
+    answer = 0
+    a = 0
+    b = len(people) - 1
+
+    while a <= b:
+        if people[a] + people[b] > limit:
+            b -= 1
+        else:
+            a += 1
+            b -= 1
+        answer += 1
+
+    return answer