[DFS, BFS] 10월 11일

08_DFS_BFS/1325.cpp

@@ -0,0 +1,67 @@
+#include <iostream>
+#include <vector>
+#include <stack>
+#include <algorithm>
+
+using namespace std;
+
+vector<vector<int>> adj_list;
+vector<bool> visited;
+int n;
+
+int dfs(int start) {
+    stack<int> s;
+    s.push(start);
+    visited[start] = true;
+    int nodes_visited = 1;
+
+    while (!s.empty())  {
+        int node = s.top();
+        s.pop();
+
+        for (int neighbor : adj_list[node]) {
+            if (!visited[neighbor]) {
+                s.push(neighbor);
+                visited[neighbor] = true;
+                nodes_visited++;
+            }
+        }
+    }
+
+    return nodes_visited;
+}
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+
+    int m;
+    cin >> n >> m;
+    adj_list.resize(n + 1);
+    visited.assign(n + 1, false);
+
+    while (m--) {
+        int a, b;
+        cin >> a >> b;
+        adj_list[b].push_back(a);  // 역방향 그래프를 만듭니다.
+    }
+
+    vector<int> result(n + 1, 0);
+
+    for (int v = 1; v <= n; v++) {
+        fill(visited.begin(), visited.end(), false);  // visited 배열 초기화
+        int nodes_visited = dfs(v);
+        result[v] = nodes_visited;
+    }
+
+    int max_hacked = *max_element(result.begin(), result.end());
+
+    for (int i = 1; i <= n; i++) {
+        if (result[i] == max_hacked) {
+            cout << i << " ";
+        }
+    }
+
+    return 0;
+}

08_DFS_BFS/19538.cpp

@@ -0,0 +1,75 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static int[] solution(int N, int[][] adj, int M, int[] firstInfected) {
+        Queue<Integer> Q = new ArrayDeque<>(); // 감염된 사람의 번호를 큐에 저장할 것이다.
+        int[] answer = new int[N + 1]; // solution 함수에서 리턴할 배열
+        Arrays.fill(answer, -1); // 사이즈 N+1, -1로 초기화
+        int[] turn = new int[N + 1]; // 감염까지 남은 주변 비감염 사람 수
+        Arrays.fill(turn, 0); // 사이즈 N+1, 0로 초기화
+
+        // 최조생성자 처리
+        for (int t : firstInfected) {
+            Q.add(t); // 최조생성자는 감염된 사람이고 주변인에게 영향을 주므로 큐에 넣어주고
+            answer[t] = 0; // 0분에 감염되었음을 저장한다.
+        }
+
+        // 주변인의 절반 이상이 루머를 믿을 때 본인도 루머를 믿으므로
+        // 몇 명이 감염되었을 때 자신이 감염되는지에 대한 정보를
+        // 사람 i의 주변인물 수 + 1 / 2의 몫으로 저장해둔다.
+        // 사람의 번호가 아닌 입력의 끝을 말하는 0이 adj 배열에 포함되어 있으므로 + 1은 안해도 된다.
+        for (int i = 1; i <= N; i++)
+            turn[i] = adj[i].length / 2;
+
+        while (!Q.isEmpty()) { // 큐가 빌 때까지 탐색하는데, 큐가 비었다면 모든 탐색을 마쳤다는 의미이다.
+            int current = Q.poll(); // 현재, 가장 먼저 감염된 사람의 
+
+            for (Integer next : adj[current]) { // 주변인물들에게
+                if (next == 0) break;
+                turn[next] -= 1; // 자신(주변인물)이 감염되기까지 남은 사람 수를 1 빼고
+                if (answer[next] == -1 && turn[next] <= 0) { // 만약 아직 감염되지 않았고 주변인의 반 이상이 감염되었다면
+                    Q.add(next); // 감염되었기에 큐에 자신의 번호를 넣어주고
+                    answer[next] = answer[current] + 1; // 자신을 감염시킨 마지막 주변인의 감염된 시간 + 1분을 더해 저장한다.
+                }
+            }
+        }
+
+        // 계산의 편의를 위해 배열에 0번 index가 아닌 1번 index부터 정답이 저장되었으므로,
+        // 배열을 두번째 원소부터 잘라 반환한다.
+        return Arrays.copyOfRange(answer, 1, answer.length);
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        StringBuilder sb = new StringBuilder();
+
+        int N = Integer.parseInt(br.readLine());
+        int[][] adj = new int[N+1][];
+        adj[0] = new int[]{0};
+        for (int i = 1; i <= N; i++) {
+            st = new StringTokenizer(br.readLine());
+            List<Integer> arrayList = new ArrayList<>();
+            while (true) {
+                int temp = Integer.parseInt(st.nextToken());
+                arrayList.add(temp);
+                if (temp == 0) {
+                    adj[i] = arrayList.stream().mapToInt(Integer::intValue).toArray();
+                    break;
+                }
+            }
+        }
+
+        int M = Integer.parseInt(br.readLine());
+        int[] firstInfected = new int[M];
+        st = new StringTokenizer(br.readLine());
+        for (int i = 0; i < M; i++) {
+            int temp = Integer.parseInt(st.nextToken());
+            firstInfected[i] = temp;
+        }
+        Arrays.stream(solution(N, adj, M, firstInfected)).forEach(t -> sb.append(t).append(" "));
+        System.out.println(sb);
+    }
+}

08_DFS_BFS/2615.java

@@ -0,0 +1,55 @@
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        int[][] graph = new int[19][19];
+        int[] dx = {0, 1, 1, -1};
+        int[] dy = {1, 0, 1, 1};
+
+        for (int i = 0; i < 19; i++) {
+            for (int j = 0; j < 19; j++) {
+                graph[i][j] = sc.nextInt();
+            }
+        }
+
+        for (int i = 0; i < 19; i++) {
+            for (int j = 0; j < 19; j++) {
+                if (graph[i][j] != 0) {
+                    int target = graph[i][j];
+
+                    for (int k = 0; k < 4; k++) {
+                        int cnt = 1;
+                        int nx = i + dx[k];
+                        int ny = j + dy[k];
+
+                        while (0 <= nx && nx < 19 && 0 <= ny && ny < 19 && graph[nx][ny] == target) {
+                            cnt++;
+
+                            if (cnt == 5) {
+                                if (0 <= i - dx[k] && i - dx[k] < 19 && 0 <= j - dy[k] && j - dy[k] < 19 &&
+                                        graph[i - dx[k]][j - dy[k]] == target) {
+                                    break;
+                                }
+                                if (0 <= nx + dx[k] && nx + dx[k] < 19 && 0 <= ny + dy[k] && ny + dy[k] < 19 &&
+                                        graph[nx + dx[k]][ny + dy[k]] == target) {
+                                    break;
+                                }
+
+                                System.out.println(target);
+                                System.out.println(i + 1 + " " + (j + 1));
+                                System.exit(0);
+                            }
+
+                            nx += dx[k];
+                            ny += dy[k];
+                        }
+                    }
+                }
+            }
+        }
+
+        System.out.println(0);
+    }
+}

08_DFS_BFS/4963.java

@@ -0,0 +1,60 @@
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+public class Main {
+    public static void bfs(int x, int y, int[][] field) {
+        int[] dx = {1, -1, 0, 0, 1, -1, 1, -1};
+        int[] dy = {0, 0, -1, 1, -1, 1, 1, -1};
+        field[x][y] = 0;
+        Queue<int[]> q = new LinkedList<>();
+        q.add(new int[]{x, y});
+
+        while (!q.isEmpty()) {
+            int[] current = q.poll();
+            int a = current[0];
+            int b = current[1];
+
+            for (int i = 0; i < 8; i++) {
+                int nx = a + dx[i];
+                int ny = b + dy[i];
+                if (0 <= nx && nx < field.length && 0 <= ny && ny < field[0].length && field[nx][ny] == 1) {
+                    field[nx][ny] = 0;
+                    q.add(new int[]{nx, ny});
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        while (true) {
+            int w = scanner.nextInt();
+            int h = scanner.nextInt();
+            if (w == 0 && h == 0) {
+                break;
+            }
+
+            int[][] field = new int[h][w];
+            int count = 0;
+
+            for (int i = 0; i < h; i++) {
+                for (int j = 0; j < w; j++) {
+                    field[i][j] = scanner.nextInt();
+                }
+            }
+
+            for (int i = 0; i < h; i++) {
+                for (int j = 0; j < w; j++) {
+                    if (field[i][j] == 1) {
+                        bfs(i, j, field);
+                        count++;
+                    }
+                }
+            }
+
+            System.out.println(count);
+        }
+    }
+}

08_DFS_BFS/게임맵최단거리.cpp

@@ -0,0 +1,55 @@
+#include <vector>
+#include <queue>
+using namespace std;
+
+struct Pos {
+    int x;
+    int y;
+    Pos(int _y, int _x) : y(_y), x(_x) {}
+};
+
+int solution(vector<vector<int> > maps) {
+    const int n = maps.size(); // 행의 개수
+    const int m = maps[0].size(); // 열의 개수
+    // 방향 (상, 우, 하, 좌)
+    int deltaY[4] = { -1, 0, 1, 0 };
+    int deltaX[4] = { 0, 1, 0, -1 };
+
+    vector<vector<int>> dist(n, vector<int>(m, -1)); // 출발지로부터 해당 위치까지의 최단 거리
+    queue<Pos> q; // 큐
+
+    // 출발지는 예약 작업을 할 수 없고 바로 방문해야 하니 미리 작업
+    q.push(Pos(0, 0));  // 큐에 출발지 좌표를 넣어 시작
+    dist[0][0] = 1; // 출발지의 거리는 1
+
+    while (!q.empty()) {
+        // 방문할 위치를 큐에서 꺼냄
+        Pos pos = q.front();
+        q.pop();
+        int nowY = pos.y;
+        int nowX = pos.x;
+
+        // 상, 우, 하, 좌 방향을 탐색
+        for (int i = 0; i < 4; ++i) {
+            int nextY = nowY + deltaY[i];
+            int nextX = nowX + deltaX[i];
+
+            // 다음에 방문할 수 있는지 체크
+            if (nextY < 0 || nextY >= n || nextX < 0 || nextX >= m) // 맵을 벗어난다면 예약할 수 없는 방향
+                continue;
+            if (maps[nextY][nextX] == 0) // 벽이라면 예약할 수 없는 방향
+                continue;
+            if (dist[nextY][nextX] != -1) // 이미 최단거리가 업데이트되었다면 스킵
+                continue;
+
+            // 다음에 방문할 수 있는 곳이니 큐에 넣어 예약하고, 그와 동시에 최단거리 업데이트
+            q.push(Pos(nextY, nextX));
+            dist[nextY][nextX] = dist[nowY][nowX] + 1; // 최단 거리 업데이트 (방문 노드에서 +1 하면 최단 거리)
+        }
+    }
+
+    if (dist[n - 1][m - 1] == -1) // 도착지까지 도달할 수 없는 경우
+        return -1;
+    else
+        return dist[n - 1][m - 1]; // 도착지의 최단거리 리턴
+}

end

@@ -0,0 +1,56 @@
+commit c75e1fae1ade668b71a93161c3a7df4b882d3ed9 (HEAD -> 08_DFS_BFS, origin/main, origin/HEAD, main)
+Merge: 1ab1b97 04b70a4
+Author: somsom <72211340+kimeunsom@users.noreply.github.com>
+Date:   Tue Sep 19 14:38:50 2023 +0900
+
+    Merge pull request #3 from Altu-Bitu-5/04_브루트포스
+
+    [브루트포스] 9월 19일
+
+commit 04b70a4979c90ba8f96bcb902419e644b855a832 (origin/04_브루트포스)
+Author: unknown <somi5488@naver.com>
+Date:   Tue Sep 19 01:37:49 2023 +0900
+
+    [브루트포스] 9월 18일
+
+commit 637350e790803c319294f7b8fe9cf84e01df6340
+Author: unknown <somi5488@naver.com>
+Date:   Wed Sep 13 18:51:29 2023 +0900
+
+    [브루트포스] 9월 13일
+
+commit 46dd74773d131d58d33164c9d36b9d7a0bf2e838 (origin/03_정수론)
+Author: unknown <somi5488@naver.com>
+Date:   Wed Sep 6 18:35:34 2023 +0900
+
+    [정수론] 9월 6일
+
+commit 0a50faf95aa260e4435bb37b9c41dd7652b25e82
+Author: unknown <somi5488@naver.com>
+Date:   Wed Sep 6 16:23:30 2023 +0900
+
+    [정수론] 9월 6일
+
+commit 050c8cffe428a01cf15880c3c17e3ffeb0d157fe (origin/01_정렬_맵_셋)
+Author: unknown <somi5488@naver.com>
+Date:   Thu Aug 24 21:26:43 2023 +0900
+
+    [정렬, 맵, 셋] 8월 24일
+
+commit 10fc0751b32a2f2a655033b37547b798e51ecdbe
+Author: unknown <somi5488@naver.com>
+Date:   Wed Aug 23 11:37:08 2023 +0900
+
+    [정렬, 맵, 셋] 8월 23일
+
+commit 6556d47ec0d698163ec2c9aa4932a56d0a4b1690
+Author: unknown <somi5488@naver.com>
+Date:   Wed Aug 23 11:27:10 2023 +0900
+
+    [정렬, 맵, 셋] 8월 23일
+
+commit 1ab1b97a09888af0e348e3d3fa6bb612f59855bc
+Author: somsom <72211340+kimeunsom@users.noreply.github.com>
+Date:   Tue Aug 22 19:11:09 2023 +0900
+
+    Initial commit