Update

Author: ndb796

12/7.cpp

@@ -0,0 +1 @@
+

13/1.cpp

@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 도시의 개수, 도로의 개수, 거리 정보, 출발 도시 번호
+int n, m, k, x;
+vector<int> graph[300001];
+// 모든 도시에 대한 최단 거리 초기화
+vector<int> d(300001, -1);
+
+int main(void) {
+    cin >> n >> m >> k >> x;
+
+    // 모든 도로 정보 입력 받기
+    for (int i = 0; i < m; i++) {
+        int a, b;
+        cin >> a >> b;
+        graph[a].push_back(b);
+    }
+
+    // 출발 도시까지의 거리는 0으로 설정
+    d[x] = 0;
+
+    // 너비 우선 탐색(BFS) 수행
+    queue<int> q;
+    q.push(x);
+    while (!q.empty()) {
+        int now = q.front();
+        q.pop();
+        // 현재 도시에서 이동할 수 있는 모든 도시를 확인
+        for (int i = 0; i < graph[now].size(); i++) {
+            int nextNode = graph[now][i];
+            // 아직 방문하지 않은 도시라면
+            if (d[nextNode] == -1) {
+                // 최단 거리 갱신
+                d[nextNode] = d[now] + 1;
+                q.push(nextNode);
+            }
+        }
+    }
+
+    // 최단 거리가 K인 모든 도시의 번호를 오름차순으로 출력
+    bool check = false;
+    for (int i = 1; i <= n; i++) {
+        if (d[i] == k) {
+            cout << i << '\n';
+            check = true;
+        }
+    }
+
+    // 만약 최단 거리가 K인 도시가 없다면, -1 출력
+    if (!check) cout << -1 << '\n';
+}

13/2.cpp

@@ -0,0 +1,90 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n, m;
+int arr[8][8]; // 초기 맵 배열
+int temp[8][8]; // 벽을 설치한 뒤의 맵 배열
+
+// 4가지 이동 방향에 대한 배열
+int dx[] = {-1, 0, 1, 0};
+int dy[] = {0, 1, 0, -1};
+
+int result;
+
+// 깊이 우선 탐색(DFS)을 이용해 각 바이러스가 사방으로 퍼지도록 하기
+void virus(int x, int y) {
+    for (int i = 0; i < 4; i++) {
+        int nx = x + dx[i];
+        int ny = y + dy[i];
+        // 상, 하, 좌, 우 중에서 바이러스가 퍼질 수 있는 경우
+        if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
+            if (temp[nx][ny] == 0) {
+                // 해당 위치에 바이러스 배치하고, 다시 재귀적으로 수행
+                temp[nx][ny] = 2;
+                virus(nx, ny);
+            }
+        }
+    }
+}
+
+// 현재 맵에서 안전 영역의 크기 계산하는 메서드
+int getScore() {
+    int score = 0;
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            if (temp[i][j] == 0) {
+                score += 1;
+            }
+        }
+    }
+    return score;
+}
+
+// 깊이 우선 탐색(DFS)을 이용해 울타리를 설치하면서, 매 번 안전 영역의 크기 계산
+void dfs(int count) {
+    // 울타리가 3개 설치된 경우
+    if (count == 3) {
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                temp[i][j] = arr[i][j];
+            }
+        }
+        // 각 바이러스의 위치에서 전파 진행
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (temp[i][j] == 2) {
+                    virus(i, j);
+                }
+            }
+        }
+        // 안전 영역의 최대값 계산
+        result = max(result, getScore());
+        return;
+    }
+    // 빈 공간에 울타리를 설치
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            if (arr[i][j] == 0) {
+                arr[i][j] = 1;
+                count += 1;
+                dfs(count);
+                arr[i][j] = 0;
+                count -= 1;
+            }
+        }
+    }
+}
+
+int main(void) {
+    cin >> n >> m;
+
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            cin >> arr[i][j];
+        }
+    }
+
+    dfs(0);
+    cout << result << '\n';
+}

13/3.cpp

@@ -0,0 +1,80 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Virus {
+public:
+    int index;
+    int second;
+    int x;
+    int y;
+    Virus(int index, int second, int x, int y) {
+        this->index = index;
+        this->second = second;
+        this->x = x;
+        this->y = y;
+    }
+    // 정렬 기준은 '번호가 낮은 순서'
+    bool operator <(Virus &other) {
+        return this->index < other.index; 
+    }
+};
+
+int n, k;
+// 전체 보드 정보를 담는 배열
+int graph[200][200];
+// 바이러스에 대한 정보를 담는 리스트
+vector<Virus> viruses;
+
+// 바이러스가 퍼져나갈 수 있는 4가지의 위치
+int dx[] = {-1, 0, 1, 0};
+int dy[] = {0, 1, 0, -1};
+
+int main(void) {
+    cin >> n >> k;
+
+    // 보드 정보를 한 줄 단위로 입력
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            cin >> graph[i][j];
+            // 해당 위치에 바이러스가 존재하는 경우
+            if (graph[i][j] != 0) {
+                // (바이러스 종류, 시간, 위치 X, 위치 Y) 삽입
+                viruses.push_back(Virus(graph[i][j], 0, i, j));
+            }
+        }
+    }
+
+    // 정렬 이후에 큐로 옮기기 (낮은 번호의 바이러스가 먼저 증식하므로)
+    sort(viruses.begin(), viruses.end());
+    queue<Virus> q;
+    for (int i = 0; i < viruses.size(); i++) {
+        q.push(viruses[i]);
+    }
+
+    int target_s, target_x, target_y;
+    cin >> target_s >> target_x >> target_y;
+    
+    // 너비 우선 탐색(BFS) 진행
+    while (!q.empty()) {
+        Virus virus = q.front();
+        q.pop();
+        // 정확히 second만큼 초가 지나거나, 큐가 빌 때까지 반복
+        if (virus.second == target_s) break;
+        // 현재 노드에서 주변 4가지 위치를 각각 확인
+        for (int i = 0; i < 4; i++) {
+            int nx = virus.x + dx[i];
+            int ny = virus.y + dy[i];
+            // 해당 위치로 이동할 수 있는 경우
+            if (0 <= nx && nx < n && 0 <= ny && ny < n) {
+                // 아직 방문하지 않은 위치라면, 그 위치에 바이러스 넣기
+                if (graph[nx][ny] == 0) {
+                    graph[nx][ny] = virus.index;
+                    q.push(Virus(virus.index, virus.second + 1, nx, ny));
+                }
+            }
+        }
+    }
+
+    cout << graph[target_x - 1][target_y - 1] << '\n';
+}

13/4.cpp

@@ -0,0 +1,54 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// "균형잡힌 괄호 문자열"의 인덱스 반환
+int balancedIndex(string p) {
+    int count = 0; // 왼쪽 괄호의 개수
+    for (int i = 0; i < p.size(); i++) {
+        if (p[i] == '(') count += 1;
+        else count -= 1;
+        if (count == 0) return i;
+    }
+    return -1;
+}
+
+// "올바른 괄호 문자열"인지 판단
+bool checkProper(string p) {
+    int count = 0; // 왼쪽 괄호의 개수
+    for (int i = 0; i < p.size(); i++) {
+        if (p[i] == '(') count += 1;
+        else {
+            if (count == 0) { // 쌍이 맞지 않는 경우에 false 반환
+                return false;
+            }
+            count -= 1;
+        }
+    }
+    return true; // 쌍이 맞는 경우에 true 반환
+}
+
+string solution(string p) {
+    string answer = "";
+    if (p == "") return answer;
+    int index = balancedIndex(p);
+    string u = p.substr(0, index + 1);
+    string v = p.substr(index + 1);
+    // "올바른 괄호 문자열"이면, v에 대해 함수를 수행한 결과를 붙여 반환
+    if (checkProper(u)) {
+        answer = u + solution(v);
+    }
+    // "올바른 괄호 문자열"이 아니라면 아래의 과정을 수행
+    else {
+        answer = "(";
+        answer += solution(v);
+        answer += ")";
+        u = u.substr(1, u.size() - 2); // 첫 번째와 마지막 문자를 제거
+        for (int i = 0; i < u.size(); i++) {
+            if (u[i] == '(') u[i] = ')';
+            else u[i] = '(';
+        }
+        answer += u;
+    }
+    return answer;
+}

13/5.cpp

@@ -0,0 +1,61 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n;
+// 연산을 수행하고자 하는 수 리스트
+vector<int> arr;
+// 더하기, 빼기, 곱하기, 나누기 연산자 개수
+int add, sub, mul, divi;
+
+// 최솟값과 최댓값 초기화
+int minValue = 1e9;
+int maxValue = -1e9;
+
+// 깊이 우선 탐색 (DFS) 메서드
+void dfs(int i, int now) {
+    // 모든 연산자를 다 사용한 경우, 최솟값과 최댓값 업데이트
+    if (i == n) {
+        minValue = min(minValue, now);
+        maxValue = max(maxValue, now);
+    }
+    else {
+        // 각 연산자에 대하여 재귀적으로 수행
+        if (add > 0) {
+            add -= 1;
+            dfs(i + 1, now + arr[i]);
+            add += 1;
+        }
+        if (sub > 0) {
+            sub -= 1;
+            dfs(i + 1, now - arr[i]);
+            sub += 1;
+        }
+        if (mul > 0) {
+            mul -= 1;
+            dfs(i + 1, now * arr[i]);
+            mul += 1;
+        }
+        if (divi > 0) {
+            divi -= 1;
+            dfs(i + 1, now / arr[i]);
+            divi += 1;
+        }
+    }
+}
+
+int main(void) {
+    cin >> n;
+    for (int i = 0; i < n; i++) {
+        int x;
+        cin >> x;
+        arr.push_back(x);
+    }
+    cin >> add >> sub >> mul >> divi;
+
+    // DFS 메서드 호출
+    dfs(1, arr[0]);
+
+    // 최댓값과 최솟값 차례대로 출력
+    cout << maxValue << '\n' << minValue << '\n';
+}