..

00주차(템플릿)/README.md

@@ -0,0 +1,38 @@
+> 마크다운 사용법 링크: https://gist.github.com/ihoneymon/652be052a0727ad59601
+## 숙제
+|난이도|번호|제목|링크|
+|-|-|-|-|
+||번||https://www.acmicpc.net/problem/|
+||번||https://www.acmicpc.net/problem/|
+
+## 스터디 진행 중 풀이
+|난이도|번호|제목|링크|
+|-----|-----|----------|----------------------------------------|
+|난이도|번호|제목|링크|
+|골드 4|번||https://www.acmicpc.net/problem/|
+
+
+## 찾아온 문제들
+#### 민기홍
+|난이도|번호|제목|링크|
+|-----|-----|---------------------|----------------------------------------|
+|골드 4|번||https://www.acmicpc.net/problem/|
+|골드 5|번||https://www.acmicpc.net/problem/|
+
+#### 김동주
+|난이도|번호|제목|링크|
+|-----|-----|---------------------|----------------------------------------|
+|골드 4|번||https://www.acmicpc.net/problem/|
+|골드 5|번||https://www.acmicpc.net/problem/|
+
+#### 정우현
+|난이도|번호|제목|링크|
+|-----|-----|---------------------|----------------------------------------|
+|골드 4|번||https://www.acmicpc.net/problem/|
+|골드 5|번||https://www.acmicpc.net/problem/|
+
+#### 서동혁
+|난이도|번호|제목|링크|
+|-----|-----|---------------------|----------------------------------------|
+|골드 4|번||https://www.acmicpc.net/problem/|
+|골드 5|번||https://www.acmicpc.net/problem/|

01주차 (정렬)/README.md

@@ -0,0 +1,3 @@
+유형: 정렬(선택, 버블, 삽입, 쾌속, 합병) + 시간복잡도 계산
+
+2750번, 2751번 문제

01주차/2750.py

@@ -0,0 +1,27 @@
+# O(N^2)의 시간복잡도를 하기 위해 선택정렬 코드
+
+# A개의 정수를 입력
+A = int(input())
+
+# 입력된 정수를 저장할 빈 리스트 A_list를 초기화시키기
+A_list = []
+
+# A번 반복하여 정수를 사용자로부터 입력받고 A_list 리스트에 저장
+for i in range(A):
+    num = int(input())
+    A_list.append(num)
+
+# 선택 정렬을 이용하여 리스트를 정렬
+for i in range(A):
+    # 현재 위치부터 나머지 원소 중에서 최솟값의 인덱스 찾기
+    min_index = i
+    for j in range(i + 1, A):
+        if A_list[j] < A_list[min_index]:
+            min_index = j
+
+    # 현재 위치의 원소와 최솟값의 원소를 교환
+    A_list[i], A_list[min_index] = A_list[min_index], A_list[i]
+
+# 정렬된 리스트를 출력
+for i in A_list:
+    print(i)

01주차/2751.py

@@ -0,0 +1,39 @@
+# O(n log n)의 시간 복잡도를 위해 quick_sort 함수 사용
+def quick_sort(arr):
+    if len(arr) <= 1:
+        return arr
+
+    # 피벗 원소를 선택
+    pivot = arr[len(arr) // 2]
+
+    # 피벗보다 작은 원소들 (왼쪽)
+    left = [x for x in arr if x < pivot]
+
+    # 피벗과 같은 원소들 (가운데)
+    middle = [x for x in arr if x == pivot]
+
+    # 피벗보다 큰 원소들 (오른쪽)
+    right = [x for x in arr if x > pivot]
+
+    return quick_sort(left) + middle + quick_sort(right)
+
+# 사용자로부터 요소의 개수인 A를 입력받기
+A = int(input())
+
+# 사용자 입력을 저장할 빈 리스트를 초기화
+A_list = []
+
+
+# A개의 정수를 사용자로부터 입력받고 A_list에 저장
+for i in range(A):
+    num = int(input())
+    A_list.append(num)
+
+# quick_sort 함수를 사용하여 리스트를 정렬
+A_list = quick_sort(A_list)
+
+# 정렬된 리스트 출력
+for i in A_list:
+    print(i)
+
+

02주차/1920번.py

@@ -0,0 +1,30 @@
+def binary_search(array, elem):
+    #left, right 값 초기화
+    left, right = 0, len(array) - 1
+
+    #왼쪽 인덱스가 오른쪽 인덱스보다 작거나 같을 동안 반복
+    while left <= right:
+        mid = (left + right) // 2
+        #중간 값이 찾고자 하는 값과 같다면, 1 반환하고 종료
+        if array[mid] == elem:
+            return 1
+        #만약 중간 값이 찾는 값보다 작다면, 왼쪽 범위를 중간 값의 오른쪽으로 1씩 조정
+        elif array[mid] < elem:
+            left = mid + 1
+        #중간 값이 찾고자 하는 값보다 크다면, 오른쪽 범위를 중간 값의 왼쪽으로 1씩 조정
+        else:
+            right = mid - 1
+    return 0
+
+#입력으로부터 정수 n 받기
+n = int(input())
+a_list = list(map(int, input().split()))
+#입력으로부터 정수 m 받기
+m = int(input())
+x_list = list(map(int, input().split()))
+
+#리스트 정렬
+a_list.sort()
+
+for x in x_list:
+    print(binary_search(a_list, x))

02주차/2110번.py

@@ -0,0 +1,38 @@
+import sys
+
+input = sys.stdin.readline
+# map 함수를 사용하여 입력된 값을 공백 기준으로 나눈 결과를 정수로 변환하여 각각 저장
+N, C = map(int, input().split())
+#N개의 집 좌표를 입력받고, 각 좌표를 정수로 변환 후 sorted 함수로 정렬하여 home에 저장
+home = sorted([int(input()) for _ in range(N)])
+
+# 공유기가 설치될 수 있는 최대 거리를 받아 해당 거리로 공유기를 설치했을 때의 개수를 세는 함수를 정의
+# count 는 공유기의 개수 저장, current 는 현재 집의 좌표
+def count_routers(distance):
+    count, current = 1, home[0]
+
+    for h in home:
+        if h - current >= distance:
+            count += 1
+            current = h
+
+    return count
+
+# 이진 탐색을 위한 시작점과 끝점 설정, 시작점은 항상 1, 끝점은 정렬된 집의 좌표 중 가장 뒤에 있는 좌표에서 가장 앞에 있는 좌표를 뺀 값
+start, end = 1, home[-1] - home[0]
+# result 는 공유기 사이의 최대 거
+result = 0
+
+# 시작점이 끝점보다 작거나 같은 동안 계속 반복, 중간지점 mid 계산
+while start <= end:
+    mid = (start + end) // 2
+
+# 중간 지점으로 공유기를 설치했을 때의 개수가 목표 개수보다 크거나 같다면, 현재의 중간 값을 결과로 저장
+    # 시작점을 중간값보다 +1로 갱신, 그렇지 않다면 끝점을 중간 값보다 -1로 갱신
+    if count_routers(mid) >= C:
+        result = mid
+        start = mid + 1
+    else:
+        end = mid - 1
+
+print(result)

03주차/1260번.py

@@ -0,0 +1,47 @@
+from collections import deque
+
+#그래프, 시작노드, 방문 여부 나타내는 배열을 인자로 받기 - 깊이 우선 탐색
+def dfs(graph, start, visited):
+    print(start, end=' ')
+    visited[start] = True #노드 방문 완료
+
+# 현재 노드에 연결된 이웃 노드들 순회 (정렬된 순서로 방문하기 위해 sorted()함수 사용)
+    for neighbor in sorted(graph[start]):
+        if not visited[neighbor]:
+            dfs(graph, neighbor, visited) # 이웃 노드가 방문되지 않을 시 DFS 함수를 재귀적으로 호출하여 해당 이웃 방문
+# 너비 우선 탐색
+def bfs(graph, start, visited):
+    queue = deque([start]) # BFS에서 사용할 큐 초기화 - 시작 노드로 큐 초기화
+    visited[start] = True
+
+    while queue: # 큐가 비어 있지 않는 동안 반복
+        node = queue.popleft()  # 큐의 맨 앞에서 노드 꺼내기
+        print(node, end=' ') #현재 노드를 출력
+
+        for neighbor in sorted(graph[node]):
+            if not visited[neighbor]:
+                queue.append(neighbor)
+                visited[neighbor] = True
+
+# 입력 받기 (정점의 개수 - N, 간선의 개수 - M, 시작 노드 - V)
+N, M, V = map(int, input().split())
+
+# 1부터 N까지의 정점을 갖는 빈 그래프를 초기화
+graph = {i: set() for i in range(1, N + 1)}
+
+#간선 정보를 입력받아 양방향 그래프 만들기
+for _ in range(M):
+    a, b = map(int, input().split())
+    graph[a].add(b)
+    graph[b].add(a)
+
+# DFS와 BFS에서 사용할 방문 여부를 나타내는 배열을 초기화
+visited_dfs = [False] * (N + 1)
+visited_bfs = [False] * (N + 1)
+
+# DFS 수행
+dfs(graph, V, visited_dfs)
+print()
+
+# BFS 수행
+bfs(graph, V, visited_bfs)

04주차/11047번.py

@@ -0,0 +1,20 @@
+def min_coin_count(N, K, coin_values):
+    count = 0
+
+    # 가장 큰 가치의 동전부터 차례로 사용하여 K를 만듦
+    for i in range(N-1, -1, -1):
+        if K == 0:
+            break
+        if K >= coin_values[i]:
+            count += K // coin_values[i]
+            K %= coin_values[i]
+
+    return count
+
+# 입력 받기
+N, K = map(int, input().split())
+coin_values = [int(input()) for _ in range(N)]
+
+# 필요한 동전 개수의 최솟값 계산 및 출력
+result = min_coin_count(N, K, coin_values)
+print(result)

04주차/2875번.py

@@ -0,0 +1,17 @@
+def max_teams(N, M, K):
+    # 가능한 최대 팀 수 계산
+    teams = 0
+
+    # 여학생과 남학생 중 적은 수의 인원을 기준으로 팀을 구성
+    while N >= 2 and M >= 1 and N + M >= K + 3:
+        N -= 2
+        M -= 1
+        teams += 1
+
+    return teams
+# 입력 받기
+N, M, K = map(int, input().split())
+
+# 최대 팀 수 계산 및 출력
+result = max_teams(N, M, K)
+print(result)

07주차 미로탐색_bfs_dfs/README.md

@@ -0,0 +1,10 @@
+숙제
+|난이도|번호|제목|링크|
+|-----|-----|----------|----------------------------------------|
+|실버 1|2178번|미로 탐색|https://www.acmicpc.net/problem/2178|
+|실버 3|2606번|바이러스|https://www.acmicpc.net/problem/2606|
+
+스터디 진행 중 풀이
+|난이도|번호|제목|링크|
+|-----|-----|----------|----------------------------------------|
+|실버 2|1012번|유기농 배추|https://www.acmicpc.net/problem/1012|

07주차 미로탐색_bfs_dfs/김서영/1012.py

@@ -0,0 +1,40 @@
+T = int(input()) #테스트케이스의 개수
+
+dx = [-1,1,0,0]
+dy = [0,0,-1,1]
+
+def BFS(x,y):
+    queue = [(x,y)]
+    matrix[x][y] = 0 # 방문처리
+
+    while queue:
+        x,y = queue.pop(0)
+
+        for i in range(4):
+            nx = x + dx[i]
+            ny = y + dy[i]
+
+            if nx < 0 or nx >= M or ny < 0 or ny >= N:
+                continue
+
+            if matrix[nx][ny] == 1 :
+                queue.append((nx,ny))
+                matrix[nx][ny] = 0
+
+# 행렬만들기
+for i in range(T):
+    M, N, K = map(int,input().split())
+    matrix = [[0]*(N) for _ in range(M)]
+    cnt = 0
+
+    for j in range(K):
+        x,y = map(int, input().split())
+        matrix[x][y] = 1
+
+    for a in range(M):
+        for b in range(N):
+            if matrix[a][b] == 1:
+                BFS(a,b)
+                cnt += 1
+
+    print(cnt)

07주차 미로탐색_bfs_dfs/김서영/README.md

@@ -0,0 +1 @@
+

07주차 미로탐색_bfs_dfs/민기홍/1012.py

@@ -0,0 +1,40 @@
+T = int(input()) #테스트케이스의 개수
+
+dx = [-1,1,0,0]
+dy = [0,0,-1,1]
+
+def BFS(x,y):
+    queue = [(x,y)]
+    matrix[x][y] = 0 # 방문처리
+
+    while queue:
+        x,y = queue.pop(0)
+
+        for i in range(4):
+            nx = x + dx[i]
+            ny = y + dy[i]
+
+            if nx < 0 or nx >= M or ny < 0 or ny >= N:
+                continue
+
+            if matrix[nx][ny] == 1 :
+                queue.append((nx,ny))
+                matrix[nx][ny] = 0
+
+# 행렬만들기
+for i in range(T):
+    M, N, K = map(int,input().split())
+    matrix = [[0]*(N) for _ in range(M)]
+    cnt = 0
+
+    for j in range(K):
+        x,y = map(int, input().split())
+        matrix[x][y] = 1
+
+    for a in range(M):
+        for b in range(N):
+            if matrix[a][b] == 1:
+                BFS(a,b)
+                cnt += 1
+
+    print(cnt)