sangwook park / 19주차

woogieon8on/chap10/boj/1325.py

@@ -0,0 +1,41 @@
+from collections import deque
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+computer = [[] for _ in range(n+1)] # 각 컴퓨터가 해킹할 수 있는 컴퓨터 리스트
+
+for _ in range(m):
+    a, b = map(int,input().split())
+    computer[b].append(a) # A가 B를 신뢰함 -> B를 해킹하면 A도 해킹 가능
+
+def bfs(i):
+    visited = [0] * (n + 1)
+    queue = deque([i])
+    visited[i] = 1
+    cnt = 1 # 해킹할 수 있는 컴퓨터 수 (자기 자신 포함)
+
+    while queue:
+        x = queue.popleft()
+
+        for nx in computer[x]: # 해당 컴퓨터와 신뢰 관계에 있는 모든 컴퓨터
+            if not visited[nx]: # 방문하지 않은 경우
+                queue.append(nx) # 큐에 추가
+                visited[nx] = 1 # 방문 처리
+                cnt += 1 # 해킹할 수 있는 컴퓨터 수 증가
+
+    return cnt
+
+answer = [] # 해킹할 수 있는 컴퓨터 수가 최대인 컴퓨터 리스트
+max_hack = 0 # 최대 해킹 수
+
+for i in range(1, n+1):
+    result = bfs(i)
+    if max_hack < result: # 최대 해킹 수가 더 높은 경우 갱신
+        max_hack = result
+        answer.clear() # 기존 답 리스트 초기화
+        answer.append(i) # 리스트에 추가
+    elif max_hack == result: # 최대 해킹 수가 동일한 경우
+        answer.append(i) # 기존 답 리스트 초기화 없이 리스트에 추가
+
+print(*answer)

woogieon8on/chap10/boj/1446.py

@@ -0,0 +1,35 @@
+import heapq
+import sys
+input = sys.stdin.readline
+INF = int(1e9)
+
+n, d = map(int, input().split())
+
+graph = [[] for i in range(d+1)]
+distance = [INF] * (d+1)
+
+for i in range(d): # 고속도로 길이를 구성하는 0부터 d까지 모든 수를 각각 하나의 노드라고 가정
+    graph[i].append((i+1, 1)) # 각 노드의 가중치 1로 설정
+
+for _ in range(n): # 기존 그래프에 지름길 추가
+    start, destination, length = map(int, input().split())
+    if destination<=d: # 도착 지점이 고속도로 끝(d)보다 큰 경우는 제외
+        graph[start].append((destination, length))
+
+def dijkstra(start): # 다익스트라 알고리즘
+    q = []
+    heapq.heappush(q, (0, start))
+    distance[start] = 0
+
+    while q:
+        dist, now = heapq.heappop(q)
+
+        for i in graph[now]: # 현재 노드와 연결된 다른 인접한 노드들 확인
+            cost = distance[now] + i[1]
+            if cost < distance[i[0]]: # 지름길을 거쳐 다른 노드로 이동할 때 거리가 더 짧은 경우
+                distance[i[0]] = cost
+                heapq.heappush(q, (cost, i[0]))
+
+dijkstra(0)
+
+print(distance[d])

woogieon8on/chap10/boj/14502.py

@@ -0,0 +1,64 @@
+from collections import deque
+import copy
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+graph = []
+dx = [0, 0, 1, -1]
+dy = [1, -1, 0, 0]
+
+# 바이러스는 벽(1)을 제외한 모든 영역을 향하여 BFS를 통해 자신을 감염시킴
+def bfs():
+    queue = deque()
+    tmp_graph = copy.deepcopy(graph) # 원래의 graph 유지
+
+    # 바이러스(2)를 큐에 넣음
+    for i in range(n):
+        for j in range(m):
+            if tmp_graph[i][j] == 2:
+                queue.append((i, j))
+
+    # 감염 시작
+    while queue:
+        x, y = queue.popleft()
+
+        for i in range(4):
+            nx = x + dx[i]
+            ny = y + dy[i]
+
+            if nx < 0 or nx >= n or ny < 0 or ny >= m: # 범위 확인
+                continue
+            if tmp_graph[nx][ny] == 0: # 감염 가능 여부, 즉 해당 칸이 0인지 확인
+                tmp_graph[nx][ny] = 2
+                queue.append((nx, ny))
+
+    global answer
+    cnt = 0
+
+    # 안전 영역(0) 카운트
+    for i in range(n):
+        cnt += tmp_graph[i].count(0)
+
+    answer = max(answer, cnt) # 안전 영역 크기 최대값 갱신
+
+# 벽을 세우고, 3개의 벽을 모두 세워 안전 영역이 확정되면 그 개수를 세기 위해 BFS 사용
+def makeWall(cnt):
+    if cnt == 3: # 3개의 벽을 모두 세우면 BFS 사용하여 바이러스 감염 시작
+        bfs()
+        return
+
+    # 벽을 세우는 모든 경우의 수 검토(백트래킹)
+    for i in range(n):
+        for j in range(m):
+            if graph[i][j] == 0: # 벽 설치 가능 여부 확인
+                graph[i][j] = 1 # 벽 설치
+                makeWall(cnt+1) # 두번째 벽 설치하기 위해 makeWall() 재귀 호출
+                graph[i][j] = 0 # 벽 제거
+
+for i in range(n):
+    graph.append(list(map(int, input().split())))
+
+answer = 0
+makeWall(0)
+print(answer)

woogieon8on/chap10/boj/2660.py

@@ -0,0 +1,44 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+n = int(input())
+members = [[] for _ in range(n+1)] # 회원별 친구 리스트
+count = [0] * (n+1)
+
+while True:
+    a, b = map(int, input().split())
+    if a == -1 and b == -1: # 마지막 줄
+        break
+    else:
+        members[a].append(b)
+        members[b].append(a)
+
+def bfs(v):
+    queue = deque()
+    queue.append([v, 0]) # 회원 번호, 현재 깊이 큐에 추가
+    visited[v] = True
+
+    while queue:
+        x, y = queue.popleft()
+
+        for i in members[x]: # 현재 회원과 친구 관계인 모든 회원들
+            if not visited[i]: # 방문하지 않은 경우
+                visited[i] = True
+                queue.append([i, y+1]) # 깊이를 1 증가시켜 큐에 추가
+
+    count[v] = y # bfs 종료 후 해당 회원의 최대 깊이를 점수로 저장
+
+for i in range(1, n+1):
+    visited = [False] * (n+1)
+    bfs(i) # 각 회원에 대해 bfs 수행
+
+count.pop(0) # 회원번호 0 제거
+answer = [] # 회장 후보 리스트
+
+for i in range(n): # 최소 점수 가진 회원 찾기
+    if count[i] == min(count):
+        answer.append(i+1)
+
+print(min(count), count.count(min(count))) # 최소 점수와 그 점수를 가진 회원 수 출력
+print(*answer) # 회장 후보 회원 번호 출력

woogieon8on/chap10/boj/5567.py

@@ -0,0 +1,32 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+n = int(input())
+m = int(input())
+graph = [[0] * (n+1) for i in range(n+1)] # 친구 관계 그래프
+visited = [0 for _ in range(n+1)] # 방문 여부 -> 상근이와의 거리
+
+for i in range(m):
+    a,b = map(int, input().split())
+    graph[a].append(b)
+    graph[b].append(a)
+
+def bfs(x):
+    queue = deque([x]) # x: 시작점
+    visited[x] = 1
+
+    while queue:
+        friend_num = queue.popleft()
+        for people_num in graph[friend_num]: # 해당 친구에게 연결된 모든 사람에 대해
+            if visited[people_num] == 0: # 아직 방문하지 않은 경우
+                queue.append(people_num) # 큐에 추가
+                visited[people_num] = visited[friend_num] + 1 # 상근이로부터의 거리 기록
+
+bfs(1) # 1번 인덱스: 상근이
+result = 0
+for i in range(2, n+1):
+    if 0 < visited[i] <= 3: # 상근이로부터의 거리가 3 이하인 친구들만 추가
+        result += 1
+
+print(result)

woogieon8on/chap3/boj/1080.py

@@ -0,0 +1,24 @@
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+a = [list(map(int, list(input().strip()))) for _ in range(n)]
+b = [list(map(int, list(input().strip()))) for _ in range(n)]
+count = 0
+
+# 3x3 크기의 부분 행렬에 있는 모든 원소 뒤집는 메소드
+def convert(x, y, a):
+    for i in range(x, x+3):
+        for j in range(y, y+3):
+            a[i][j] = 1 - a[i][j] # 0 -> 1, 1 -> 0
+
+# convert 메소드 유의하여 범위 설정
+for i in range(n-2):
+    for j in range(m-2):
+        count += 1
+        convert(i, j, a)
+
+if a != b: # A를 B로 바꿀 수 없다면 -1 출력
+    print(-1)
+else:
+    print(count)

woogieon8on/chap3/boj/11000.py

@@ -0,0 +1,25 @@
+import sys
+import heapq
+imput = sys.stdin.readline
+
+n = int(input())
+time = [] # 강의 시간 정보 리스트
+
+for _ in range(n):
+    time.append(list(map(int, input().split())))
+
+time.sort(key = lambda x: (x[0], x[1])) # 강의 시작하는 시간 기준으로 정렬
+
+heap = [time[0][1]] # 첫 번째 강의의 종료 시간 힙에 추가
+for i in range(1,n):
+    # heap[0]: 가장 빨리 끝나는 강의의 종료 시간
+    # time[i][0]: 현재 강의의 시작 시간
+    # 가장 빨리 끝나는 강의의 종료 시간보다 현재 강의의 시작 시간이 크거나 같은 경우
+    # -> 강의실 재사용 가능
+    if heap[0] <= time[i][0]:
+        # 힙에서 가장 빨리 끝나는 강의의 종료 시간 제거
+        # 현재 강의의 종료 시간 힙에 추가하여 가장 빨리 끝나는 강의의 종료 시간 업데이트
+        heapq.heappop(heap)
+    heapq.heappush(heap, time[i][1])
+
+print(len(heap)) # 필요한 강의실 수

woogieon8on/chap4/boj/20006.py

@@ -0,0 +1,31 @@
+p, m = map(int,input().split())
+
+rooms = []
+
+for i in range(p):
+    l, n = input().split()
+
+    # 첫 플레이어 방 만들기
+    if not rooms:
+        rooms.append([[int(l),n]])
+        continue
+
+    enter = False
+    for room in rooms:
+        # 입장 가능한 방이 있으면 입장
+        if len(room) < m and room[0][0] - 10 <= int(l) <= room[0][0] + 10:
+            room.append([int(l),n])
+            enter = True
+            break
+	# 입장 가능한 방이 없는 경우 방 만들기
+    if not enter:
+        rooms.append([[int(l),n]])
+
+for room in rooms :
+    if len(room) == m:
+        print('Started!')
+    else:
+        print('Waiting!')
+
+    for l, n in room:
+        print(l, n)

woogieon8on/chap4/boj/2852.py

@@ -0,0 +1,30 @@
+N = int(input())
+
+score = {1: 0, 2: 0} # 득점 현황
+scoreTime = {1: 0, 2: 0} # 득점 시간
+leadTime = {1: 0, 2: 0} # 이기고 있던 시간
+lead = 0 # 리드중인 팀 / 0: 동점 상황
+
+for i in range(N):
+    # team, time 모두 int 형식으로 변환
+    team, time = input().split()
+    team = int(team)
+    minute, second = map(int, time.split(':'))
+    time = minute*60 + second
+    score[team] += 1
+
+    # 동점 상황에서 특정 팀이 득점한 경우
+    if lead == 0: 
+        scoreTime[team] = time
+        lead = team
+    # 입력받은 득점으로 동점이 된 경우
+    elif lead != 0 and score[1] == score[2]:
+        leadTime[lead] = time - scoreTime[lead] # 이기고 있던 시간 = 입력받은 득점 시간 - 이기고 있던 팀의 득점 시간
+        lead = 0
+
+# 입력 종료 후 이긴 팀이 있는 경우
+if lead != 0:
+    leadTime[lead] += 60*48 - scoreTime[lead] # (경기 종료 시간 - 이긴 팀의 득점 시간) 추가
+
+print("%02d:%02d" %(leadTime[1]//60, leadTime[1]%60))
+print("%02d:%02d" %(leadTime[2]//60, leadTime[2]%60))

woogieon8on/chap4/boj/8979.py

@@ -0,0 +1,19 @@
+N, K = map(int, input().split())
+
+medals = []
+for i in range(N):
+  medals.append(list(map(int, input().split()))) # 국가-메달 리스트 입력받기
+
+medals.sort() # 국가 순서로 정렬
+
+kCountry, kGold, kSilver, kBronze = medals[K-1] # K번째 국가 메달 리스트
+rank = 1
+
+for country, gold, silver, bronze in medals :
+  if country == K :
+    continue
+  # K번째 국가보다 잘한 국가 발견하면 등수 + 1
+  if gold > kGold or gold == kGold and silver > kSilver or gold == kGold and silver == kSilver and bronze > kBronze :
+    rank += 1
+
+print(rank)