08_DFS_BFS

08_DFS_BFS_/필수/2606.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int num, pair_num;
+vector<vector<int>> li;
+vector<bool> visited;
+
+void doDfs(int index, vector<int>& ans_dfs){
+    visited[index]=true;
+    ans_dfs.push_back(index);
+
+    for(int i=1; i<=num; i++){
+        if(li[index][i]==1 && !visited[i]){
+            doDfs(i, ans_dfs);
+        }
+    }
+}
+
+int main(){
+    cin >> num;
+    cin >> pair_num;
+
+    li.assign(num + 1, vector<int>(num + 1, 0));
+    visited.assign(num + 1, false);
+
+    for(int i=0; i<pair_num; i++){
+        int a,b;
+        cin >> a >> b;
+        li[a][b]=li[b][a]=1;
+    }
+    vector<int> ans_dfs;
+    int index = 1; 
+    doDfs(index, ans_dfs);
+
+    int count = ans_dfs.size() - 1; //방문한 노드의 수
+
+    cout << count;
+
+    return 0;
+}

08_DFS_BFS_/필수/2615.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+#include <queue>
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+const int MAX=19;
+int map[20][20];
+bool visit[20][20][4];
+int dy[]={0, 1,1,1};
+int dx[]={1,1,0,-1};
+vector<pair<int, int>> pos;
+
+
+bool cmp(pair<int, int> a, pair<int, int>b){
+    if(a.second >= b.second){
+        if(a.second == b.second){
+            if(a.first> b.first){
+                return false;
+            }
+            else return true;
+        }else return false;
+    }else return true;
+}
+
+bool outrange(int y, int x){
+    if(y<1 || x<1 || y>MAX || x > MAX){
+        return false;
+    }
+    return true;
+}
+
+int check_next(int now_y, int now_x, int dir, int val, int cnt){
+    visit[now_y][now_x][dir]=true;
+    pos.push_back(make_pair(now_y, now_x));
+
+    int next_y=now_y+ dy[dir];
+    int next_x=now_x+ dx[dir];
+
+    if(!outrange(next_y, next_x) || map[next_y][next_x]!=val){
+        return cnt;
+    }
+    return check_next(next_y, next_x, dir, val, cnt+1);
+}
+
+
+int main(){
+
+    for(int i=1; i<=MAX; i++){
+        for(int j=1; j<=MAX; j++){
+            cin >> map[i][j];
+        }
+    }
+
+    for (int i=1; i<=MAX; i++){
+        for(int j=1; j<=MAX; j++){
+            if(map[i][j]==0) continue;
+            for(int d=0; d<4; d++){
+                int ny=i+dy[d];
+                int nx=j+dx[d];
+
+                if(!outrange(ny,nx)) continue;
+                if(map[ny][nx]==map[i][j] && !visit[i][j][d]){
+                    pos.clear();
+                    visit[i][j][d]=true;
+                    pos.push_back(make_pair(i,j));
+                    if(check_next(ny,nx, d, map[i][j], 2)==5){
+                        sort(pos.begin(), pos.end(), cmp);
+                        cout << map[i][j] << "\n";
+                        cout << pos[0].first << " " << pos[0].second;
+                        return 0;
+                    }
+                }
+            }
+        }
+    }
+
+    cout << 0;
+    return 0;
+
+}

08_DFS_BFS_/필수/2644.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int n, a, b, m; //함수에서 사용할 변수를 전역 변수로 선언. 
+vector<vector<int>> li; // 그래프를 나타내는 인접 리스트
+vector<bool> visited; // 방문 여부를 체크하는 벡터
+int ans = -1; // 최종 촌수 저장, 기본값은 -1(친척 관계 없음)
+
+void dfs(int v, int num) { //dfs로 촌수 계산. 
+    // 현재 노드 방문 처리
+    //찾길 원하는 사람의 번호에 방문 처리.  
+    visited[v] = true;  
+
+    if (v == b) { // 촌수를 구한 경우
+        ans = num; //촌수를 저장할 변수인 ans에 num값 저장. 
+        return;
+    }
+
+    for (int i = 1; i <= n; i++) { //전체 사람의 수
+        if (li[v][i] == 1 && !visited[i]) { // 인접하고 아직 방문하지 않은 것에 대해 dfs 실행 
+            dfs(i, num + 1); //dfs 함수 순환 호출
+        }
+    }
+}
+
+int main() {
+    cin >> n;  //전체 사람의 수
+    cin >> a >> b; //촌수를 찾을 사람의 번호
+    cin >> m;  //부모와 자식 간의 관계의 개수 
+
+    li.assign(n + 1, vector<int>(n + 1, 0)); //인접 리스트 li 초기화. 
+    visited.assign(n + 1, false);//최초 방문 전, 아무도 방문하지 않았다는 의미로 모든 false 대입.
+
+    for (int i = 0; i < m; i++) {//m번 루프를 돌며 부모와 자식 간의 관계를 입력받음. 
+        int c, d; 
+        cin >> c >> d; //c:부모의 번호, d: 자식의 번호. 
+        li[c][d] = li[d][c] = 1; // 양방향 그래프로 구성-> 부모-자식 간은 1촌 간. 어느 방향으로 보든 1촌이기에 양방향으로 선언해줌. 
+    }
+
+    dfs(a, 0); //dfs함수 호출. 
+
+    if (ans == -1) { //서로 아무런 관계가 없는 경우. 
+        cout << -1 << "\n"; // 경로가 없는 경우
+    } else {
+        cout << ans << "\n"; // 최소 거리 출력
+    }
+
+    return 0;
+}