Merge pull request #25 from Mingguriguri/minjeong

Minjeong / 5월 1주차 / 3문제 ( 스킬체크 포함: 5문제)

Author: Mingguriguri

minjeong/BruteForce/2024-05-06-[PGS]-#최소직사각형.py

@@ -0,0 +1,31 @@
+def solution(sizes):
+    widths = []
+    heights = []  
+    for i in range(len(sizes)):
+        if sizes[i][0] >= sizes[i][1]:
+            widths.append(sizes[i][0])
+            heights.append(sizes[i][1])
+        else:
+            widths.append(sizes[i][1])
+            heights.append(sizes[i][0])
+    answer = max(widths) * max(heights)
+    return answer
+'''
+# 다른 코드 A
+def solution(sizes):
+    return max(max(x) for x in sizes) * max(min(x) for x in sizes)
+
+'''
+
+'''
+# 다른 코드 B
+def solution(sizes):
+    row = 0
+    col = 0
+    for a, b in sizes:
+        if a < b:
+            a, b = b, a
+        row = max(row, a)
+        col = max(col, b)
+    return row * col
+'''

minjeong/BruteForce/2024-05-07-[PGS]-#카펫.py

@@ -0,0 +1,33 @@
+def solution(brown, yellow):
+    carpet_size = brown + yellow # 카펫의 전체 크기
+    
+    for w in range(1,int(carpet_size**0.5)+1): # 약수 범위 설정. 여기서 w는 너비를 의미함
+        if carpet_size % w == 0: # 약수라면
+            h = carpet_size // w # 전체 크기에서 너비로 나눈 값을 높이로 설정
+            
+            if (2*w + 2*h - 4 == brown) and ((w-2)*(h-2) == yellow): # 조건에 해당하는지 확인
+                return [max(w, h), min(w,h)] 
+                
+# # 다른 풀이 1            
+# def solution(brown, yellow):
+#     for i in range(1, int(yellow**(1/2))+1):
+#         if yellow % i == 0:
+#             if 2*(i + yellow//i) == brown-4:
+#                 return [yellow//i+2, i+2]
+            
+# # 다른 풀이2
+# import math
+# def solution(brown, yellow):
+#     w = ((brown+4)/2 + math.sqrt(((brown+4)/2)**2-4*(brown+yellow)))/2
+#     h = ((brown+4)/2 - math.sqrt(((brown+4)/2)**2-4*(brown+yellow)))/2
+#     return [w,h]
+
+# # 다른 풀이 3
+# def solution(brown, yellow):
+#     nm = brown + yellow
+#     for n in range(1, nm+1):
+#         if nm%n != 0:
+#             continue
+#         m = nm//n
+#         if (n-2)*(m-2) == yellow:
+#             return sorted([n, m], reverse = True)

minjeong/BruteForce/2024-05-09-[PGS]-#모의고사.py

@@ -0,0 +1,27 @@
+def solution(answers):
+    answer = []
+    p1 = [1, 2, 3, 4, 5] # 1번 수포자가 찍는 방식
+    p2 = [2, 1, 2, 3, 2, 4, 2, 5] # 2번 수포자가 찍는 방식
+    p3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5] # 3번 수포자가 찍는 방식
+    scores = [0, 0, 0] # 각각 1번, 2번, 3번의 점수를 담은 리스트
+    
+    for i in range(len(answers)): # 시험 문제의 정답 개수만큼 반복
+        # 정답인지 판별. 이때 찍는 방식의 크기를 넘어가면 나머지 연산을 이용해 반복할 수 있도록 처리
+        if p1[i%(len(p1))] == answers[i]:
+            scores[0] += 1
+        if p2[i%(len(p2))] == answers[i]:
+            scores[1] += 1
+        if p3[i%(len(p3))] == answers[i]:
+            scores[2] += 1
+
+    if scores.count(max(scores)) == 3: # 3명이 동점인 경우
+        answer = [1,2,3]
+    elif scores.count(max(scores)) == 2: # 2명이 동점인 경우
+        # 최고점 한 사람 찾은 후, 그 사람의 점수를 0점으로 바꾸고, 다시 최고점을 찾는다.
+        answer.append(scores.index(max(scores))+1) 
+        scores[scores.index(max(scores))] = 0
+        answer.append(scores.index(max(scores))+1)
+    else: # 최고점이 1명만 있는 경우
+        answer = [scores.index(max(scores))+1]
+        
+    return answer

minjeong/BruteForce/2024-05-10-[PGS]-#전력망을둘로나누기.py

@@ -0,0 +1,32 @@
+def dfs(start, graph, visited, check_link):
+    cnt = 1
+    visited[start] = True     # 방문 체크
+    for v in graph[start]:  # v에 연결되어 있는 다른 노드 탐색.
+        if visited[v] == False and check_link[start][v] == True: 
+            # 연결되어 있지만 방문한 적 없다면 -> DFS 호출하고, 반환값을 cnt에 누적해서 더함
+            cnt += dfs(v, graph, visited, check_link) 
+    return cnt
+    
+def solution(n, wires):
+    answer = float("inf")                           # answer 초기화
+    check_link = [[True]*(n+1) for _ in range(n+1)] # 끊은 간선인지 아닌지 체크하는 용도
+    graph = [[] for _ in range(n+1)]                # 송전탑 그래프
+    
+    # 그래프 연결
+    for u, v in wires:
+        graph[u].append(v)
+        graph[v].append(u)
+    
+    # 전력망 나누기
+    for a, b in wires:
+        # 1. 간선 정보를 확인하면서 a, b 그룹에 연결된 송전탑 개수를 세기 위해서 a에서 b로 가는 간선을 끊어본다.
+        visited = [False] * (n+1) 
+        check_link[a][b] = False                   # 양망향 연결 끊기
+        # 2. a와 b에 붙어있는 송전탑 개수
+        cnt_a = dfs(a, graph, visited, check_link) # a랑 붙어있는 송전탑 개수
+        cnt_b = dfs(b, graph, visited, check_link) # b랑 붙어있는 송전탑 개수
+        check_link[a][b] = True
+        
+        answer = min(answer, abs(cnt_a - cnt_b)) # 송전탑 개수의 차이(절대값) 가장 작은 걸로 저장함
+        
+    return answer 

minjeong/DFSBFS/2024-04-30-[백준]-#11724-연결요소의개수.py

@@ -0,0 +1,33 @@
+import sys
+sys.setrecursionlimit(10000) #재귀 limit 설정(파이썬 최대 깊이 늘리는 모듈 이용)
+
+# 1. DFS 함수
+def dfs(u):
+    visited[u] = True   # 방문표시
+    for v in graph[u]:  # 연결되어 있는 리스트 내 요소들도 방문 표시
+        if visited[v] == False:
+            visited[v] = True
+            dfs(v)      # 연결되어 있는 요소의 연결된 요소도 dfs로 탐색
+
+# 2. 입력 및 초기화
+input = sys.stdin.readline
+N, M = map(int, input().strip().split()) # N: 정점의 개수, M: 간선의 개수
+graph = [[] for _ in range(N+1)]        # 그래프 초기화
+visited = [False] * (N+1)               # 방문여부 리스트 초기화
+
+# 3. 그래프 만들기
+for _ in range(M):
+    u, v = map(int, input().strip().split()) # 양 끝점 u,v
+    graph[u].append(v)
+    graph[v].append(u)
+
+
+# 4. 연결 요소 개수 찾기
+cnt = 0
+for i in range(1, N+1):
+    if visited[i] == False:     
+        cnt += 1    # 첫 방문시에만 cnt에 +1
+        dfs(i)    
+
+# 5. 정답 출력
+print(cnt)

minjeong/DFSBFS/2024-05-02-[PGS]-고고학최고의발견.py

@@ -0,0 +1,37 @@
+from itertools import product
+
+
+def solution(clockHands):
+    answer = 9876543210
+    n = len(clockHands)
+
+    dy = [-1, 1, 0, 0, 0]
+    dx = [0, 0, -1, 1, 0]
+
+    def rotate(a, b, t, arr):
+        for k in range(5):
+            y, x = a + dy[k], b + dx[k]
+            if 0 <= y < n and 0 <= x < n:
+                arr[y][x] = (arr[y][x] + t) % 4
+
+    for case in product(range(4), repeat=n):    # 첫째줄 최대4번까지 회전 한다는 가정 하에 모든 경우의 수를 만든다.
+        arr = [i[:] for i in clockHands]    # 깊은 복사는 deepcopy 보다 slicing 이 빠름
+
+        for j in range(n):    # case 를 가지고 첫번째 줄만 회전 시킨다
+            rotate(0, j, case[j], arr)
+
+        result = sum(case)    # 첫번째 줄 조작 횟수의 합
+
+        for i in range(1, n):    # 두번째 줄부터 체크
+            for j in range(n):
+                if arr[i-1][j]:    # 12시 가있지 않은 시계만 조작
+                    temp = 4 - arr[i-1][j]    # 12시에 가도록 하기 위한 조작 횟수
+                    rotate(i, j, temp, arr)    # 회전
+                    result += temp    # 조작 횟수 누적
+
+        if sum(arr[n-1]):    # 마지막 라인에 12시를 향하지 않는 시계가 존재
+            continue    # pass
+
+        answer = min(answer, result)    # 시계가 모두 12시를 가리킨다면 answer을 최솟값으로 갱신
+
+    return answer

minjeong/DynamicProgramming/2024-05-02-[PGS]-#등굣길.py

@@ -0,0 +1,17 @@
+def solution(m, n, puddles):
+    puddles = [[q, p] for [p, q] in puddles]
+
+    # dp 초기화    
+    dp = [[0] * (m+1) for _ in range(n+1)]
+    dp[1][1] = 1
+
+    # 장애물 있는 경우가 아니면 dp에 누적하여 값 더하기
+    for i in range(1, n+1):
+        for j in range(1, m+1):
+            if [i, j] in puddles:
+                dp[i][j] = 0
+            else:
+                dp[i][j] += (dp[i-1][j] + dp[i][j-1])% 1000000007
+
+    # 정답 반환
+    return dp[n][m]

minjeong/Graph/2024-04-30-[백준]-#11724-연결요소의개수.py

@@ -0,0 +1,33 @@
+import sys
+sys.setrecursionlimit(10000) #재귀 limit 설정(파이썬 최대 깊이 늘리는 모듈 이용)
+
+# 1. DFS 함수
+def dfs(u):
+    visited[u] = True   # 방문표시
+    for v in graph[u]:  # 연결되어 있는 리스트 내 요소들도 방문 표시
+        if visited[v] == False:
+            visited[v] = True
+            dfs(v)      # 연결되어 있는 요소의 연결된 요소도 dfs로 탐색
+
+# 2. 입력 및 초기화
+input = sys.stdin.readline
+N, M = map(int, input().strip().split()) # N: 정점의 개수, M: 간선의 개수
+graph = [[] for _ in range(N+1)]        # 그래프 초기화
+visited = [False] * (N+1)               # 방문여부 리스트 초기화
+
+# 3. 그래프 만들기
+for _ in range(M):
+    u, v = map(int, input().strip().split()) # 양 끝점 u,v
+    graph[u].append(v)
+    graph[v].append(u)
+
+
+# 4. 연결 요소 개수 찾기
+cnt = 0
+for i in range(1, N+1):
+    if visited[i] == False:     
+        cnt += 1    # 첫 방문시에만 cnt에 +1
+        dfs(i)    
+
+# 5. 정답 출력
+print(cnt)

minjeong/Sort/2024-05-05-[PGS]-#K번째수.py

@@ -0,0 +1,15 @@
+def solution(array, commands):
+    answer = []
+    for i in range(len(commands)):
+        start = commands[i][0]-1
+        end = commands[i][1]
+        k = commands[i][2]-1
+        temp = array[start:end]
+        temp.sort()
+        answer.append(temp[k])
+    return answer
+'''
+# 다른 코드
+def solution(array, commands):
+    return [sorted(array[i-1:j])[k-1] for i,j,k in commands]
+'''

minjeong/Stack, Queue/2024-05-05-[PGS]-#같은숫자는싫어.py

@@ -0,0 +1,10 @@
+def solution(arr):
+    stack = []
+    for i in range(len(arr)):
+        if len(stack) == 0: # 스택이 비어 있다면 추가
+            stack.append(arr[i])
+        else: # 스택이 비어있지 않다면
+            if arr[i] != stack[-1]: # 가장 최근의 스택값과 현재 값을 비교하고, 다를 경우에만 스택에 추가
+                stack.append(arr[i])
+                
+    return stack