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';
+}

13/6.cpp

@@ -0,0 +1,128 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n; // 복도의 크기
+char board[6][6]; // 복도 정보 (N x N)
+vector<pair<int, int> > teachers; // 모든 선생님 위치 정보
+vector<pair<int, int> > spaces; // 모든 빈 공간 위치 정보
+
+// 특정 방향으로 감시를 진행 (학생 발견: true, 학생 미발견: false)
+bool watch(int x, int y, int direction) {
+    // 왼쪽 방향으로 감시
+    if (direction == 0) {
+        while (y >= 0) {
+            if (board[x][y] == 'S') { // 학생이 있는 경우
+                return true;
+            }
+            if (board[x][y] == 'O') { // 장애물이 있는 경우
+                return false;
+            }
+            y -= 1;
+        }
+    }
+    // 오른쪽 방향으로 감시
+    if (direction == 1) {
+        while (y < n) {
+            if (board[x][y] == 'S') { // 학생이 있는 경우
+                return true;
+            }
+            if (board[x][y] == 'O') { // 장애물이 있는 경우
+                return false;
+            }
+            y += 1;
+        }
+    }
+    // 위쪽 방향으로 감시
+    if (direction == 2) {
+        while (x >= 0) {
+            if (board[x][y] == 'S') { // 학생이 있는 경우
+                return true;
+            }
+            if (board[x][y] == 'O') { // 장애물이 있는 경우
+                return false;
+            }
+            x -= 1;
+        }
+    }
+    // 아래쪽 방향으로 감시
+    if (direction == 3) {
+        while (x < n) {
+            if (board[x][y] == 'S') { // 학생이 있는 경우
+                return true;
+            }
+            if (board[x][y] == 'O') { // 장애물이 있는 경우
+                return false;
+            }
+            x += 1;
+        }
+    }
+    return false;
+}
+
+// 장애물 설치 이후에, 한 명이라도 학생이 감지되는지 검사
+bool process() {
+    // 모든 선생의 위치를 하나씩 확인
+    for (int i = 0; i < teachers.size(); i++) {
+        int x = teachers[i].first;
+        int y = teachers[i].second;
+        // 4가지 방향으로 학생을 감지할 수 있는지 확인
+        for (int i = 0; i < 4; i++) {
+            if (watch(x, y, i)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool found; // 학생이 한 명도 감지되지 않도록 설치할 수 있는지의 여부
+
+int main(void) {
+    cin >> n;
+
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            cin >> board[i][j];
+            // 선생님이 존재하는 위치 저장
+            if (board[i][j] == 'T') {
+                teachers.push_back({i, j});
+            }
+            // 장애물을 설치할 수 있는 (빈 공간) 위치 저장
+            if (board[i][j] == 'X') {
+                spaces.push_back({i, j});
+            }
+        }
+    }
+
+    // 빈 공간에서 3개를 뽑는 모든 조합을 확인
+    vector<bool> binary(spaces.size());
+    fill(binary.end() - 3, binary.end(), true);
+    do {
+        // 장애물들을 설치해보기
+        for (int i = 0; i < spaces.size(); i++) {
+            if (binary[i]) {
+                int x = spaces[i].first;
+                int y = spaces[i].second;
+                board[x][y] = 'O';
+            }
+        }
+        // 학생이 한 명도 감지되지 않는 경우
+        if (!process()) {
+            // 원하는 경우를 발견한 것임
+            found = true;
+            break;
+        }
+        // 설치된 장애물을 다시 없애기
+        for (int i = 0; i < spaces.size(); i++) {
+            if (binary[i]) {
+                int x = spaces[i].first;
+                int y = spaces[i].second;
+                board[x][y] = 'X';
+            }
+        }
+    } while(next_permutation(binary.begin(), binary.end()));
+
+    if (found) cout << "YES" << '\n';
+    else cout << "NO" << '\n';
+}

13/7.cpp

@@ -0,0 +1,92 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 땅의 크기(N), L, R 값을 입력받기
+int n, l, r;
+
+// 전체 나라의 정보(N x N)를 입력받기
+int graph[50][50];
+int unions[50][50];
+
+int dx[] = {-1, 0, 1, 0};
+int dy[] = {0, -1, 0, 1};
+
+// 특정 위치에서 출발하여 모든 연합을 체크한 뒤에 데이터 갱신
+void process(int x, int y, int index) {
+    // (x, y)의 위치와 연결된 나라(연합) 정보를 담는 리스트
+    vector<pair<int, int> > united;
+    united.push_back({x, y});
+    // 너비 우선 탐색 (BFS)을 위한 큐 라이브러리 사용
+    queue<pair<int, int> > q;
+    q.push({x, y});
+    unions[x][y] = index; // 현재 연합의 번호 할당
+    int summary = graph[x][y]; // 현재 연합의 전체 인구 수
+    int count = 1; // 현재 연합의 국가 수
+    // 큐가 빌 때까지 반복(BFS)
+    while (!q.empty()) {
+        int x = q.front().first;
+        int y = q.front().second;
+        q.pop();
+        // 현재 위치에서 4가지 방향을 확인하며
+        for (int i = 0; i < 4; i++) {
+            int nx = x + dx[i];
+            int ny = y + dy[i];
+            // 바로 옆에 있는 나라를 확인하여
+            if (0 <= nx && nx < n && 0 <= ny && ny < n && unions[nx][ny] == -1) {
+                // 옆에 있는 나라와 인구 차이가 L명 이상, R명 이하라면
+                int gap = abs(graph[nx][ny] - graph[x][y]);
+                if (l <= gap && gap <= r) {
+                    q.push({nx, ny});
+                    // 연합에 추가하기
+                    unions[nx][ny] = index;
+                    summary += graph[nx][ny];
+                    count += 1;
+                    united.push_back({nx, ny});
+                }
+            }
+        }
+    }
+    // 연합 국가끼리 인구를 분배
+    for (int i = 0; i < united.size(); i++) {
+        int x = united[i].first;
+        int y = united[i].second;
+        graph[x][y] = summary / count;
+    }
+}
+
+int totalCount = 0;
+
+int main(void) {
+    cin >> n >> l >> r;
+
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            cin >> graph[i][j];
+        }
+    }
+
+    // 더 이상 인구 이동을 할 수 없을 때까지 반복
+    while (true) {
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                unions[i][j] = -1;
+            }
+        }
+        int index = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (unions[i][j] == -1) { // 해당 나라가 아직 처리되지 않았다면
+                    process(i, j, index);
+                    index += 1;
+                }
+            }
+        }
+        // 모든 인구 이동이 끝난 경우
+        if (index == n * n) break;
+        totalCount += 1;
+    }
+
+    // 인구 이동 횟수 출력
+    cout << totalCount << '\n';
+}

13/8.cpp

@@ -0,0 +1,103 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Node {
+public:
+    int pos1X;
+    int pos1Y;
+    int pos2X;
+    int pos2Y;
+    Node(int pos1X, int pos1Y, int pos2X, int pos2Y) {
+        this->pos1X = pos1X;
+        this->pos1Y = pos1Y;
+        this->pos2X = pos2X;
+        this->pos2Y = pos2Y;
+    }
+};
+
+vector<Node> getNextPos(Node pos, vector<vector<int> > board) {
+    vector<Node> nextPos; // 반환 결과 (이동 가능한 위치들)
+    // (상, 하, 좌, 우)로 이동하는 경우에 대해서 처리
+    int dx[] = {-1, 1, 0, 0};
+    int dy[] = {0, 0, -1, 1};
+    for (int i = 0; i < 4; i++) {
+        int pos1NextX = pos.pos1X + dx[i];
+        int pos1NextY = pos.pos1Y + dy[i];
+        int pos2NextX = pos.pos2X + dx[i];
+        int pos2NextY = pos.pos2Y + dy[i];
+        // 이동하고자 하는 두 칸이 모두 비어 있다면
+        if (board[pos1NextX][pos1NextY] == 0 && board[pos2NextX][pos2NextY] == 0) {
+            nextPos.push_back(Node(pos1NextX, pos1NextY, pos2NextX, pos2NextY));
+        }
+    }
+    // 현재 로봇이 가로로 놓여 있는 경우
+    int hor[] = {-1, 1};
+    if (pos.pos1X == pos.pos2X) {
+        for (int i = 0; i < 2; i++) { // 위쪽으로 회전하거나, 아래쪽으로 회전
+            // 위쪽 혹은 아래쪽 두 칸이 모두 비어 있다면
+            if (board[pos.pos1X + hor[i]][pos.pos1Y] == 0 && board[pos.pos2X + hor[i]][pos.pos2Y] == 0) {
+                nextPos.push_back(Node(pos.pos1X, pos.pos1Y, pos.pos1X + hor[i], pos.pos1Y));
+                nextPos.push_back(Node(pos.pos2X, pos.pos2Y, pos.pos2X + hor[i], pos.pos2Y));
+            }
+        }
+    }
+    // 현재 로봇이 가로로 놓여 있는 경우
+    int ver[] = {-1, 1};
+    if (pos.pos1Y == pos.pos2Y) {
+        for (int i = 0; i < 2; i++) { // 왼쪽으로 회전하거나, 오른쪽으로 회전
+            // 왼쪽 혹은 오른쪽 두 칸이 모두 비어 있다면
+            if (board[pos.pos1X][pos.pos1Y + ver[i]] == 0 && board[pos.pos2X][pos.pos2Y + ver[i]] == 0) {
+                nextPos.push_back(Node(pos.pos1X, pos.pos1Y, pos.pos1X, pos.pos1Y + ver[i]));
+                nextPos.push_back(Node(pos.pos2X, pos.pos2Y, pos.pos2X, pos.pos2Y + ver[i]));
+            }
+        }
+    }
+    // 현재 위치에서 이동할 수 있는 위치를 반환
+    return nextPos;
+}
+
+int solution(vector<vector<int> > board) {
+    // 맵의 외곽에 벽을 두는 형태로 맵 변형
+    int n = board.size();
+    vector<vector<int> > newBoard(n + 2, vector<int>(n + 2, 1));
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            newBoard[i + 1][j + 1] = board[i][j];
+        }
+    }
+    // 너비 우선 탐색(BFS) 수행
+    queue<pair<Node, int> > q;
+    vector<Node> visited;
+    Node pos = Node(1, 1, 1, 2); // 시작 위치 설정
+    q.push({pos, 0}); // 큐에 삽입한 뒤에
+    visited.push_back(pos); // 방문 처리
+    // 큐가 빌 때까지 반복
+    while (!q.empty()) {
+        Node pos = q.front().first;
+        int cost = q.front().second;
+        q.pop();
+        // (n, n) 위치에 로봇이 도달했다면, 최단 거리이므로 반환
+        if ((pos.pos1X == n && pos.pos1Y == n) || (pos.pos2X == n && pos.pos2Y == n)) {
+            return cost;
+        }
+        // 현재 위치에서 이동할 수 있는 위치 확인
+        vector<Node> nextPos = getNextPos(pos, newBoard);
+        for (int i = 0; i < nextPos.size(); i++) {
+            // 아직 방문하지 않은 위치라면 큐에 삽입하고 방문 처리
+            bool check = true;
+            Node pos = nextPos[i];
+            for (int j = 0; j < visited.size(); j++) {
+                if (pos.pos1X == visited[j].pos1X && pos.pos1Y == visited[j].pos1Y && pos.pos2X == visited[j].pos2X && pos.pos2Y == visited[j].pos2Y) {
+					check = false;
+					break;
+				}
+            }
+            if (check) {
+		        q.push({pos, cost + 1});
+		        visited.push_back(pos);
+			}
+        }
+    }
+    return 0;
+}