Merge branch '24-Algorithm:main' into main

Author: YoonYn9915

.DS_Store

@@ -0,0 +1,35 @@
+"""
+실패
+1. 가장 큰 자리수 비교 -> 자리수 가장 작은 수
+0. graph
+idx : numbers
+value : [0,0,0,-1] # ex 62 => [6,2,False,False]
+# 조건 2.
+3,30,300 비교 -> 3 > 30> 300 우선순위
+#반례
+1) 110 vs 1 > 1+110
+2) [12, 1213] -> 1213+12
+"""
+
+def solution(numbers):
+    answer = ''
+    #0. graph 만들기
+    graph = list()
+    for n in numbers:
+        p =  4-len(str(n))
+        if p >  0 : 
+            douple_n = str(n)*p
+        else :
+            douple_n = str(n)
+        graph.append([douple_n[:4], p ]) # 자리수 맞춰주기(4자리)
+    # print(graph)
+    #2.정렬 : 높은 자리수의 값이 큰 순서 대로
+    graph.sort(key=lambda x : x[0] , reverse = True)
+    # print(graph)
+    #3. 합치기
+    answer=""
+    for i in range(len(graph)):
+        num = graph[i][0] ; position = 4-graph[i][1]
+        answer += str(int(num[:position]))# "000","0" 경우 0으로 처리
+    
+    return answer

Hongjoo/lv2/가장큰수.py

@@ -0,0 +1,27 @@
+"""
+# 계수 정렬 idea 적용
+"""
+
+def solution(topping):
+    answer = 0 # 공평하게 자를 수 있는 경우의 수
+    # 0, graph
+    forward = set()
+    backward = dict()
+    # 1. key 종류, value: toppping 중복 개수
+    for t in topping:
+        backward[str(t)]= backward.get(str(t),0)
+        backward[str(t)] += 1
+    print(backward)
+    #2. forward vs backward
+    for t in topping :
+        # f 에서 t가 추가됨 == b에서 t 빠짐
+        forward.add(t)
+        backward[str(t)] -=1
+        if backward[str(t)] == 0 :
+            del backward[str(t)]
+        
+        # 토핑 종류 같은 경우 = 공평 한 경우
+        if len(forward) == len(backward.keys()):
+            answer+=1
+        
+    return answer

Hongjoo/lv2/롤케이크자르기.py

@@ -0,0 +1,49 @@
+"""
+시작 = 1 
+if 시작 ~ # 노드(N개) 까지의 최단 거리 <= K : 배달 가능True 
+다익스트라 
+"""
+import heapq
+INF = 2001
+
+def dikstra(graph, distance, start) :
+    #2. distance 초기화 : (0,start)로 초기화 / q에 (0,start 넣기)
+    q= []
+    distance[start] = 0
+    heapq.heappush(q,(0,start))
+    #3. q에서 최단 거리(start -> X)  & 방문x 노드 선택  
+    while q :
+        dist , now = heapq.heappop(q) # A->X
+        if distance[now] < dist: # 방문 완료
+            continue
+        #4. Cost(X->B)계산 + Cost(A->X) < Cost(A->B) => distance 업데이트 + q에 넣기
+        #  graph 인접 간선(i[1]) , dist, 현distance[B]
+        for i in graph[now]: # i = (b,c)....
+            cost = dist + i[1] 
+            if cost < distance[i[0]] :
+                distance[i[0]] = cost 
+                heapq.heappush(q,(cost,i[0]))
+    return distance
+
+def solution(N, road, K):
+    # input 
+    graph = [[] for _ in range(N+1)] 
+    distance = [INF]*(N+1) # 최단거리 그래프
+    
+    #0 그래프 필드 정의 a : [(b,c)...]  #양방향
+    road.sort()    
+    for r in road : 
+        a=r[0] ; b = r[1] ; c= r[2]
+        graph[a].append([b,c])
+        graph[b].append([a,c])
+
+    # 다익스트라
+    distance = dikstra(graph ,distance, 1)
+  
+    # 거리 < K 인 마을 개수
+    count = 0
+    for city in range(1, N+1) :
+        if distance[city] <= K : 
+            count+=1
+    return count
+        

Hongjoo/lv2/배달.py

@@ -0,0 +1,7 @@
+def solution(s):
+    answer = ''
+    li = list(map(int,s.split(" ")))
+    li.sort() # 오름 차순 정렬
+    answer= str(li[0]) + " "+str(li[-1]) #"최소 최대"
+    # print(answer)
+    return answer

Hongjoo/lv2/최대값최소값.py

@@ -0,0 +1,49 @@
+"""
+4 4 2 1  # 도시 개수 n , 도로 개수 m , 거리 정보 k , 출발 도시 번호 x 
+1 2
+1 3
+2 3
+2 4 # 2~m 번 a -> b
+다익스트라
+"""
+import heapq
+#0 input
+INF = 20000
+city_count , road_count , target_km , start =map(int,input().split())
+
+#1. graph 그리기 -> 인접 리스트 방식 , 최단거리 테이블
+graph = [[] for i in range(city_count+1) ]
+distance = [INF]* (city_count+1)
+
+for _ in range(road_count):
+    a,b = map(int, input().split()) 
+   # a -> b ,b 는 a 에서 갈수 있는 인접한 city  
+    for j in range(len(graph)):
+        if  a == j:
+            graph[a].append((b,1))
+
+
+# 다익스트라
+#1. 초기 노드 설정  #2. 최단거리 테이블 최기화
+q =[]
+distance[start]=0
+heapq.heappush(q, (0,start))
+# 2. 최단 거리(heappop) & 방문 x  노드 선택
+while q : 
+    dist , now = heapq.heappop(q)
+    if distance[now] < dist :
+        continue
+    #4, Cost(A->X) + Cost(X->B) < Cost(A->B) : 업데이트 & push
+    for i in graph[now]:
+        cost = dist + i[1]
+        if cost < distance[i[0]] :
+            distance[i[0]] = cost
+            heapq.heappush(q,(cost,i[0]))
+           
+islenK = False
+for i in range(1, city_count+1):
+    if distance[i] == target_km :
+        islenK = True
+        print(i)
+if not islenK :
+    print(-1)

Hongjoo/백준/특정거리의도시찾기.py

@@ -0,0 +1,35 @@
+INF = int(1e9) #무한을 나타내는 갑스올  10억 설정
+
+# 노드 개수 & 간선의 개수 입력
+n = int(input())
+m = int(input())
+#1. graph 설정 -인접 행렬(2차원 , nxn ) , 초기화
+graph = [[INF]*(n+1) for _ in range(n+1)]
+
+#1-1. 자기 자신에서 자기 자신 가는 비용 {Cost (A->A)}= 0 초기화
+for a in range(1,n+1) :
+    for b in range(1,n+1):
+        if a==b:
+            graph[a][a] = 0
+
+#1-2 .각 간선에 대한 정보를 입력 받아, 그 값으로 초기화 :   Cost(A->B) = 초기값
+for _ in range(m):
+    # Cost(A->B) = c
+    a,b,c = map(int, input().split())
+    graph[a][b]= c
+
+#2. 플로이드 워샬 점화식 수행
+# a->b : a->k->b vs a->b
+for k in range(1,n+1):   
+    for a in range(1,n+1):
+        for b in range(1,n+1):
+            graph[a][b] = min(graph[a][b], graph[a][k]+ graph[k][b])
+
+# 출력
+for a in range(1,n+1):
+    for b in range(1,n+1):
+        if graph[a][b] == INF :
+            print("INF", end="")
+        else :
+            print(graph[a][b], end ="")
+print()

Hongjoo/백준/플로이드와샬.py

@@ -0,0 +1,41 @@
+import sys
+from collections import deque
+sys.setrecursionlimit(10**5) # 최대 재귀한도 깊이
+input = sys.stdin.readline
+
+# dfs 함수 정의
+def dfs(start):
+    print(start, end=' ')   # 해당 값을 출력한다.
+    dfs_visited[start] = 1  # 해당 값을 방문처리한다.
+    for u in sorted(graph[start]):  # 해당 값과 연결되어 있고, 방문하지 않았다면 재귀 탐색한다.
+        if not dfs_visited[u]:
+            dfs(u)
+
+# bfs 함수 정의
+def bfs(start):
+    queue = deque([start])
+
+    while queue:            # 큐가 빌 때까지 계속 반복
+        u = queue.popleft() # 첫번째 값을 꺼낸다.
+        if not bfs_visited[u]: # 해당 값을 방문하지 않았다면
+            print(u, end=' ')  # 값을 출력한다.
+            bfs_visited[u] = 1 # 방문 표시를 해준다.
+        for v in sorted(graph[u]):  # 해당 값과 연결되어 있고, 방문하지 않았다면 큐에 추가한다.
+            if not bfs_visited[v]:
+                queue.append(v)
+
+# 정점, 간선, 시작할 정점 초기화
+n, m, v = map(int, input().strip().split()) # n: 정점 개수 / m: 간선 개수 / v: 시작 번호
+dfs_visited = [0] * (n + 1)                 # DFS 방문 기록
+bfs_visited = [0] * (n + 1)                 # BFS 방문 기록
+graph = [[] for _ in range(n + 1)]          # 그래프 초기화
+
+# 그래프 연결
+for _ in range(m):
+    a, b = map(int, input().strip().split())
+    graph[a].append(b)
+    graph[b].append(a)
+
+dfs(v)  # DFS 함수 호출
+print() # 줄바꿈
+bfs(v)  # BFS 함수 호출

minjeong/DFSBFS/2024-07-21-[백준]-#1260-DFS와BFS.py

@@ -0,0 +1,20 @@
+def solution(record):
+    answer = []
+    dict = {}
+    
+    # 사용자 DB 딕셔너리
+    for i in range(len(record)):
+        temp = record[i].split()
+        if temp[0] == 'Enter' or temp[0] == 'Change':
+            dict[temp[1]] = temp[2]
+    
+    # Enter, Change, Leave 순회
+    for i in range(len(record)):
+        temp = record[i].split()
+        if temp[0] == 'Enter':
+            answer.append(f"{dict[temp[1]]}님이 들어왔습니다.")
+        elif temp[0] == 'Leave':
+            answer.append(f"{dict[temp[1]]}님이 나갔습니다.")
+
+        
+    return answer

minjeong/HashMap/2024-07-20-[PGS]-#오픈채팅방.py

@@ -0,0 +1,30 @@
+import sys
+sys.setrecursionlimit(10**6) # 최대 재귀한도 깊이
+input = sys.stdin.readline
+
+# 초기화
+n, m = map(int, input().strip().split()) # n: 수의 개수, m: 조건으로 주어진 합
+arr = list(map(int, input().strip().split())) # 수열
+
+prefix_sums = [0] * n
+prefix_sums[0] = arr[0]
+
+# 누적합 계산
+for i in range(1, n):
+    prefix_sums[i] = prefix_sums[i-1] + arr[i]
+
+# 나머지 값 빈도수를 저장할 해시맵
+mod_count = {}
+mod_count[0] = 1 # 처음부터 M으로 나누어 떨어지는 경우를 위해 초기화
+count = 0
+
+# 누적합 배열 순회ㅣ
+for p in prefix_sums:
+    mod = p % m
+    if mod in mod_count: # 동일한 나머지값이 있는 경우
+        count += mod_count[mod] # 해당 나머지 갑싀 빈도수만큼 count에 더해줌
+        mod_count[mod] += 1 # 해당 나머지 값의 빈도수 +1
+    else:
+        mod_count[mod] = 1 # 새로운 나머지 값 추가
+        
+print(count)