Merge pull request #155 from zaqquum/main

Hongjoo/3월 3주차 / 6개

Author: zaqquum

Hongjoo/lv2/게임맵최단거리.py

@@ -0,0 +1,40 @@
+from collections import deque
+def solution(maps):
+    n,m = len(maps) ,len(maps[0])# y길이 # x 길이 
+    
+    # 이동 범위 - 하,우,상,좌
+    dx = [0,1 , 0,-1]
+    dy = [1 , 0 , -1 , 0]
+    queue = deque([(0,0)])
+    visited = [[False for _ in range(m)] for k in range(n)]
+    visited[0][0] = True
+    #2. BFS
+    while queue :
+        # 현위치 
+        curr_y , curr_x = queue.popleft()
+        
+        # 통로 확인 - 벽or 바운더리 밖이면 x 
+        for i in range(4):
+            next_y = curr_y + dy[i]
+            next_x = curr_x + dx[i]
+            # target 도착 확인 
+            if next_y == n-1 and next_x == m-1 and maps[next_y][next_x] == 1:
+                visited[next_y][next_x] = True
+                maps[next_y][next_x] = maps[curr_y][curr_x] +1
+                break
+            # 바운더리 안에 있음 * 길인 경우 + 방문 등록 x 
+            if 0<=next_y< n and 0<= next_x < m :
+                if maps[next_y][next_x] == 1 and not visited[next_y][next_x]:
+                    maps[next_y][next_x] = maps[curr_y][curr_x] +1 
+                    queue.append((next_y, next_x))
+                    visited[next_y][next_x] = True
+
+          
+    # 3. 최단 거리 출력
+    # print(answer_list)
+    if not visited[n-1][m-1]:
+        return -1 
+    # answer = min(answer_list)
+    answer= maps[-1][-1]
+    # print(answer)
+    return answer

Hongjoo/lv2/완전범죄 .py

@@ -0,0 +1,29 @@
+def solution(info, n, m):
+    answer = 0
+    #1. dp 테이블 정의
+    dp = [[] for _ in range(len(info))]
+
+    if info[0][0] < n: 
+        dp[0].append((info[0][0]  , 0))
+    if info[0][1]  < m :
+        dp[0].append((0, info[0][1]))
+    if len(dp[0]) <= 0 :
+        return -1
+    # print(f" # item 0 : {dp[0]}")
+    for i in range(1, len(info)):
+        # dp[i][k]
+        for cur_a ,cur_b in dp[i-1]:
+            # print(f"##cur_a ,cur_b  {cur_a},{cur_b }")
+            up_a = cur_a + info[i][0]
+            up_b = cur_b + info[i][1]
+            if up_a < n: 
+                dp[i].append((up_a , cur_b))
+            if up_b < m :
+                dp[i].append((cur_a , up_b))
+            # print(f" # item {i} : {dp[i]}")
+        if len(dp[i]) <= 0 :
+            return -1
+        # print(f" # item {i} : {dp[i]}")
+    # A 최소값 반환 
+    answer = sorted(dp[-1])[0][0]
+    return answer

Hongjoo/lv2/완전범죄.py

@@ -0,0 +1,29 @@
+def solution(info, n, m):
+    answer = 0
+    #1. dp 테이블 정의
+    dp = [[] for _ in range(len(info))]
+
+    if info[0][0] < n: 
+        dp[0].append((info[0][0]  , 0))
+    if info[0][1]  < m :
+        dp[0].append((0, info[0][1]))
+    if len(dp[0]) <= 0 :
+        return -1
+    # print(f" # item 0 : {dp[0]}")
+    for i in range(1, len(info)):
+        # dp[i][k]
+        for cur_a ,cur_b in dp[i-1]:
+            # print(f"##cur_a ,cur_b  {cur_a},{cur_b }")
+            up_a = cur_a + info[i][0]
+            up_b = cur_b + info[i][1]
+            if up_a < n: 
+                dp[i].append((up_a , cur_b))
+            if up_b < m :
+                dp[i].append((cur_a , up_b))
+            # print(f" # item {i} : {dp[i]}")
+        if len(dp[i]) <= 0 :
+            return -1
+        # print(f" # item {i} : {dp[i]}")
+    # A 최소값 반환 
+    answer = sorted(dp[-1])[0][0]
+    return answer

Hongjoo/lv3/단어변환.py

@@ -0,0 +1,60 @@
+# 최소 편집 거리 =1 확인
+def check_edit1(a,b):
+    diff= 0 
+    for i in range(len(a)) :
+        if a[i] != b[i] :
+            diff+=1
+        if diff > 1 : 
+            return False
+    if diff == 1 : 
+        return True
+        
+from collections import deque
+def solution(begin, target, words):
+    answer = 0
+    #excep1 :words 에 target없으면 -> 변환 불가
+    if target not in words :
+        return 0 
+    
+    # 1. 인접 graph 생성
+    graph = [[] for _ in range(len(words)+2)] 
+    # begin -> words, target 단방향 
+    for k in range(len(words)) :
+        if check_edit1(begin, words[k]) :
+            graph[0].append(k+1)
+    if check_edit1(begin,target):
+        graph[0].append(len(words)+1)
+    # words -> wrods_1(쌍방향) , target(단방향)    
+    for k in range(len(words)):
+        for j in range(k ,len(words)):
+            if check_edit1(words[k], words[j]):
+                graph[k+1].append(j+1)
+                graph[j+1].append(k+1)
+        if check_edit1(words[k], target):
+            graph[k+1].append(len(words)+1)
+
+    #2.BFS 
+    visited = [ 0 for _ in range(len(words)+2)]
+    def bfs(visited):
+        visited[0] = 0
+        queue = deque()
+        queue.append(0)
+
+        while queue :
+            curr_idx = queue.popleft()
+            if len(graph[curr_idx]) <= 0 : # 이웃한 놈이 없는 경우 => return 0 
+                return 0
+
+            for next_idx in graph[curr_idx] : 
+                if not visited[next_idx] :  
+
+                    queue.append(next_idx)
+                    visited[next_idx] = visited[curr_idx] + 1 
+
+                if visited[-1] : #성공
+                    return visited[-1]
+        
+        return visited[-1] 
+    
+    
+    # print(graph)

Hongjoo/lv3/아이템줍기.py

@@ -0,0 +1,99 @@
+"""
+2hour 
+- 직사각형 바깥 테두리 이동
+ - x축, y축 좌표가 같은 경우 없음(꼭짓점, 변 공유 x  )
+ - 분리x, 포함x  => only 겹침
+goal) 캐릭터(start) -> 아이템 최단거리(BFS)
+
+#key idea : 좌표 & grid 2배 처리하기
+(참고.https://jyeonnyang2.tistory.com/247#google_vignette)
+#1. 인접 행렬
+-field[x][y] =  길에 해당하는 (x,y) 칸 = 1 ,길 x 인 칸은 (x,y )= 0 
+
+-(1) 각 직사각형 테두리에 해당하는 좌표 선출
+- (2) A- > B 각 범위에 겹치는 테두리 자표 제거[필터링]
+    -> 내부 빈 공간은 상관x 
+#2. BFS
+- visited 사용 to 누적 거리 
+"""
+from collections import deque
+def get_outlier(x1,y1,x2,y2):
+
+    pos_outliers = list()
+    # 가로 
+    for x in range(x1,x2+1,1):
+        pos_outliers.append([x,y1])
+        pos_outliers.append([x,y2])
+    # 세로
+    for y in range(y1, y2+1, 1):
+        if  [x1,y] in pos_outliers or [x2,y] in pos_outliers:
+            continue
+        pos_outliers.append([x1,y])
+        pos_outliers.append([x2,y])
+    return sorted(pos_outliers)
+        
+        
+def solution(rectangle, characterX, characterY, itemX, itemY):
+    answer = 0
+    field = [[0 for _ in range(51*2)] for k in range(51*2)]
+    #인접 행렬
+    characterX, characterY = characterX*2 , characterY*2
+    itemX, itemY = itemX*2 , itemY*2
+    #1.각 직사각형 칸 획득
+    for k in range(len(rectangle)):
+        #outlier 칸 찾기
+        x1,y1 ,x2 ,y2 = rectangle[k]
+        x1 = x1*2 ; x2 = x2*2 ; y1 = y1*2 ; y2 = y2*2 # 2배 
+        outliers = get_outlier(x1,y1,x2,y2)
+        
+        #필터링
+        # 모든 변 = 1  - 영역 겹치는 모서리만 =0
+        for i in range(len(outliers)):
+            out_x , out_y= outliers[i]
+            field[out_x][out_y] = 1 
+        # 영역 겹치는 모서리 탐색 -> =0 
+        for j in range(len(rectangle)) : 
+            if j == k : # 본인껀 스킵
+                continue
+            fil_x1 , fil_y1 , fil_x2 , fil_y2 =  rectangle[j]
+            fil_x1 , fil_y1  =fil_x1*2 , fil_y1*2
+            fil_x2 , fil_y2  = fil_x2*2 , fil_y2*2 
+            for i in range(len(outliers)):
+                out_x , out_y = outliers[i]
+                # 면적이 겹침 -> 필터링
+                if fil_x2 > out_x > fil_x1 and fil_y2 > out_y > fil_y1: 
+                    field[out_x][out_y] = 0 
+        
+        # for i in range(51):
+        #     for k in range(51):
+        #         if field[i][k] == 1:
+        #             print (f"[{i},{k}")
+
+    # stage 2. BFS로 최단 거리 찾기
+    # 상하좌우
+    dx =[0,0,1,-1]
+    dy= [1,-1,0,0]
+    queue = deque([(characterX,characterY)]) #queue 초기화
+    field[characterX][characterY]=0
+    while queue : 
+        cur_x, cur_y = queue.popleft()
+        #인접 노드
+        for idx in range(4):
+            # 루트만 가능
+            next_x ,next_y = cur_x + dx[idx] , cur_y + dy[idx]
+            if field[next_x][next_y] == 1   : # 방문 x & 길
+                field[next_x][next_y] = field[cur_x][cur_y] +1 
+                # print(f"#{field[next_x][next_y]}")
+                if next_x == itemX and next_y == itemY: # 목적지 도착 -> 결과 반환
+                    # print(f"#####{field[next_x][next_y]}")
+                    return field[next_x][next_y]//2
+                    break
+                queue.append((next_x,next_y))
+                
+        # print(f"#: {cur_x},{cur_y} => {field[cur_x][cur_y]}")
+        
+        # print(f">{queue}")
+        # print(f"##{field[next_x][next_y]}")
+    
+    
+    return answer

Hongjoo/백준/데스노트.py

@@ -0,0 +1,30 @@
+"""
+https://www.acmicpc.net/problem/2281
+# 참고 : https://cme10575.tistory.com/161
+"""
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+
+names = [int(input()) for _ in range(n)]
+dp = [[-1]*(m+1) for _ in range(n)]
+dp[0][names[0]] = 0
+
+for r in range(n-1):
+    for c in range(1, m+1):
+        if dp[r][c] != -1:
+            #뒤에 붙이는 경우의 수
+            if c+1+names[r+1] <= m:
+                dp[r+1][c+names[r+1]+1] = dp[r][c]
+            #다음줄에 쓰는 경우의 수
+            if dp[r+1][names[r+1]] != -1:
+                dp[r+1][names[r+1]] = min(dp[r+1][names[r+1]], dp[r][c] + (m-c)**2)
+            else:
+                dp[r+1][names[r+1]] = dp[r][c] + (m-c)**2
+
+answer = 1000000000
+for i in range(1, m+1):
+    if dp[n-1][i] != -1:
+        answer = min(answer, dp[n-1][i])
+print(answer)

Hongjoo/백준/동전1.py

@@ -0,0 +1,32 @@
+"""
+https://www.acmicpc.net/problem/2293
+
+# 문제
+- 가치가 다른 n 개의 종류의 동전을 활용해 총합 k 가 되는 경우의 수 
+- 사용 순서는 구분하지 않는다(중복제외)
+
+# 경우의 수 
+# brude force
+- n <= 100 
+
+1. 목표 금액 k에 도달하기 까지 divde conquer /사용하는 동전 종류도 사전 순서대로 사용 
+dp[lv][k] = dp[lv-1][k] + dp[lv][k-c]
+2. 메모리 초과
+=> dp 는 1차원 테이블로
+
+"""
+import sys
+
+n , k = map(int,sys.stdin.readline().split())
+coins = list()
+dp = [0 for _ in range(k+1)]
+for _ in range(n):
+    coins.append(int(sys.stdin.readline()))
+# 가치가 작은 coin 부터 적용
+coins.sort()
+dp[0] = 1
+
+for c in coins:
+    for i in range(c, k+1) :
+        dp[i] = dp[i] + dp[i-c]
+print(dp[k])

Hongjoo/백준/동전2.py

@@ -0,0 +1,33 @@
+"""
+https://www.acmicpc.net/problem/2294
+# dp
+- n개의 동전 조합으로 가치 합이 k 가 되는 경우
+- 그 중 사용 동전 최소
+- 메모리 제한 128MB
+# 문제 
+-dp[0] = 0 ,
+j : 사용 가능한 coin 종류 
+DP[k] =  min(dp이전[k] , "dp[k-c]+1 )
+"""
+import sys
+
+n , k  = map(int, sys.stdin.readline().split())
+coins = list()
+for _ in range(n):
+    coins.append(int(sys.stdin.readline()))
+
+coins.sort() 
+
+# 2. dp 테이블 초기화
+INF= int(1e9)
+dp = [INF for _ in range(k+1)]
+dp[0] = 0 
+for c in coins :
+    for j in range(c, k+1) :
+        dp[j] = min(dp[j] , dp[j-c]+1)
+
+#3. 출력 - 업데이트x 면 -1 출력
+if dp[k] == INF : 
+    print(-1)
+else : 
+    print(dp[k])