copy_table

Author: movingone

Diff for: 1/1.py

@@ -0,0 +1,6 @@
+import time
+start_time = time.time() # 측정 시작
+
+# 프로그램 소스코드
+end_time = time.time() # 측정 종료
+print("time:", end_time - start_time) # 수행 시간 출력

Diff for: 1/2.py

@@ -0,0 +1,35 @@
+from random import randint
+import time
+
+# 배열에 10,000개의 정수를 삽입
+array = []
+for _ in range(10000):
+    array.append(randint(1, 100)) # 1부터 100 사이의 랜덤한 정수
+
+# 선택 정렬 프로그램 성능 측정
+start_time = time.time()
+
+# 선택 정렬 프로그램 소스코드
+for i in range(len(array)):
+    min_index = i # 가장 작은 원소의 인덱스
+    for j in range(i + 1, len(array)):
+        if array[min_index] > array[j]:
+            min_index = j
+    array[i], array[min_index] = array[min_index], array[i] # 스와프
+
+end_time = time.time() # 측정 종료
+print("선택 정렬 성능 측정:", end_time - start_time) # 수행 시간 출력
+
+# 배열을 다시 무작위 데이터로 초기화
+array = []
+for _ in range(10000):
+    array.append(randint(1, 100)) # 1부터 100 사이의 랜덤한 정수
+
+# 기본 정렬 라이브러리 성능 측정
+start_time = time.time()
+
+# 기본 정렬 라이브러리 사용
+array.sort()
+
+end_time = time.time() # 측정 종료
+print("기본 정렬 라이브러리 성능 측정:", end_time - start_time) # 수행 시간 출력

Diff for: 10/1.cpp

@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 노드의 개수(V)와 간선(Union 연산)의 개수(E)
+// 노드의 개수는 최대 100,000개라고 가정
+int v, e;
+int parent[100001]; // 부모 테이블 초기화하기
+
+// 특정 원소가 속한 집합을 찾기
+int findParent(int x) {
+    // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
+    if (x == parent[x]) return x;
+    return findParent(parent[x]);
+}
+
+// 두 원소가 속한 집합을 합치기
+void unionParent(int a, int b) {
+    a = findParent(a);
+    b = findParent(b);
+    if (a < b) parent[b] = a;
+    else parent[a] = b;
+}
+
+int main(void) {
+    cin >> v >> e;
+
+    // 부모 테이블상에서, 부모를 자기 자신으로 초기화
+    for (int i = 1; i <= v; i++) {
+        parent[i] = i;
+    }
+
+    // Union 연산을 각각 수행
+    for (int i = 0; i < e; i++) {
+        int a, b;
+        cin >> a >> b;
+        unionParent(a, b);
+    }
+
+    // 각 원소가 속한 집합 출력하기
+    cout << "각 원소가 속한 집합: ";
+    for (int i = 1; i <= v; i++) {
+        cout << findParent(i) << ' ';
+    }
+    cout << '\n';
+
+    // 부모 테이블 내용 출력하기
+    cout << "부모 테이블: ";
+    for (int i = 1; i <= v; i++) {
+        cout << parent[i] << ' ';
+    }
+    cout << '\n';
+}

Diff for: 10/1.java

@@ -0,0 +1,57 @@
+import java.util.*;
+
+public class Main {
+
+    // 노드의 개수(V)와 간선(Union 연산)의 개수(E)
+    // 노드의 개수는 최대 100,000개라고 가정
+    public static int v, e;
+    public static int[] parent = new int[100001]; // 부모 테이블 초기화하기
+
+    // 특정 원소가 속한 집합을 찾기
+    public static int findParent(int x) {
+        // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
+        if (x == parent[x]) return x;
+        return findParent(parent[x]);
+    }
+
+    // 두 원소가 속한 집합을 합치기
+    public static void unionParent(int a, int b) {
+        a = findParent(a);
+        b = findParent(b);
+        if (a < b) parent[b] = a;
+        else parent[a] = b;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        v = sc.nextInt();
+        e = sc.nextInt();
+
+        // 부모 테이블상에서, 부모를 자기 자신으로 초기화
+        for (int i = 1; i <= v; i++) {
+            parent[i] = i;
+        }
+
+        // Union 연산을 각각 수행
+        for (int i = 0; i < e; i++) {
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+            unionParent(a, b);
+        }
+
+        // 각 원소가 속한 집합 출력하기
+        System.out.print("각 원소가 속한 집합: ");
+        for (int i = 1; i <= v; i++) {
+            System.out.print(findParent(i) + " ");
+        }
+        System.out.println();
+
+        // 부모 테이블 내용 출력하기
+        System.out.print("부모 테이블: ");
+        for (int i = 1; i <= v; i++) {
+            System.out.print(parent[i] + " ");
+        }
+        System.out.println();
+    }
+}

Diff for: 10/1.py

@@ -0,0 +1,40 @@
+# 특정 원소가 속한 집합을 찾기
+def find_parent(parent, x):
+    # 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
+    if parent[x] != x:
+        return find_parent(parent, parent[x])
+    return x
+
+# 두 원소가 속한 집합을 합치기
+def union_parent(parent, a, b):
+    a = find_parent(parent, a)
+    b = find_parent(parent, b)
+    if a < b:
+        parent[b] = a
+    else:
+        parent[a] = b
+
+# 노드의 개수와 간선(Union 연산)의 개수 입력 받기
+v, e = map(int, input().split())
+parent = [0] * (v + 1) # 부모 테이블 초기화하기
+
+# 부모 테이블상에서, 부모를 자기 자신으로 초기화
+for i in range(1, v + 1):
+    parent[i] = i
+
+# Union 연산을 각각 수행
+for i in range(e):
+    a, b = map(int, input().split())
+    union_parent(parent, a, b)
+
+# 각 원소가 속한 집합 출력하기
+print('각 원소가 속한 집합: ', end='')
+for i in range(1, v + 1):
+    print(find_parent(parent, i), end=' ')
+
+print()
+
+# 부모 테이블 내용 출력하기
+print('부모 테이블: ', end='')
+for i in range(1, v + 1):
+    print(parent[i], end=' ')

Diff for: 10/2.py

@@ -0,0 +1,4 @@
+def find_parent(parent, x):
+    if parent[x] != x:
+        parent[x] = find_parent(parent, parent[x])
+    return parent[x]

Diff for: 10/3.cpp

@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 노드의 개수(V)와 간선(Union 연산)의 개수(E)
+// 노드의 개수는 최대 100,000개라고 가정
+int v, e;
+int parent[100001]; // 부모 테이블 초기화
+
+// 특정 원소가 속한 집합을 찾기
+int findParent(int x) {
+    // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
+    if (x == parent[x]) return x;
+    return parent[x] = findParent(parent[x]);
+}
+
+// 두 원소가 속한 집합을 합치기
+void unionParent(int a, int b) {
+    a = findParent(a);
+    b = findParent(b);
+    if (a < b) parent[b] = a;
+    else parent[a] = b;
+}
+
+int main(void) {
+    cin >> v >> e;
+
+    // 부모 테이블상에서, 부모를 자기 자신으로 초기화
+    for (int i = 1; i <= v; i++) {
+        parent[i] = i;
+    }
+
+    // Union 연산을 각각 수행
+    for (int i = 0; i < e; i++) {
+        int a, b;
+        cin >> a >> b;
+        unionParent(a, b);
+    }
+
+    // 각 원소가 속한 집합 출력하기
+    cout << "각 원소가 속한 집합: ";
+    for (int i = 1; i <= v; i++) {
+        cout << findParent(i) << ' ';
+    }
+    cout << '\n';
+
+    // 부모 테이블 내용 출력하기
+    cout << "부모 테이블: ";
+    for (int i = 1; i <= v; i++) {
+        cout << parent[i] << ' ';
+    }
+    cout << '\n';
+}

Diff for: 10/3.java

@@ -0,0 +1,57 @@
+import java.util.*;
+
+public class Main {
+
+    // 노드의 개수(V)와 간선(Union 연산)의 개수(E)
+    // 노드의 개수는 최대 100,000개라고 가정
+    public static int v, e;
+    public static int[] parent = new int[100001]; // 부모 테이블 초기화하기
+
+    // 특정 원소가 속한 집합을 찾기
+    public static int findParent(int x) {
+        // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
+        if (x == parent[x]) return x;
+        return parent[x] = findParent(parent[x]);
+    }
+
+    // 두 원소가 속한 집합을 합치기
+    public static void unionParent(int a, int b) {
+        a = findParent(a);
+        b = findParent(b);
+        if (a < b) parent[b] = a;
+        else parent[a] = b;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        v = sc.nextInt();
+        e = sc.nextInt();
+
+        // 부모 테이블상에서, 부모를 자기 자신으로 초기화
+        for (int i = 1; i <= v; i++) {
+            parent[i] = i;
+        }
+
+        // Union 연산을 각각 수행
+        for (int i = 0; i < e; i++) {
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+            unionParent(a, b);
+        }
+
+        // 각 원소가 속한 집합 출력하기
+        System.out.print("각 원소가 속한 집합: ");
+        for (int i = 1; i <= v; i++) {
+            System.out.print(findParent(i) + " ");
+        }
+        System.out.println();
+
+        // 부모 테이블 내용 출력하기
+        System.out.print("부모 테이블: ");
+        for (int i = 1; i <= v; i++) {
+            System.out.print(parent[i] + " ");
+        }
+        System.out.println();
+    }
+}

Diff for: 10/3.py

@@ -0,0 +1,40 @@
+# 특정 원소가 속한 집합을 찾기
+def find_parent(parent, x):
+    # 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
+    if parent[x] != x:
+        parent[x] = find_parent(parent, parent[x])
+    return parent[x]
+
+# 두 원소가 속한 집합을 합치기
+def union_parent(parent, a, b):
+    a = find_parent(parent, a)
+    b = find_parent(parent, b)
+    if a < b:
+        parent[b] = a
+    else:
+        parent[a] = b
+
+# 노드의 개수와 간선(Union 연산)의 개수 입력 받기
+v, e = map(int, input().split())
+parent = [0] * (v + 1) # 부모 테이블 초기화하기
+
+# 부모 테이블상에서, 부모를 자기 자신으로 초기화
+for i in range(1, v + 1):
+    parent[i] = i
+
+# Union 연산을 각각 수행
+for i in range(e):
+    a, b = map(int, input().split())
+    union_parent(parent, a, b)
+
+# 각 원소가 속한 집합 출력하기
+print('각 원소가 속한 집합: ', end='')
+for i in range(1, v + 1):
+    print(find_parent(parent, i), end=' ')
+
+print()
+
+# 부모 테이블 내용 출력하기
+print('부모 테이블: ', end='')
+for i in range(1, v + 1):
+    print(parent[i], end=' ')