지원-5주차 제출

Baekjoon/jjuny-won/빗물/README.md

@@ -0,0 +1,11 @@
+# baek_14719
+
+## 문제
+- 블록을 입력 받고  고이는 빗물의 총량 구하기
+
+## 접근 방법
+- 첫 번째와 마지막 블록을 제외하고 각 블록을 순회
+- 왼쪽 기준,오른쪽 기준에서 가장 높은 것 찾기
+- 현재 블록 i에서 왼쪽과 오른쪽에서 찾은 가장 큰 높이 중에서 작은 값을 선택 -> 현재 블록에 고일 수 있는 최대 높이
+- 현재 블록 i의 높이 arr[i]가 m보다 작다면 고일 수 있도록 조건줌
+

Baekjoon/jjuny-won/빗물/beak_14719.py

@@ -0,0 +1,14 @@
+h,w = map(int,input().split())
+arr = list(map(int,input().split()))
+
+#가장 큰 수를 기준으로 나눈다
+
+result=0
+
+for i in range(1,w-1):
+    left = max(arr[:i])
+    right = max(arr[i+1:])
+    m = min(left,right)
+    if(m>arr[i]):
+        result += m-arr[i]
+print(result)

Baekjoon/jjuny-won/회의실 배정/beak_1931.py

@@ -0,0 +1,18 @@
+import sys
+
+n = int(sys.stdin.readline())
+arr = []
+for i in range(n):
+    arr.append(list(map(int,sys.stdin.readline().split())))
+
+data_sorted = sorted(arr, key=lambda x:(x[1], x[0]))
+#[[2, 2], [3, 3], [2, 3], [1, 3]]
+#[[2, 2], [1, 3], [2, 3], [3, 3]]
+
+cnt  =0 
+end_time =0
+for a in data_sorted:
+    if a[0] >= end_time:
+        cnt +=1
+        end_time = a[1]
+print(cnt)       

Programmers/jjuny-won/Dynamic Programming/README.md

@@ -0,0 +1,110 @@
+# Dynamic Programming
+
+# Level1
+
+## prog_134240
+
+### 문제
+- 수웅이가 준비한 음식의 양을 칼로리가 적은 순서대로 나타내는 정수 배열 food가 주어졌을 때, 대회를 위한 음식의 배치를 나타내는 문자열을 return 하는 solution 함수를 완성해주세요.
+- 준비한 음식의 수가 홀수 or 남을 경우 짝수개 까지만 표현
+
+### 해결 방법
+- i ==0 : 물의 경우 continue
+- 1부터 food//2 개의 i 를 answer 에 추가
+- 중간에 물 연결
+- 마지막 상대편 선수는 문자열을 뒤집어서 연결
+
+## prog_142086
+
+### 문제
+- 문자열 s가 주어졌을 때, s의 각 위치마다 자신보다 앞에 나왔으면서, 자신과 가장 가까운 곳에 있는 같은 글자가 어디 있는지 찾는문제
+- s="banana" , 최종 결과물은 [-1, -1, -1, 2, 2, 2]
+
+### 해결방법
+- s 에서 for 문으로 하나씩 돌면서 s[i] 가 s[:i] 에 있을 때 -> 앞에 동일한 문자가 있을때
+- 해당 인덱스에서 s[:i].rfind(s[i])를 빼준 값을 append 해주었다
+- 만약에 동일한 문자가 없다면 -1 append
+
+# Level2
+
+## prog_49994 -> 미해결
+
+### 문제
+- 캐릭터를 4가지 명령어를 통해 움직인다
+- 게임 캐릭처가 지나간 길 중에 처음 걸어본 길의 길이를 구하려한다
+
+### 접근 방법
+- dic로 각각의 방향에서 움직이는 경로를 지정
+- for 문을 통해 해당방향에서 선언해놓은 경로를 따라 움직이도록
+- boundart 를 검사
+
+### 해결 못 한 이유
+- 양방향성을 고려하지 못함
+- 현재 코드에서 양방향성을 고려한다면 더욱 복잡해질 것
+
+## prog_1844->미해결
+
+### 문제
+- ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.
+- 게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요. 단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요.
+
+
+### 접근 방법
+- BFS 사용
+- map 은 0 이고 길은 1
+- 초기 값은 `(0, 0)`이고, 목표 지점은 `(len(maps) - 1, len(maps[0]) - 1)`
+
+### 해결 못 한 이유
+- BFS로 접근 및 구현의 어려움
+
+# Level3
+
+## prog_150365->미해결
+
+### 문제
+- n x m 격자 미로가 주어집니다. 당신은 미로의 (x, y)에서 출발해 (r, c)로 이동해서 탈출
+- 이동하는 거리가 총 k
+- 같은 격자를 두 번 이상 방문
+- 미로에서 탈출한 경로를 문자열로 나타냈을 때, 문자열이 사전 순으로 가장 빠른 경로로 탈출
+
+### 접근 방법
+- 최소 거리를 맨해튼 거리로 계산
+- 최소거리와 k 비교 -> impossible return
+- l과 r을 n번해서 dx 의 값을 만들어야하고 
+- u,d 을 (k-n) 번해서 dy 의 값을 만들어야 한다
+- 그렇게 만들수 있는 경우수를 조합해서 이걸 사전순으로 가장 빠른 경로를 return 
+
+### 해결 못 한 이유
+- 이동하는 부분과 사전순을 고려하는 부분을 구현하지 못했다
+- 또한 최소거리 외에 추가거리 구현에 어려움이 있었다
+
+## prog_150367->미해결
+
+### 문제
+- 이진트리를 수로 표현
+- 이진트리에서 리프 노드가 아닌 노드는 자신의 왼쪽 자식이 루트인 서브트리의 노드들보다 오른쪽에 있으며, 자신의 오른쪽 자식이 루트인 서브트리의 노드들보다 왼쪽에 있다고 가정합니다.
+-> root 노드가 (서브 트리든 메인 트리든) 0 이면 이진트리를 만들 수 없다는 것 이용
+
+### 접근 방법
+- 각 요소가 binary 수로 변환
+- 변환후 이진 탐색을 통해 반씩 나눠가면서 mid가 0 인지 (root 가 0인지) 확인
+
+### 해결 못 한 이유
+- 트리 구현의 어려움
+- 문제 이해도 어려웠다
+# 백준
+
+## beak_1931
+
+### 문제
+ - N개의 회의에 대하여 회의실 사용표를 만들려고 한다.
+ - 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수
+
+### 접근 방법
+- sort 로 끝나는 시간 기준으로 오름차순으로 정렬
+- 2순위로 시작시간을 고려하도로 설정
+- endtime을 설정하여 시작 시간과 비교해 count
+
+### 어려웠던 부분
+- 처음에 시작시간 고려하여 정렬 했을 때 시간 초과 발생
+- 끝나는 시간만 고려했을 때 배열 생성시 순서가 잘못 고려 되었다

Programmers/jjuny-won/Dynamic Programming/prog_134240.py

@@ -0,0 +1,10 @@
+def solution(food):
+    answer = ''
+    for i in range(len(food)):
+        if i ==0:
+            continue
+        answer += str(i )*(food[i]//2)
+    final_answer = answer + "0" + answer[::-1]
+    return answer
+input_arr = list(map(int,input().split()))
+solution(input_arr)

Programmers/jjuny-won/Dynamic Programming/prog_142086.py

@@ -0,0 +1,10 @@
+def solution(s):
+    answer = []
+    for i in range(len(s)):
+        if s[i] in s[:i]:
+            first = s[:i].rfind(s[i])
+            # first = s[:i].rindex(s[i])
+            answer.append(i -first)
+        else:
+            answer.append(-1)
+    return answer

Programmers/jjuny-won/Dynamic Programming/prog_150365.py

@@ -0,0 +1,34 @@
+
+def solution(n, m, x, y, r, c, k):
+    d = {'u': (0,1), 'd': (0, -1), 'r': (1, 0), 'l': (-1, 0)}
+    diff = abs(x-r)+abs(y-c)
+    print(diff)  
+    # 최소 거리와 k 비교
+    if diff%2!=k%2 or diff>k:
+        return 'impossible'
+
+    answer = ''
+
+    rest = k-diff
+    lcount ,rcount ,dcount ,ucount = 0
+    if x<r : #내려가야함
+        dcount = r-x
+    else:
+        ucount = x-r
+    if y<c :
+        rcount = c-y
+    else:
+        lcount = y-c
+
+    dplus = min( n-max(x,r), rest//2)
+    rest -= dplus*2
+
+    lplus = min( min(y,c)-1, rest//2)
+    rest -= lplus*2
+
+    answer = 'd'*(dcount+dplus)+'l'*(lcount+lplus)+'rl'*(rest//2)+'r'*(rcount+lplus)+'u'*(dplus+ucount)
+    # print(lcount,lplus,rcount,rest)
+    print(answer)
+    return answer
+
+solution(3,4,2,3,3,1,5)

Programmers/jjuny-won/Dynamic Programming/prog_150367.py

@@ -0,0 +1,31 @@
+def dfs(b, i, depth):
+    if depth == 0:  	
+        return True 	# 포화이진트리
+
+    elif b[i] == '0':   
+        if b[i - depth] == '1' or b[i + depth] == '1': return False
+
+    # 왼쪽 서브 트리 탐색
+    left = dfs(b, i - depth, depth // 2)
+    # 오른쪽 서브 트리 탐색
+    right = dfs(b, i + depth, depth // 2)
+    return left and right
+
+
+def solution(numbers):
+    answer = []
+    for num in numbers:			
+        b = bin(num)[2:]  			
+        nodes = bin(len(b) + 1)[2:] 	
+
+        # 포화이진트리가 아닌 경우 더미노드(0추가)
+        if '1' in nodes[1:]:       
+            dummies = (1 << len(nodes)) - int(nodes, 2)
+            b = '0' * dummies + b
+
+        # 이미 포화이진트리일 경우
+        result = dfs(b, len(b)//2, (len(b)+1)//4)
+        answer.append(1 if result else 0)
+
+    return answer
+

Programmers/jjuny-won/Dynamic Programming/prog_1844.py

@@ -0,0 +1,38 @@
+from collections import deque
+def solution(maps):
+    answer = 0
+
+    # 상하좌우
+    dx = [-1, 1, 0, 0]
+    dy = [0, 0, -1, 1]
+
+    def bfs(x, y):
+        queue = deque()
+        queue.append((x, y))
+
+        # queue가 빌 때까지 반복
+        while queue:
+            x, y = queue.popleft()
+
+            # 상하좌우 칸 확인하기
+            for i in range(4):
+                nx = x + dx[i]
+                ny = y + dy[i]
+
+                # 맵을 벗어나면 무시하기
+                if nx < 0 or nx >= len(maps) or ny < 0 or ny >= len(maps[0]): continue
+
+                # 벽이면 무시하기
+                if maps[nx][ny] == 0:  continue
+
+                # 처음 지나가는 길이면 거리계산하고 다시 상하좌우 확인하기
+                if maps[nx][ny] == 1:
+                    maps[nx][ny] = maps[x][y] + 1
+                    queue.append((nx, ny))    # 재귀
+
+        # 상대 팀 진영(제일 오른쪽 아래 칸)까지의 거리 반환
+        return maps[len(maps)-1][len(maps[0])-1]
+
+    answer = bfs(0, 0)
+    return -1 if answer == 1 else answer    # 상대 팀 진영에 도착할 수 없을 때 -1
+

Programmers/jjuny-won/Dynamic Programming/prog_49994.py

@@ -0,0 +1,11 @@
+def solution(dirs):
+    s = set()
+    d = {'U': (0,1), 'D': (0, -1), 'R': (1, 0), 'L': (-1, 0)}
+    x, y = 0, 0
+    for i in dirs:
+        nx, ny = x + d[i][0], y + d[i][1]
+        if -5 <= nx <= 5 and -5 <= ny <= 5:
+            s.add((x,y,nx,ny))
+            s.add((nx,ny,x,y))
+            x, y = nx, ny
+    return len(s)//2

Programmers/jjuny-won/Shortest Path Algorithm/README.md

@@ -0,0 +1,68 @@
+# prog_42889
+https://school.programmers.co.kr/learn/courses/30/lessons/42889#
+
+## 문제
+- stage 수와 유저들이 멈춰있는 stages를 입력받아, 실패율이 높은 스테이지부터 return
+
+## 해결 방법
+- stage (N+1) 만큼 반복문을 돌며 각 스테이지 마다 실피율을 구한다
+- stage 에 도달한 유저 수가 없을 경우 실피율을 0으로 처리
+
+# prog_161989
+
+## 문제
+- 페이트가 칠해진 길이가 n, 페인트를 칠하는 롤러의 길이가 m
+- 다시 페인트를 칠하기로 정한 구역들의 번호가 담긴 정수 배열 section이 매개변수로 주어질 때 롤러로 페인트칠해야 하는 최소 횟수를 return 하는 solution 함수를 작성
+
+## 해결방법
+- 페인트를 칠해야하는 구역을 prev를 설정
+- prev에서 에서 칠할 수 있는 구역의 수를 빼며
+- prev 를 갱신
+
+----
+
+# prog_42583
+
+## 문제
+- 모든 트럭이 다리를 건너너는데 소요되는 최소 시간
+- bridge_length(최대 몇 대) , weight(다리가 견딜 수 있는 무게), truck_weights (트럭 무게)
+
+## 해결 방법
+- 한 블럭을 1초씩 이동한다고 가정
+- 이미 지나간 트럭 무게 빼기
+- 트럭이 올라갈 수 있는 지 조건 주고 더 올라갈 수 있으면 올림
+- 올라갈 수 없는 경우에는 0 추가
+
+# prog_42746
+
+## 문제
+- 0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수
+
+## 해결 방법
+- 문자열로 변환
+- x*10 을 해서 문자열 비교 (3,30) 같은 경우 비교를 위해
+- 다 0일 경우 
+
+---
+
+# prog_17676
+
+## 문제 
+- 로그와 처리 시간을 입력 받아, 초당 최대 처리량를 return 
+
+## 해결방법
+- 처리량이 변하는 부분 = 시작 or 끝나는 부분
+- 밀리세큰드 단위로 변환후 시작 시간 구하기
+- 초당 최대 처리량을 구하는 문제이기 때문에 각 로그의 끝나는 시점을 기준으로 1초(1000 밀리초) 동안 겹치는 로그 수를 고려
+
+
+# prog_12942 (미해결)
+https://school.programmers.co.kr/learn/courses/30/lessons/12942
+
+## 문제
+- 행렬의 최소 곱셈 수 구하기
+
+## 해결 방법
+- 곱셈 가능한 모든 경우를 파악 후 최소 곱셈 구하기
+- 점화식 dp[a][b] = min(dp[a][b], dp[a][k] + middle_product + dp[k + 1][b])
+

Programmers/jjuny-won/Shortest Path Algorithm/prog_161989.py

@@ -0,0 +1,9 @@
+def solution(n, m, section):
+    answer = 1
+    prev = section[0]
+    for i in section:
+        if i - prev >= m:
+            prev = i
+            answer+=1
+    return answer
+

Programmers/jjuny-won/Shortest Path Algorithm/prog_42746.py

@@ -0,0 +1,15 @@
+
+def solution(numbers):
+
+    numbers_str = list(map(str, numbers))
+
+    # 두 문자열을 비교하여 정렬하는 커스텀 정렬 함수
+    numbers_str.sort(key=lambda x: x*10, reverse=True)
+    answer = ''.join(numbers_str)
+
+    # '0'으로 시작한다면, 0을 반환 
+    if answer[0] == '0':
+        return '0'
+
+    return answer
+