Merge branch 'main' of https://github.com/YoonYn9915/codingtest_algorithm_study

Author: YoonYn9915

.DS_Store

@@ -0,0 +1,25 @@
+"""
+6/range(1,45+1)
+최고 순위, 최저 순위
+1. 알수 없는 번호 개수: 0의 개수 => unknown_n
+2. 최저 순위 = 6- (1개,0개 == 0 개로 취급, 현재 맞는 개수)
+3. 최고 순위 = 6- 현재 맞은 개수
+"""
+def solution(lottos, win_nums):
+    answer = []
+    #1. 0의 개수
+    correct= 0 ; unknown = 0
+    #2. 알수 없는 개수, ,현재 맞은 개수
+    for i in range(len(lottos)):
+        if lottos[i] == 0 :
+            unknown += 1
+        elif lottos[i] in win_nums : 
+            win_nums.remove(lottos[i])
+            correct+=1
+    #3. 순위 = 7- 맞은 개수(1개 맞은 개수 == 0개 맞은 개수 = 1로 취급)
+    for c in [correct+unknown,correct] :
+        if c == 0 :
+            c= 1
+        rank = 7-c
+        answer.append(rank)
+    return answer

Hongjoo/lv1/로또의최고순위와최저순위.py

@@ -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,36 @@
+from collections import deque
+import copy
+def solution(bridge_length, weight, truck_weights):
+    answer = 0
+    t=0
+    run_truck = deque() # bride 올라간 weight
+    timeline = [[0] for _ in range(len(truck_weights))]
+    finish =[]
+    # 통과 조건(bridge에 있는 시간 >= bridge_length)
+    print(len(timeline))
+    i=0 # new truck 번호
+    while len(finish) <= len(truck_weights)and t<len(truck_weights):
+        t+=1 ;
+           #2. 나가기
+        if t==1:
+            run_truck.append(i)
+            timeline[i] = 1
+            continue
+        for r in copy.deepcopy(run_truck) : 
+            if timeline[r] > bridge_length : #내보내기
+                run_truck.popleft()
+                finish.append(r)
+                print(f"out {r} ,t={timeline[r]} , run : {run_truck}")
+            else :  #충족 x
+                timeline[r] += 1
+                print("# , run_truck", run_truck)
+       
+        #1. bridge 무게 조건 
+        now_weight = 0
+        for j in  copy.deepcopy(run_truck):
+            now_weight += truck_weights[j]
+        if now_weight + truck_weights[i] <= weight: # 올라감
+            run_truck.append(i)
+            timeline[i] = 1
+        
+    return answer

Hongjoo/lv2/다리를지나는트럭.py

@@ -0,0 +1,30 @@
+def defend(use_k,n,k,enemy_i):
+    if use_k : # use_k true
+        return n ,k-1
+    else : # no uese_k
+        return n-enemy_i, k
+    
+def solution(n, k, enemy):
+    answer = 0
+    graph = [[] for _ in range(len(enemy)+1)]
+    graph[0] =[[n,k]]
+    #매 i 라운드 별로
+    for i in range(len(enemy)) :
+        # print("길이:",len(graph[i]))
+        if len(graph[i]) == 0 : # 길이 0(중간에 끝나는 경우)
+            # print(i-1)
+            return i-1
+        for r in graph[i]:
+            input_n = r[0] ; left_k= r[1]
+            #1-1  use k /no use k  -> [남은 n, 남은 k]
+            for use_k in [0,1]:
+                x,y = defend(use_k,input_n,left_k,enemy[i])
+                if x>=0 and y>=0 :
+                    graph[i+1].append([x,y])
+                    # print(f"{i+1}라운드: {[x,y]} =>{graph[i+1]}")
+    #모든 라운드 통과
+    answer = len(enemy)
+    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,53 @@
+"""
+시작 1 ~ N번 node , road : m 개 (cost=1)
+최단거리= k인
+-> 다익스트라? ....BFS 감사합니다 ㅎ
+<BFS>
+0. 인접 리스트 graph 정의 , 시작 노드 queue 넣기 & 방문 등록
+1.queue 가 빌때 까지 
+    queue에서 꺼낸 n 과 인접한 노드 중 방문 안한 노드
+        -> queue 넣고 방문 등록
+    없으면 : 
+        -> queue에서 빼기
+
+=> cost = level : start ~ 거리 
+"""
+import sys
+from collections import deque
+
+n, m, k, start = map(int, sys.stdin.readline().split())
+#0.graph 정의
+INF = 300001
+graph = [[] for _ in range(n+1)]
+cost= [INF]*(n+1) # 최단 거리 graph
+visited=[False]*(n+1)
+for _ in range(m):
+    a,b = map(int, sys.stdin.readline().split())
+    graph[a].append(b)
+
+# print(graph)
+#2 BFS 
+queue = deque([start])
+visited[start] = True
+cost[start] = 0
+answer =list()
+
+while queue :
+    now = queue.popleft()
+ 
+    for n in graph[now] :  
+  
+        if not visited[n]  :
+            queue.append(n)
+            visited[n] = True
+            cost[n] = cost[now] + 1
+            if cost[n] == k : 
+                answer.append(n)
+# 출력
+if len(answer)== 0 :
+    print(-1)
+else :
+    answer.sort()
+    for a in answer:
+        print(a)
+