Merge pull request #59 from 24-Algorithm/minjeong

Minjeong / 9월 2-3주차 / 6문제

Author: YoonYn9915

.DS_Store

@@ -0,0 +1,25 @@
+n = int(input())
+origin = [int(n) for n in input().split()]  # 4,1,5,2,3
+m = int(input())
+compare = [int(m) for m in input().split()]  # 1,3,7,9,5
+
+origin.sort()  # 1,2,3,4,5
+
+for i in range(m):  #
+    tag = False
+    low = 0
+    high = len(origin) - 1
+    target = compare[i]  # 5
+    while low <= high:
+        mid = (low + high) // 2
+        if origin[mid] == target:
+            tag = True
+            print(1)
+            break
+        elif origin[mid] > target:
+            high = mid - 1
+        else:
+            low = mid + 1
+
+    if tag is False:
+        print(0)

minjeong/BinarySearch/2024-09-19-[백준]-#1920-수찾기.py

@@ -0,0 +1,50 @@
+# PGS. 2024 KAKAO WINTER INTERNSHIP - 가장 많이 받은 선물
+def solution(friends, gifts):
+    gift_map = {}  # 각 친구 쌍 간 선물 기록
+    send_count = {}  # 선물 준 횟수 딕셔너리
+    receive_count = {}  # 선물 받은 횟수 딕셔너리
+    gift_count = {}  # 선물 지수 딕셔너리
+    next_month_gift_cnt = {}  # 다음 달에 받을 선물의 개수를 친구들별로 저장하는 딕셔너리
+
+    for friend in friends: # 초기화
+        gift_map[friend] = {}
+        send_count[friend] = 0
+        receive_count[friend] = 0
+        gift_count[friend] = 0
+        next_month_gift_cnt[friend] = 0
+
+    # 선물 기록 분석(각 친구 간에 누가 몇 번 선물을 주고받았는지)
+    for gift in gifts:
+        sender, receiver = gift.split()
+        if receiver not in gift_map[sender]: # 해당 친구 간의 기록이 없다면 0으로 초기화
+            gift_map[sender][receiver] = 0
+        if sender not in gift_map[receiver]: # 해당 친구 간의 기록이 없다면 0으로 초기화
+            gift_map[receiver][sender] = 0
+        gift_map[sender][receiver] += 1 # sender가 receiver에게 선물한 횟수 +1
+
+        send_count[sender] += 1         # sender가 준 선물 횟수 +1
+        receive_count[receiver] += 1    # receiver가 받은 선물 횟수 +1
+
+    # 선물 지수 계산
+    for friend in friends:
+        # 선물지수: 준 선물 수 - 받은 선물 수
+        gift_count[friend] = send_count[friend] - receive_count[friend]
+
+    # 모든 친구 쌍을 비교하여 다음 달에 받을 선물 수 계산
+    for i in range(len(friends)):
+        for j in range(i + 1, len(friends)):
+            A = friends[i]
+            B = friends[j]
+            if gift_map[A].get(B, 0) > gift_map[B].get(A, 0): # A>B이면, A가 다음달에 받음
+                next_month_gift_cnt[A] += 1
+            elif gift_map[A].get(B, 0) < gift_map[B].get(A, 0): #A<B이면, B가 다음달에 받음
+                next_month_gift_cnt[B] += 1
+            else:  # 두 사람이 주고받은 수가 같다면, 선물 지수가 더 큰 사람이 받음
+                if gift_count[A] > gift_count[B]:
+                    next_month_gift_cnt[A] += 1
+                elif gift_count[A] < gift_count[B]:
+                    next_month_gift_cnt[B] += 1
+                # 선물 지수도 같다면 아무도 받지 않음
+
+    # 가장 많이 받을 친구 반환
+    return max(next_month_gift_cnt.values())

minjeong/BruteForce/2024-09-12-[PGS]-가장많이받은선물.py

@@ -0,0 +1,35 @@
+'''
+양 모은 수보다 늑대의 수가 같거나 많아지면 종료됨
+부모 노드는 방문했지만 자식 노드는 방문하지 않았을 때 방문할 수 있음
+
+'''
+
+
+def solution(info, edges):
+    # info - 0: 양, 1: 늑대
+    global answer
+    answer = 0
+    visited = [False] * len(info)
+    visited[0] = True  # 0번 노드는 항상 양이 있음
+
+    def dfs(sheep, wolf):
+        global answer
+
+        if wolf < sheep:  # 양이 늑대보다 더 많으면 모을 수 있는 최대 양 마리 수 업데이트
+            answer = max(answer, sheep)
+        else:  # 늑대가 양의 수와 같거나 더 많을 경우 종료됨
+            return
+
+        for parent, child in edges:
+            # 부모 노드는 방문했지만 자식 노드는 방문하지 않았을 때
+            if visited[parent] and not visited[child]:
+                visited[child] = True
+                if info[child] == 0:  # 양이라면 양 마리 수 + 1
+                    dfs(sheep + 1, wolf)
+                else:  # 늑대라면 늑대 마리 수 + 1
+                    dfs(sheep, wolf + 1)
+                visited[child] = False
+
+    dfs(1, 0)  # (sheep, wolf)
+
+    return answer

minjeong/DFSBFS/2024-09-09-[PGS]-#양과늑대.py

@@ -0,0 +1,18 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input()) # 수 입력 받기
+t, p = [0 for _ in range(n + 1)], [0 for _ in range(n + 1)]
+for i in range(1, n + 1):
+    t[i], p[i] = map(int, input().split())
+dp = [0] * (n+1) #dp 리스트 초기화
+
+for i in range(1, n+1):
+    time = t[i]
+    pay = p[i]
+    day = i + time - 1
+    dp[i] = max(dp[i], dp[i - 1])  # 이전까지의 최댓값
+    if day <= n:
+        dp[day] = max(dp[day], dp[i-1]+pay)
+
+print(max(dp))

minjeong/DynamicProgramming/2024-09-21-[백준]-#15486-퇴사2.py

@@ -0,0 +1,51 @@
+import sys
+input = sys.stdin.readline
+
+
+def check_winner(x, y, color):
+    # 오목 4개 방향
+    directions = [(-1, 0), (0, -1), (-1, -1), (-1, 1)]
+    # (-1, 0) - 세로 방향 (위쪽)
+    # (0, -1) - 가로 방향 (왼쪽)
+    # (-1, -1) - 좌상향 대각선 방향
+    # (-1, 1) - 우상향 대각선 방향
+
+    for dx, dy in directions:
+        count = 1  # 현재 돌이 포함된 연속된 돌의 개수를 셀 변수 초기화
+
+        # 주어진 방향으로 연속된 돌 개수 세기
+        nx, ny = x + dx, y + dy
+        while 1 <= nx < 20 and 1 <= ny < 20 and board[nx][ny] == color:
+            count += 1
+            # 방향 dx, dy로 이동하며 해당 방향에 같은 색의 돌이 있는 한 계속 탐색
+            nx += dx
+            ny += dy
+
+        # 반대 방향으로도 연속된 돌 개수 세기
+        nx, ny = x - dx, y - dy
+        while 1 <= nx < 20 and 1 <= ny < 20 and board[nx][ny] == color:
+            count += 1
+            # 반대 방향으로도 이동하여 연속된 돌의 개수를 추가로 셈
+            nx -= dx
+            ny -= dy
+
+        # 5개일 경우만 승리로 인정
+        if count == 5:
+            return True
+
+    return False # 5개의 돌이 연속되지 않을 경우
+
+N = int(input().strip())  # 돌의 개수
+board = [[0] * 20 for _ in range(20)]  # 19x19 바둑판 / 바둑돌이 놓인 위치 기록 (1,1)~(19,19)
+
+# 입력된 좌표에 돌을 기록
+for i in range(N):
+    x, y = map(int, input().strip().split()) # 각 수의 좌표
+    color = 1 if i % 2 == 0 else 2 # 홀수 번째 수: 흑돌(1), 짝수 번째 수: 백돌(2)
+    board[x][y] = color # 해당 좌표에 돌을 놓음 (바둑판 배열에 기록)
+
+    if check_winner(x, y, color): # 현재 놓은 돌로 인해 승리가 결정되는지 확인
+        print(i + 1)              # 승리가 결정되면 현재 몇 번째 수인지 출력하고 프로그램 종료
+        sys.exit()
+
+print(-1) # 모든 돌을 놓았지만 승패가 결정되지 않으면 -1 출력

minjeong/Simulation/2024-09-04-[백준]-#2072-오목.py

@@ -0,0 +1,10 @@
+K = int(input())
+stack = []
+for i in range(K):
+    num = int(input())
+    stack.append(num)
+    if num == 0:
+        stack.pop()
+        stack.pop()
+
+print(sum(stack))