Merge branch 'main' into 11-pu2rile

oesnuj/README.md

@@ -6,10 +6,11 @@
 | 2차시 | 2024.03.29 |  연결리스트  | [에디터](https://www.acmicpc.net/problem/1406)  | [#8](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/8) |
 | 3차시 | 2024.04.02 |  덱  | [카드 놓기](https://www.acmicpc.net/problem/18115)  | [#11](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/11) |
 | 4차시 | 2024.04.06 |  스택  | [옥상 정원 꾸미기](https://www.acmicpc.net/problem/6198)  | [#14](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/14) |
-| 5차시 | 2024.04.13 | 이분탐색  | [듣보잡](https://www.acmicpc.net/problem/1764)  | [#20](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/20) |
-| 6차시 | 2024.05.06 | 기하학  | [정사각형](https://www.acmicpc.net/problem/1485)  | [#22](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/22) |
+| 5차시 | 2024.04.13 | 이분 탐색  | [듣보잡](https://www.acmicpc.net/problem/1764)  | [#20](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/20) |
+| 6차시 | 2024.05.06 | 기하 | [정사각형](https://www.acmicpc.net/problem/1485)  | [#22](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/22) |
 | 7차시 | 2024.05.08 | 스택, 큐, 덱 | [queuestack](https://www.acmicpc.net/problem/24511)  | [#24](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/24) |
 | 8차시 | 2024.05.13 | 우선순위 큐 | [카드 정렬하기](https://www.acmicpc.net/problem/1715)  | [#27](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/27) |
 | 9차시 | 2024.05.30 | 구현 | [빙고](https://www.acmicpc.net/problem/2578)  | [#30](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/30) |
 | 10차시 | 2024.07.04 | 구현 | [상어초등학교](https://www.acmicpc.net/problem/21608)  | [#34](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/34) |
+| 11차시 | 2024.07.18 | 이분 탐색 | [랜선 자르기](https://www.acmicpc.net/problem/1654)  | [#38](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/38) |
 ---

oesnuj/구현/21608.js

@@ -74,5 +74,3 @@ function calcSatisfy(){
 		}
 	}
 	return result;
-}
-출처: https://oesnuj.tistory.com/entry/Nodejs-백준-Javascript-21608-상어-초등학교 [비트로 그리는 성장일기:티스토리]

oesnuj/이분 탐색/1654.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+bool check(vector <int>& v, int n, long long length);
+int binary_serach(vector <int>& v, int n);
+
+int main() {
+    int k, n;
+    cin >> k >> n;
+    vector <int> v(k);
+    for (auto& i : v) {
+        cin >> i;
+    }
+    cout << binary_serach(v, n);
+    return 0;
+}
+
+bool check(vector <int>& v, int n, long long length) {
+    int cnt = 0;
+    for (const auto& i : v) {
+        cnt += i / length;
+    }
+    return cnt >= n;
+}
+
+int binary_serach(vector <int>& v, int n) {
+    long long lo = 1, hi = 2147483648; //자를 수 있는 랜선의 범위
+    while (lo + 1 < hi) {
+        long long mid = (lo + hi) / 2;
+        if (check(v, n, mid)) lo = mid;
+        else hi = mid;
+    }
+    return lo;
+}

pu2rile/구현/오늘도 졌다.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+
+int main() {
+    int j[9];
+    int g[9];
+    int win = 0;
+    int j_score = 0;
+    int g_score = 0;
+
+    for (int i=0 ; i<9; i++) { //제미니스 점수 입력
+        scanf("%d", &j[i]);
+    }
+    for (int i=0 ; i<9; i++) { //걸리버스 점수 입력
+        scanf("%d", &g[i]);
+    }
+
+    for (int i=0 ; i<9; i++) {
+        j_score += j[i]; //제미니스 점수 누적합(j_score == 총 점수)
+        if (j_score > g_score) //점수 비교
+            win = 1; //제미니스가 이겼다면 win = 1
+        g_score += g[i]; //걸리버스 점수 누적합(g_score == 총 점수)
+    }
+    if (j_score < g_score && win == 1) //제미니스가 졌지만 제미니스가 이긴 적이 있다면(역전패)
+        printf("Yes\n");
+    else
+        printf("No\n");
+}

pu2rile/스택/화학식량.py

@@ -0,0 +1,22 @@
+chemical = input()
+stack = []
+atomic = {'H':1, 'C':12, 'O':16} # 원자량 딕셔너리
+
+for c in chemical:
+  if c =='(': 
+    stack.append(c)
+  elif c == 'H' or c == 'C' or c == 'O':
+    stack.append(atomic[c]) # 입력받은 원자의 원자량을 스택에 추가
+  elif c == ')':
+    temp = 0 # 닫는 괄호를 만나면 temp 초기화
+    while True:
+      if stack[-1] == '(': # 스택의 top이 여는 괄호면
+        stack.pop() # 스택에서 여는 괄호를 삭제
+        stack.append(temp) # 스택에 temp 추가
+        break
+      else:
+        temp += stack.pop() # 여는 괄호 전까지의 스택 안의 모든 값을 temp에 저장
+  else: # c가 숫자라면
+    stack.append(stack.pop()*int(c)) # 스택의 top 값과 숫자를 곱하여 스택에 추가
+
+print(sum(stack))

suhyun113/README.md

@@ -7,4 +7,8 @@
 | 3차시 | 2024.04.02 |  그리디  | [거스름돈](https://www.acmicpc.net/problem/14916)  | [#12](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/12) |
 | 4차시 | 2024.04.06 |  DP  | [피보나치 수 5](https://www.acmicpc.net/problem/10870)  | [#16](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/16) |
 | 5차시 | 2024.04.10 |  스택  | [크레인 인형 뽑기 게임](https://school.programmers.co.kr/learn/courses/30/lessons/64061)  | [#19](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/19) |
-| 6차시 | 2024.04.14 |  스택  | [컨트롤 제트](https://school.programmers.co.kr/learn/courses/30/lessons/120853)  | [#21](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/21) |
+| 6차시 | 2024.04.14 |  스택  | [컨트롤 제트](https://school.programmers.co.kr/learn/courses/30/lessons/120853)  | [#21](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/21) |
+| 7차시 | 2024.05.09 |  트리  | [원숭이 매달기](https://www.acmicpc.net/problem/2716)  | [#31](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/31) |
+| 8차시 | 2024.05.14 |  수학  | [어린 왕자](https://www.acmicpc.net/problem/1004)  | [#32](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/32) |
+| 9차시 | 2024.05.28 |  다익스트라  | [최소비용 구하기](https://www.acmicpc.net/problem/1916)  | [#33](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/33) |
+| 10차시 | 2024.07.13 |  플로이드-워셜  | [플로이드](https://www.acmicpc.net/problem/11404)  | [#36](https://github.com/AlgoLeadMe/AlgoLeadMe-10/pull/36) |

suhyun113/다익스트라/9-suhyun113.py

@@ -0,0 +1,36 @@
+# 1916 : 최소비용 구하기
+
+import heapq
+
+INF = float('inf') # 최대값 정의
+
+N = int(input()) # 도시의 개수(노드)
+M = int(input()) # 버스의 개수(에지)
+
+graph = [[] for _ in range(N+1)] # 그래프 인접 리스트로 초기화(방문하지 않은 노드들)
+distance = [INF] * (N+1) # 각 노드까지의 거리 무한대로 초기화
+
+for _ in range(M):
+    x, y, cost = map(int, input().split()) # x -> y 도시로 가는 데 필요한 비용 cost
+    graph[x].append([y, cost]) # 그래프에 에지 추가
+
+start, end = map(int, input().split()) # 출발, 도착 노드 입력 받기
+
+# 다익스트라 알고리즘
+def Dijkstra(start):
+    q = [] # 우선순위 큐 생성
+    heapq.heappush(q, [0, start]) # 출발할 도시 큐에 넣기([거리, 노드] 형태)
+    distance[start] = 0 # 시작 도시의 거리 0으로 초기화
+
+    while q: # 큐가 빌 때까지 반복
+        weight, node = heapq.heappop(q) # 현재 노드까지의 거리, 현재 노드(큐에서 가장 작은 값)
+        if distance[node] < weight: # 현재 노드가 이미 처리된 노드인지 확인
+            continue
+        for n, w in graph[node]:
+            cost = w + weight # 현재 노드를 통해 인접 노드까지 가는 새로운 거리 계산
+            if distance[n] > cost: # 새로운 거리가 기존에 저장된 거리보다 짧은지 확인
+                distance[n] = cost # 최단 거리 갱신
+                heapq.heappush(q, [cost, n]) # 인접 노드를 우선순위 큐에 추가
+
+Dijkstra(start)
+print(distance[end])

suhyun113/수학/8-suhyun113.cpp

@@ -0,0 +1,42 @@
+// 1004 : 어린 왕자
+
+#include <iostream>
+#include <cmath>
+using namespace std;
+
+int main() {
+    int T; // 테스트 케이스의 개수
+    int x1, y1, x2, y2; // 출발점, 도착점
+    int n; // 행성의 개수
+    int cx, cy, r; // 행성계의 중점과 반지름
+
+    cin >> T;
+    while(T--) {
+        cin >> x1 >> y1 >> x2 >> y2;
+        cin >> n;
+
+        int enter = 0; // 진입 횟수
+        int departure = 0; // 이탈 횟수
+        int count = 0; // 최종 진입/이탈 횟수
+
+        while(n--) {
+            cin >> cx >> cy >> r;
+            float startDistance = sqrt(pow(cx - x1, 2) + pow(cy - y1, 2)); // 출발점과 원 사이의 거리
+            float endDistance = sqrt(pow(cx - x2, 2) + pow(cy - y2, 2)); // 도착점과 원 사이의 거리
+
+            if (startDistance < r){  // 출발점이 원 내부에 있고, 
+                if (endDistance > r) { // 도착점이 원 외부에 있음
+                    departure++; // 출발점 포함하는 행성 -> 이탈 횟수 증가
+                }
+            }
+            if (startDistance > r) { // 출발점이 원 외부에 있고, 
+                if (endDistance < r) { // 도착점이 원 내부에 있음
+                    enter++; // 도착점 포함하는 행성 -> 진입 회수 증가
+                }
+            }
+        }
+        count = enter + departure; // 최종 진입/이탈 횟수
+        cout << count << endl; 
+    }
+    return 0;
+}

suhyun113/플로이드-워셜/10-suhyun113.py

@@ -0,0 +1,41 @@
+# 11404 : 플로이드
+import sys
+
+input = sys.stdin.readline
+INF = float('inf') # 최대값 정의
+
+# 노드의 개수(n)과 간선의 개수(m) 입력
+n = int(input()) # 도시의 개수 n
+m = int(input()) # 버스의 개수 m
+
+# 2차원 리스트 (그래프 표현) 만들고, 무한대로 초기화(플로이드-워셜 = 이차원 배열)
+graph = [[INF] * (n + 1) for _ in range(n + 1)]
+
+# i에서 j로 갈 수 없는 경우, 
+# 자기 자신에서 자기 자신으로 가는 비용은 0으로 초기화(대각선에 해당하는 부분))
+for i in range(1, n + 1):
+    for j in range(1, n + 1):
+        if i == j:
+            graph[i][j] = 0
+
+# 각 간선에 대한 정보를 입력받아, 그 값으로 초기화
+for _ in range(m):
+    # A -> B로 가는 비용을 C라고 설정
+    i, j, cost = map(int, input().split())
+    if graph[i][j] > cost: # 시작 도시와 도착 도시 연결하는 노선 하나가 x
+        graph[i][j] = cost
+
+# 점화식에 따라 플로이드 워셜 알고리즘을 수행(3중 for문)
+for k in range(1, n + 1):
+    for i in range(1, n + 1):
+        for j in range(1, n + 1):
+            graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j])
+
+# 수행된 결과를 출력
+for i in range(1, n + 1):
+    for j in range(1, n + 1):
+        if graph[i][j] == INF:
+            print(0, end=' ')
+        else:
+            print(graph[i][j], end=' ')
+    print()