SMCodingStudy · Lanvizu · Jan 23, 2024 · Jan 18, 2024 · Jan 18, 2024 · Jan 19, 2024
diff --git a/.DS_Store b/.DS_Store
diff --git a/이코테 유형별 기출문제/07 이진 탐색/고정점찾기/준영.py b/이코테 유형별 기출문제/07 이진 탐색/고정점찾기/준영.py
@@ -0,0 +1,24 @@
+def binary_search(arr, start, end):
+
+    if start > end:
+        return None
+    mid = (start + end) // 2
+    while start <= end:
+        if arr[mid] == mid:
+            return mid
+        elif arr[mid] > mid:
+            return binary_search(arr, start, mid - 1)
+        else:
+            return binary_search(arr, mid + 1, end)
+
+
+N = int(input())
+
+arr = list(map(int, input().split()))
+
+index = binary_search(arr, 0, N-1)
+
+if index == None:
+    print(-1)
+else:
+    print(index)
diff --git a/이코테 유형별 기출문제/07 이진 탐색/정렬된배열에서특정수의개수구하기/준영.py b/이코테 유형별 기출문제/07 이진 탐색/정렬된배열에서특정수의개수구하기/준영.py
@@ -0,0 +1,104 @@
+from bisect import bisect_left, bisect_right
+
+# 내가 처음 풀었던 풀이
+N, x = map(int, input().split())
+
+arr = list(map(int, input().split()))
+
+# 배열에 x가 없는 경우 -1 출력
+
+# 이진 탐색을 이용하여 arr에서 x와 같은 수까지 start와 end를 늘려가다가 더 이상 같이 않을 때 멈추고 start와 end의 길이를 구함
+
+start = 0
+end = len(arr) - 1
+
+
+while start <= end:
+    # mid = (start + end) // 2
+    # print(mid)
+
+    # start < x
+    if arr[start] < x:
+        start += 1
+        # print("start, end:", start, end)
+        # if arr[start] == x:
+        #     break
+    # x < end
+    if arr[end] > x:
+        end -= 1
+        # print("start, end:", start, end)
+        # if arr[end] == x:
+        #     break
+    if arr[end] == x and arr[start] == x:
+        break
+
+print(end - start + 1)
+print()
+
+##################################################################################
+# 이진 탐색을 이용한 풀이
+print("이진 탐색을 이용한 풀이")
+
+
+def binary_search(arr, x, find_first):
+    n = len(arr)
+    start = 0
+    end = n-1
+    result = -1
+
+    while start <= end:
+        mid = (start + end) // 2
+        if arr[mid] < x:
+            start = mid + 1
+        elif arr[mid] > x:
+            end = mid - 1
+        else:
+            result = mid
+            if find_first:
+                # x가 처음 등장하는 위치를 찾습니다.
+                end = mid - 1
+            else:
+                # x가 마지막으로 등장하는 위치를 찾습니다.
+                start = mid + 1
+    return result
+
+
+N, x = map(int, input().split())
+
+arr = list(map(int, input().split()))
+
+# 이진 탐색으로 첫 번째와 마지막 위치를 찾기
+first_position = binary_search(arr, x, True)
+last_position = binary_search(arr, x, False)
+
+# 결과 출력
+if first_position == -1 or last_position == -1:
+    print(-1)
+else:
+    print(last_position - first_position + 1)
+
+print()
+
+##################################################################################
+# bisect를 활용한 풀이
+
+
+def count_by_range(arr, left_value, right_value):
+    right_index = bisect_right(arr, right_value)
+    left_index = bisect_left(arr, left_value)
+    return right_index - left_index
+
+
+N, x = map(int, input().split())
+
+arr = list(map(int, input().split()))
+
+# 값이 [x, x] 범위에 있는 데이터의 개수 계산
+count = count_by_range(arr, x, x)
+
+# 값이 x인 원소가 존재하지 않는다면
+if count == 0:
+    print(-1)
+# 값이 x인 원소가 존재한다면
+else:
+    print(count)
diff --git a/이코테/07 이진 탐색/떡볶이_떡_만들기/준영.py b/이코테/07 이진 탐색/떡볶이_떡_만들기/준영.py
@@ -0,0 +1,41 @@
+N, M = map(int, input().split())
+dduck = list(map(int, input().split()))
+
+dduck.sort()
+
+mid = max(dduck) // 2
+# print(mid)
+
+for i in range(0, len(dduck)):
+    sum = 0
+    res = dduck[i] - mid
+    sum += res
+    # print("sum:", sum)
+    if sum == M:
+        print(dduck[i])
+        break
+
+# 정답 코드 (이진 탐색)
+start = 0
+end = max(dduck)
+
+# 절단 위치
+result = 0
+
+while (start <= end):
+    # 총 잘리는 떡의 길이
+    total = 0
+    mid = (start + end) // 2
+
+    for i in dduck:
+        # 절단기 길이보다 떡 길이가 길면 절단 가능
+        if i > mid:
+            total += i - mid
+
+    if total < M:
+        end = mid - 1
+    else:
+        result = mid
+        start = mid + 1
+
+print(result)
diff --git a/이코테/08 다이나믹 프로그래밍/1로_만들기/유진.py b/이코테/08 다이나믹 프로그래밍/1로_만들기/유진.py
@@ -1,5 +1,6 @@
 x = int(input())
 d = [0] * 30001
+# 연산의 횟수를 저장.
 
 # 보텀업 방식
 for i in range(2, x + 1):

diff --git a/이코테/08 다이나믹 프로그래밍/1로_만들기/준영.py b/이코테/08 다이나믹 프로그래밍/1로_만들기/준영.py
@@ -0,0 +1,21 @@
+X = int(input())
+
+# 1~X까지 각각의 최단 거리를 기록하기 위해 크기가 30000인 배열을 만들고 0으로 초기화한다
+
+arr = [0] * 30001
+
+for i in range(2, X + 1):
+    # 이전요소까지의 바로 아래 단계까지 가는 거리를 더해주기 위해 1을 더함
+    arr[i] = arr[i-1] + 1
+
+    # 2로 나누어질때
+    if i % 2 == 0:
+        arr[i] = min(arr[i], arr[i//2] + 1)
+    # 3으로 나누어질때
+    if i % 3 == 0:
+        arr[i] = min(arr[i], arr[i//3] + 1)
+    # 5로 나누어질때
+    if i % 5 == 0:
+        arr[i] = min(arr[i], arr[i//5] + 1)
+
+print(arr[X])
diff --git a/이코테/08 다이나믹 프로그래밍/바닥_공사/유진.py b/이코테/08 다이나믹 프로그래밍/바닥_공사/유진.py
@@ -0,0 +1,19 @@
+n = int(input())
+d = [0] * 1001
+# 경우의 수를 저장
+
+# 점화식을 어떻게 세우지?
+# d[1], d[2]은 어떻게 처리할까
+# d[1]은 2 x 1로 1
+# d[2]은 2 x 2, 1 x 2로 2
+# 이후에는 
+# i - 1 까지 채워져 있으면 1개의 경우가 있음
+# i - 2 까지 채워져 있으면 2개의 경우가 있음
+# di = di-1 + di-2 * 2
+
+d[1] = 1
+d[2] = 2
+for i in range(3, n + 1):
+    d[i] = (d[i - 1] + d[i - 2] * 2) % 796796
+
+print(d[n])
diff --git a/이코테/08 다이나믹 프로그래밍/효율적인_화페_구성/유진.py b/이코테/08 다이나믹 프로그래밍/효율적인_화페_구성/유진.py
@@ -0,0 +1,26 @@
+import sys
+input = sys.stdin.readline
+
+n, m = 2, 15#map(int, input().split())
+money = [2, 3]
+#for _ in range(n):
+#    money.append(int(input()))
+
+d = [10001] * (m + 1)
+# 1로 만들기 + 거스름돈 문제 같은데
+# d를 10001개로 설정하는게 맞나? -> 1원이 있을 때? -> 화폐 단위별 개수를 저장하는 거라서 101개가 맞지 않을까
+# d[1] = m일 듯.
+# 점화식은?
+# di = min(d[i - 1], d[m//i])
+# 단단히 틀림. 
+# 왜 i - k 인가...
+d[0] = 0
+for i in range(n):
+    for j in range(money[i], m + 1):
+        if d[j - money[i]] != 10001:
+            d[j] = min(d[j], d[j - money[i]] + 1)
+
+if d[m] == 0:
+    print(-1)
+else:
+    print(d[m])
diff --git a/이코테/09 최단 경로/다익스트라.py b/이코테/09 최단 경로/다익스트라.py
@@ -23,10 +23,12 @@ def dijkstra(start):
 
     # 시작 노드로 가는 비용 0
     heapq.heappush(q, (0, start))
+    # 근데 큐에 넣는 것 만으로도 distance에 저장이 되나?
     distance[start] = 0
 
     while q: # q가 비어있지 않다면,
         # 최단 거리가 짧은 노드 꺼내기
+        # 거리, 지금 노드
         dist, now = heapq.heappop(q)
 
         # 이미 처리된 적 있는가?

diff --git a/이코테/09 최단 경로/미래_도시/유진.py b/이코테/09 최단 경로/미래_도시/유진.py
@@ -0,0 +1,28 @@
+INF = int(1e9)
+n, m = map(int, input().split())
+
+graph = [[INF] * (n + 1) for _ in range(n + 1)]
+
+# 자기 자신 0 
+for a in range(1, n + 1):
+    for b in range(1, n + 1):
+        if a == b:
+            graph[a][b] = 0
+
+for i in range(m):
+    a, b = map(int, input().split())
+    graph[a][b] = 1
+    graph[b][a] = 1 # 안썼었음
+
+x, k = map(int, input().split())
+
+for i in range(1, m + 1):
+    for a in range(1, m + 1):
+        for b in range(1, m + 1):
+            graph[a][b] = min(graph[a][b], graph[a][i] + graph[i][b])
+
+distance = graph[1][k] + graph[k][x]
+if distance == INF:
+    print(-1)
+else:
+    print(distance)
diff --git a/이코테/09 최단 경로/미래_도시/준영.py b/이코테/09 최단 경로/미래_도시/준영.py
@@ -0,0 +1,46 @@
+import sys
+input = sys.stdin.readline
+
+# 무한대 설정
+INF = int(1e9)
+
+# 회사의 개수 N, 경로의 개수 M
+N, M = map(int, input().split())
+
+company = [[INF] * (N+1) for _ in range(N+1)]
+# print(company)
+
+for i in range(1, N + 1):
+    for j in range(1, N + 1):
+        if i == j:
+            company[i][j] = 0
+
+for i in range(M):
+    x, y = map(int, input().split())
+    company[x][y] = 1
+    company[y][x] = 1
+
+# X와 K가 공백으로 구분되어 차례대로 주어진다 (1 <= K <= 100)
+X, K = map(int, input().split())
+
+for i in range(N):
+    for j in range(N):
+        print(company[i][j], end=' ')
+    print()
+
+# 여기까지 2차원 리스트에서 자기 자신까지의 거리는 0, 인접한 회사끼리는 1, 두 칸 이상 떨어진 회사는 INF로 초기화
+
+# 다음 과정은 두 칸 떨어진 회사까지의 거리를 테이블에 적용시켜야함
+
+for k in range(1, N + 1):
+    for a in range(1,  N + 1):
+        for b in range(1, N + 1):
+            company[a][b] = min(company[a][b], company[a][k] + company[k][b])
+
+# 결과 출력
+distance = company[1][k] + company[k][X]
+
+if distance >= INF:
+    print("-1")
+else:
+    print(distance)
diff --git a/이코테/09 최단 경로/전보/유진.py b/이코테/09 최단 경로/전보/유진.py
@@ -0,0 +1,49 @@
+import heapq, sys
+input = sys.stdin.readline
+INF = int(1e9)
+
+n, m, c = map(int, input().split())
+graph = [[] for i in range(n + 1)]
+distance = [INF] * (n + 1)
+
+# 간선들의 정보 입력받기
+for i in range(m):
+    x, y, z = map(int, input().split())
+    graph[x].append((y, z))
+
+# 다익스트라
+def dijkstra(start):
+    q = [] # 우선순위 큐
+
+    heapq.heappush(q, (0, start))
+    # 시작지점 거리 0
+    distance[start] = 0
+
+    while q:
+        dist, now = heapq.heappop(q)
+
+        # 이미 처리했다면,
+        if distance[now] < dist:
+            continue
+
+        # 지금 위치에서 비용계산을 하면
+        for i in graph[now]:
+            cost = dist + i[1]
+
+            # 다른 노드를 거치는게 더 적게 걸린다면, 
+            if cost < distance[i[0]]:
+                heapq.heappush(q, (cost, i[0]))
+dijkstra(c) # 다익스트라 함수 실행
+
+# C와 연결된 도시 갯수 세기
+count = 0
+
+# 전보가 가는 시간 측정
+# -> 총 걸리는 시간 = 가장 오래 걸리는 시간을 측정해야하는데 최댓값을 뽑아야 하나?
+time = 0
+for i in distance:
+    if i != INF:
+        count += 1
+        time = max(time, i)
+
+print(count - 1, time) # 시작노드 제외해야 해서 -1 해줘야 하는데 안함