Update

Author: ndb796

5/1.java

@@ -0,0 +1,24 @@
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Stack<Integer> s = new Stack<>();
+
+        // 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()
+        s.push(5);
+        s.push(2);
+        s.push(3);
+        s.push(7);
+        s.pop();
+        s.push(1);
+        s.push(4);
+        s.pop();
+        // 스택의 최상단 원소부터 출력
+        while (!s.empty()) {
+            System.out.println(s.peek());
+            s.pop();
+        }
+    }
+
+}

5/10.cpp

@@ -3,7 +3,7 @@
 using namespace std;
 
 int n, m;
-int graph[1001][1001];
+int graph[1000][1000];
 
 // DFS로 특정 노드를 방문하고 연결된 모든 노드들도 방문
 bool dfs(int x, int y) {

5/10.java

@@ -0,0 +1,57 @@
+import java.util.*;
+
+public class Main {
+
+    public static int n, m;
+    public static int[][] graph = new int[1000][1000];
+
+    // DFS로 특정 노드를 방문하고 연결된 모든 노드들도 방문
+    public static boolean dfs(int x, int y) {
+        // 주어진 범위를 벗어나는 경우에는 즉시 종료
+        if (x <= -1 || x >=n || y <= -1 || y >= m) {
+            return false;
+        }
+        // 현재 노드를 아직 방문하지 않았다면
+        if (graph[x][y] == 0) {
+            // 해당 노드 방문 처리
+            graph[x][y] = 1;
+            // 상, 하, 좌, 우의 위치들도 모두 재귀적으로 호출
+            dfs(x - 1, y);
+            dfs(x, y - 1);
+            dfs(x + 1, y);
+            dfs(x, y + 1);
+            return true;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // N, M을 공백을 기준으로 구분하여 입력 받기
+        n = sc.nextInt();
+        m = sc.nextInt();
+        sc.nextLine(); // 버퍼 지우기
+
+        // 2차원 리스트의 맵 정보 입력 받기
+        for (int i = 0; i < n; i++) {
+            String str = sc.nextLine();
+            for (int j = 0; j < m; j++) {
+                graph[i][j] = str.charAt(j) - '0';
+            }
+        }
+
+        // 모든 노드(위치)에 대하여 음료수 채우기
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                // 현재 위치에서 DFS 수행
+                if (dfs(i, j)) {
+                    result += 1;
+                }
+            }
+        }
+        System.out.println(result); // 정답 출력 
+    }
+
+}

5/11.java

@@ -0,0 +1,79 @@
+import java.util.*;
+
+class Node {
+
+    private int index;
+    private int distance;
+
+    public Node(int index, int distance) {
+        this.index = index;
+        this.distance = distance;
+    }
+
+    public int getIndex() {
+        return this.index;
+    }
+    
+    public int getDistance() {
+        return this.distance;
+    }
+}
+
+public class Main {
+
+    public static int n, m;
+    public static int[][] graph = new int[201][201];
+
+    // 이동할 네 가지 방향 정의 (상, 하, 좌, 우) 
+    public static int dx[] = {-1, 1, 0, 0};
+    public static int dy[] = {0, 0, -1, 1};
+
+    public static int bfs(int x, int y) {
+        // 큐(Queue) 구현을 위해 queue 라이브러리 사용 
+        Queue<Node> q = new LinkedList<>();
+        q.offer(new Node(x, y));
+        // 큐가 빌 때까지 반복하기 
+        while(!q.isEmpty()) {
+            Node node = q.poll();
+            x = node.getIndex();
+            y = node.getDistance();
+            // 현재 위치에서 4가지 방향으로의 위치 확인
+            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) continue;
+                // 벽인 경우 무시
+                if (graph[nx][ny] == 0) continue;
+                // 해당 노드를 처음 방문하는 경우에만 최단 거리 기록
+                if (graph[nx][ny] == 1) {
+                    graph[nx][ny] = graph[x][y] + 1;
+                    q.offer(new Node(nx, ny));
+                } 
+            } 
+        }
+        // 가장 오른쪽 아래까지의 최단 거리 반환
+        return graph[n - 1][m - 1];
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // N, M을 공백을 기준으로 구분하여 입력 받기
+        n = sc.nextInt();
+        m = sc.nextInt();
+        sc.nextLine(); // 버퍼 지우기
+
+        // 2차원 리스트의 맵 정보 입력 받기
+        for (int i = 0; i < n; i++) {
+            String str = sc.nextLine();
+            for (int j = 0; j < m; j++) {
+                graph[i][j] = str.charAt(j) - '0';
+            }
+        }
+
+        // BFS를 수행한 결과 출력
+        System.out.println(bfs(0, 0));
+    }
+
+}

5/2.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Queue<Integer> q = new LinkedList<>();
+
+        // 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()
+        q.offer(5);
+        q.offer(2);
+        q.offer(3);
+        q.offer(7);
+        q.poll();
+        q.offer(1);
+        q.offer(4);
+        q.poll();
+        // 먼저 들어온 원소부터 추출
+        while (!q.isEmpty()) {
+            System.out.println(q.poll());
+        }
+    }
+
+}

5/3.java

@@ -0,0 +1,14 @@
+import java.util.*;
+
+public class Main {
+
+    public static void recursiveFunction() {
+        System.out.println("재귀 함수를 호출합니다.");
+        recursiveFunction();
+    }
+
+    public static void main(String[] args) {
+        recursiveFunction();
+    }
+
+}

5/4.java

@@ -0,0 +1,17 @@
+import java.util.*;
+
+public class Main {
+
+    public static void recursiveFunction(int i) {
+        // 100번째 호출을 했을 때 종료되도록 종료 조건 명시
+        if (i == 100) return;
+        System.out.println(i + "번째 재귀 함수에서 " + (i + 1) + "번째 재귀함수를 호출합니다.");
+        recursiveFunction(i + 1);
+        System.out.println(i + "번째 재귀 함수를 종료합니다.");
+    }
+
+    public static void main(String[] args) {
+        recursiveFunction(1);
+    }
+
+}

5/5.java

@@ -0,0 +1,29 @@
+import java.util.*;
+
+public class Main {
+
+    // 반복적으로 구현한 n!
+    public static int factorialIterative(int n) {
+        int result = 1;
+        // 1부터 n까지의 수를 차례대로 곱하기
+        for (int i = 1; i <= n; i++) {
+            result *= i;
+        }
+        return result;
+    }
+
+    // 재귀적으로 구현한 n!
+    public static int factorialRecursive(int n) {
+        // n이 1 이하인 경우 1을 반환
+        if (n <= 1) return 1;
+        // n! = n * (n - 1)!를 그대로 코드로 작성하기
+        return n * factorialRecursive(n - 1);
+    }
+
+    public static void main(String[] args) {
+        // 각각의 방식으로 구현한 n! 출력(n = 5)
+        System.out.println("반복적으로 구현:" + factorialIterative(5));
+        System.out.println("재귀적으로 구현:" + factorialRecursive(5));
+    }
+
+}

5/6.java

@@ -0,0 +1,24 @@
+import java.util.*;
+
+public class Main {
+
+    public static final int INF = 999999999;
+    
+    // 2차원 리스트를 이용해 인접 행렬 표현
+    public static int[][] graph = {
+        {0, 7, 5},
+        {7, 0, INF},
+        {5, INF, 0}
+    };
+
+    public static void main(String[] args) {
+        // 그래프 출력
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                System.out.print(graph[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+
+}

5/7.java

@@ -0,0 +1,48 @@
+import java.util.*;
+
+class Node {
+
+    private int index;
+    private int distance;
+
+    public Node(int index, int distance) {
+        this.index = index;
+        this.distance = distance;
+    }
+
+    public void show() {
+        System.out.print("(" + this.index + "," + this.distance + ") ");
+    }
+}
+
+public class Main {
+
+    // 행(Row)이 3개인 인접 리스트 표현
+    public static ArrayList<ArrayList<Node>> graph = new ArrayList<ArrayList<Node>>();
+
+    public static void main(String[] args) {
+        // 그래프 초기화
+        for (int i = 0; i < 3; i++) {
+            graph.add(new ArrayList<Node>());
+        }
+
+        // 노드 0에 연결된 노드 정보 저장 (노드, 거리)
+        graph.get(0).add(new Node(1, 7));
+        graph.get(0).add(new Node(2, 5));
+
+        // 노드 1에 연결된 노드 정보 저장 (노드, 거리)
+        graph.get(1).add(new Node(0, 7));
+
+        // 노드 2에 연결된 노드 정보 저장 (노드, 거리)
+        graph.get(2).add(new Node(0, 5));
+
+        // 그래프 출력
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < graph.get(i).size(); j++) {
+                graph.get(i).get(j).show();
+            }
+            System.out.println();
+        }
+    }
+
+}