Sad Puppy 3 '코딩테스트/문제 풀이 - Python' 카테고리의 글 목록 (5 Page) :: 개발자 아지트

https://school.programmers.co.kr/learn/courses/30/lessons/1844

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

 

문제설명

 

 

링크 참고


문제 해결 방법

 

bfs를 통해 문제를 해결하였음

 

 

코드 구현

 

 

과거에 작성한 코드 

더보기
from collections import deque

def solution(maps):
    answer = 0
    # map은 2차원 배열이라고 생각하면 됨 
    n = len(maps) #가로 
    m = len(maps[0]) #세로 

    # 이동할 네 가지 방향 정의 (상, 하, 좌, 우)
    dx = [-1, 1, 0, 0] #세로축
    dy = [0, 0, -1, 1] #가로축 
    
    def bfs(x,y):
        #큐 구현을 위해 deque라이브러리 사용
        queue = deque()
        queue.append((x,y))
        # 큐가 빌 때까지 반복하기 
        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 maps[nx][ny] == 0:
                    continue
                # 해당 노드를 처음 방문하는 경우에만 최단 거리 기록 
                if maps[nx][ny] == 1:
                    maps[nx][ny] = maps[x][y] + 1
                    queue.append((nx, ny))
        # 가장 오른쪽 아래 까지의 최단 거리 반환 
        return maps[n-1][m-1]
    
    
    if bfs(0,0)==1:
        answer=-1
    else:
        answer=bfs(0,0)
    
    return answer

 

 

 

 

 

from collections import deque

def solution(maps):
    answer = 0
    n = len(maps) 
    m = len(maps[0]) 
    
    # 최단 거리 구하기.
    # bfs - deque
    # 1,1 부터 시작
    dx = [1, -1, 0, 0] # 동, 서, 남, 북
    dy = [0, 0, -1, 1]
    
    # 게임 맵 벗어난 길은 갈 수 없음
    queue = deque([(0, 0)])
    distance = 0
    
    visited = [[False] * n for _ in range(m)]
    visited[0][0] = True
    
    while 1:
        if len(queue) == 0: 
            break
            
        x, y = queue.popleft()
        
        if x == n-1 and y == m-1:
            check = 1
            break   
        
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            
            if nx >= n or ny >= m or nx < 0 or ny < 0:
                continue 
            
            if maps[nx][ny] == 0:
                continue
            
            if maps[nx][ny] == 1:
                queue.append([nx, ny])
                maps[nx][ny] = maps[x][y] +1
    
    answer = maps[n-1][m-1]
    if answer == 1:
        return -1
    return answer

 

 

시간/공간 복잡도

 

 

O(N*M)

 

최적화 및 개선

 

 

.

 

어려웠던 점

 

 

가로 세로가 헷깔렸음.

예전에 풀어봤던 문제인데도 처음엔 느낌조차 없다가 점점 느낌 살아났지만, 예전에 고민했던 부분을 또 고민하며 문제를 풀었다. 

'코딩테스트 > 문제 풀이 - Python' 카테고리의 다른 글

[프로그래머스 lv3] 배달  (1) 2024.04.10
[프로그래머스 lv3] 네트워크  (0) 2024.04.10
벨만포드 알고리즘  (0) 2024.04.09
다익스트라 알고리즘  (0) 2024.04.08
BFS 순회  (0) 2024.04.08

주석 있는 코드 

def solution(graph, source):
    # 1. 그래프의 노드 수
    num_vertices = len(graph)
    # 2. 거리 배열 초기화 
    distance = [float("inf")] * num_vertices
    distance [source] = 0
    # 3. 직전 경로 배열 초기화 
    predecessor = [None] * num_vertices

    # 4. 간선 수 만큼 반복하여 최단 경로 갱신
    for temp in range(num_vertices - 1):
        for u in range(num_vertices):
            for v, weight in graph[u]:
                # 5. 현재 노드 u를 거쳐서 노드 v로 가는 경로의 거리가 기존에 저장된 노드 v까지의
                # 거리보다 짧은 경우
                if distance[u] + weight < distance[v]:
                    # 6. 최단 거리를 갱신해줌.
                    distance[v] = distance[u] + weight
                    # 7. 직전 경로를 업데이트해줌.
                    predecessor[v] = u

    # 8. 음의 가중치 순회 체크 
    for u in range(num_vertices):
        for v, weight in graph[u]:
            # 9. 현재 노드 u를 거쳐서 노드 v로 가는 경로의 거리가 기존에 
            # 저장된 노드 v까지의 거리보다 짧은 경우
            if distance[u] + weight < distance[v]:
                # 10. 음의 가중치 순회가 발견됐음, [-1] 반환
                return [-1]

    return [distance, predecessor]

 

 

주석 간소화 코드

def solution(graph, source):
    vLen = len(graph)
    distances = [float("inf")] * vLen
    distances[source] = 0 # 최단거리 리스트, 시작은 0
    predecessor = [None] * vLen # 직전 노드 
    print("")

    # 일단 최단거리 그거 구해야함. 
    for i in range(0, vLen-1): # n-1번 반복함
        for v, node in enumerate(graph):
            for oneNode in node:
                currNode, weight = oneNode
                distance = distances[v] + weight
                if distance < distances[currNode]:
                    distances[currNode] = distance
                    predecessor[currNode] = v

    # 음의 순환 잡기 
    for v, node in enumerate(graph):
        for oneNode in node:
            currNode, weight = oneNode       
            distance = distances[v] + weight
            if distance < distances[currNode]:
                return [-1]

    return [distances, predecessor]

 

 

 

'코딩테스트 > 문제 풀이 - Python' 카테고리의 다른 글

[프로그래머스 lv3] 네트워크  (0) 2024.04.10
[프로그래머스 lv2] 게임 맵 최단거리  (0) 2024.04.09
다익스트라 알고리즘  (0) 2024.04.08
BFS 순회  (0) 2024.04.08
DFS 순회  (0) 2024.04.06
import heapq

def solution(graph, start):

# 1. 시작 노드 설정, 시작 노드부터 특정 노드까지 최소 비용을 저장할 공간과 직전 노드를 저장할 공간 마련
# 1-1. 최소 비용을 저장할 공간은 모두 매우 큰 값으로 초기화
# 무한대 약자는 INF 로 표현, 직전 노드를 저장할 공간 또한 INF로 초기화 
# 1-2. 시작 노드의 최소 비용은 0, 직전 노드는 자신으로

# 2. 해당 노드를 ㅌ오해 방문할 수 있는 노드 중, 아직 방문하자ㅣ 않는 노드 중 현재까지 구한 최소 비용이 
# 가장 작은 노드를 선택
# 2-1. 해당 노드를 거쳐 각 노드까지 가는 최소 비용과 현재까지 구한 최소 비용을 비교해 작은 값을
# 각 노드의 최소 비용으로 갱신함
# 2-2. 이때 직전 노드도 같이 갱신함.
# 3. 노드 개수에서 1을 뺀 만큼 반복함.
    
    distances = {node: float("inf") for node in graph}
    # 1. 모든 노드의 거리 값을 무한대로 초기화 
    # print(distances)

    distances[start] = 0 
    # 2. 시작 노드의 거리 값은 0으로 초기화 

    queue = []
    heapq.heappush(queue, [distances[start], start]) 
    # print('queue', queue) # [[0, 'A']]

    # 3. 시작 노드를 큐에 삽입
    paths = {start: [start]} # paths:  {'A': ['A']} 이렇게 나오는게 맞나,,? 
    # 4. 시작 노드의 경로를 초기화 

    # print('paths: ', paths)

    while queue:
        # 5. 현재 가장 거리 값이 작은 노드를 가져옴
        current_distance, current_node = heapq.heappop(queue)
        # 6. 만약 현재 노드의 거리 값이 큐에서 가져온 거리 값보다 크면,
        # 해당 노드는 이미 처리한 것이므로 무시

        if distances[current_node] < current_distance:
            continue

        # 7. 현재 노드와 인접한 노드들의 거리 값을 계산하여 업데이트
        
        for adjacent_node, weight in graph[current_node].items():
            distance = current_distance + weight
            # 8. 현재 계산한 거리 값이 기존 거리 값보다 작으면 최소 비용 및
            # 최단 경로 업데이트 
             
            if distance < distances[adjacent_node]:
                distances[adjacent_node] = distance # 최소 비용 업데이트
                paths[adjacent_node] = paths[current_node] + [adjacent_node]
                # 최단 경로 업데이트

                # 9. 최소 경로가 갱신된 노드를 비용과 함께 큐에 푸시
                heapq.heappush(queue, [distance, adjacent_node])

    # 10. paths 딕셔너리를 노드 번호에 따라 오름차순 정렬하여 반환
    sorted_paths = {node: paths[node] for node in sorted(paths)}

    return [distances, sorted_paths]

 

 

주석 없는 버전 

 

import heapq
def solution(graph, start):

    distances = {node: float("inf") for node in graph}
    distances[start] = 0

    queue = []
    heapq.heappush(queue, [distances[start], start])
    paths = {start: [start]}

    while queue:
        currDis, currNode = heapq.heappop(queue)

        if distances[currNode] < currDis:
            continue 

        for injeop, weight in graph[currNode].items():
            distance = currDis + weight
            if distances[currNode] > distance:
                distances[currNode] = distance
                paths[injeop] = paths[currNode] + [injeop]
                heapq.heappush(queue, [distance, injeop])

        
        sorted_paths = {node: paths[node] for node in sorted(paths)}


            
   
    return [distances, sorted_paths]

'코딩테스트 > 문제 풀이 - Python' 카테고리의 다른 글

[프로그래머스 lv2] 게임 맵 최단거리  (0) 2024.04.09
벨만포드 알고리즘  (0) 2024.04.09
BFS 순회  (0) 2024.04.08
DFS 순회  (0) 2024.04.06
[프로그래머스 lv2]전화번호 목록.ver2  (0) 2024.04.05
from collections import defaultdict, deque

def solution(graph, start):
    # 트리 생성 
    tmp_tree = defaultdict(list)
    for i, v in graph:
        tmp_tree[i].append(v)

    print(tmp_tree)
    
    def dfs(start):
        visited = set()
        queue = deque([start])
        visited.add(start)
        result.append(start)

        while queue:       
            node = queue.popleft() # 순차적으로 처리함 
            for injeop in tmp_tree.get(node, []):
                print('node', node, 'injeop', injeop)
                if injeop not in visited:
                    queue.append(injeop)
                    visited.add(injeop)
                    result.append(injeop)

    result = []
    dfs(start)  
    return result

 

from collections import defaultdict

def solution(graph, start):

    adj_list = defaultdict(list)
    for u, v in graph:
        adj_list[u].append(v)


    def dfs(node, visited, result):
        visited.add(node)
        result.append(node)
        for neighbor in adj_list.get(node, []):
            print('neighbor', neighbor)

            if neighbor not in visited:
                dfs(neighbor, visited, result)

    
    visited=set()
    result = []
    dfs(start, visited, result)

    return result

https://school.programmers.co.kr/learn/courses/30/lessons/42577

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

 

 

문제설명

 

 

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.

전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

 

구조대 : 119

박준영 : 97 674 223

지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book  solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true return 하도록 solution 함수를 작성해주세요.

 

 

제한 사항

 

 

phone_book의 길이는 1 이상 1,000,000 이하입니다.

각 전화번호의 길이는 1 이상 20 이하입니다.

같은 전화번호가 중복해서 들어있지 않습니다.

 

 

입출력 예제

 

 

phone_book       return
["119", "97674223", "1195524421"]   false
["123","456","789"]  true
["12","123","1235","567","88"] false

 

 

 

입출력 예 설명

 

 

입출력 예 #1

앞에서 설명한 예와 같습니다.

 

입출력 예 #2

한 번호가 다른 번호의 접두사인 경우가 없으므로, 답은 true입니다.

 

입출력 예 #3

첫 번째 전화번호, “12”가 두 번째 전화번호 “123”의 접두사입니다. 따라서 답은 false입니다.

 

 

문제 해결 방법

 

그래서 연속된 두 문자씩 비교함

 

코드 구현

 

 

def solution(phone_book):
    answer = True
    phone_book.sort()

    count=0
    for num in phone_book:
        if count==0:
            count+=1
            pass
        else:
            preNum = phone_book[count-1]
            if preNum in num and num.startswith(preNum):
                answer = False
            count+=1
    
    return answer

 

 

 

시간/공간 복잡도

 

 

O(N)

 

 

최적화 및 개선

 

그래서 연속된 두 문자씩 비교를 위해 문자열 상태에서 sort를 하여 찾는 효율을 높임.

시간 초과 개선을 위해 모든 문자열 비교하려고 하지않음.

특정 문자열이 문자열 접두사로 붙는 것을 확인하기 위해 startswith함수를 사용함.

 

 

어려웠던 점 및 느낀점

 

없음. 확실히 예전에 푼문제라 그런가 이해가 빨리되고, 풀때 헤메는 것도 잠깐이고 코드가 간결해짐.

 

 

 

 

 

 

 

'코딩테스트 > 문제 풀이 - Python' 카테고리의 다른 글

BFS 순회  (0) 2024.04.08
DFS 순회  (0) 2024.04.06
[프로그래머스 lv2]영어 끝말잇기.ver2  (0) 2024.04.05
[프로그래머스 lv3]길 찾기 게임  (0) 2024.04.04
[프로그래머스 lv3]미로 탈출  (0) 2024.03.20

https://school.programmers.co.kr/learn/courses/30/lessons/12981?language=python3

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제설명

 

1부터 n까지 번호가 붙어있는 n명의 사람이 영어 끝말잇기를 하고 있습니다. 영어 끝말잇기는 다음과 같은 규칙으로 진행됩니다.

1번부터 번호 순서대로  사람씩 차례대로 단어를 말합니다.

마지막 사람이 단어를 말한 다음에는 다시 1번부터 시작합니다.

앞사람이 말한 단어의 마지막 문자로 시작하는 단어를 말해야 합니다.

이전에 등장했던 단어는 사용할  없습니다.

 글자인 단어는 인정되지 않습니다.

다음은 3명이 끝말잇기를 하는 상황을 나타냅니다.

tank  kick  know  wheel  land  dream  mother  robot  tank

 끝말잇기는 다음과 같이 진행됩니다.

1 사람이 자신의  번째 차례에 tank 말합니다.

2 사람이 자신의  번째 차례에 kick 말합니다.

3 사람이 자신의  번째 차례에 know 말합니다.

1 사람이 자신의  번째 차례에 wheel 말합니다.

(계속 진행)

끝말잇기를 계속 진행해 나가다 보면, 3 사람이 자신의  번째 차례에 말한 tank 라는 단어는 이전에 등장했던 단어이므로 탈락하게 됩니다.

사람의  n 사람들이 순서대로 말한 단어 words  매개변수로 주어질 , 가장 먼저 탈락하는 사람의 번호와  사람이 자신의  번째 차례에 탈락하는지를 구해서 return 하도록 solution 함수를 완성해주세요.

제한 사항

끝말잇기에 참여하는 사람의  n 2 이상 10 이하의 자연수입니다.

words 끝말잇기에 사용한 단어들이 순서대로 들어있는 배열이며, 길이는 n 이상 100 이하입니다.

단어의 길이는 2 이상 50 이하입니다.

모든 단어는 알파벳 소문자로만 이루어져 있습니다.

끝말잇기에 사용되는 단어의 (의미) 신경 쓰지 않으셔도 됩니다.

정답은 [ 번호, 차례 ] 형태로 return 해주세요.

만약 주어진 단어들로 탈락자가 생기지 않는다면, [0, 0] return 해주세요.

문제 해결 방법

문제를 풀기위한 조건들을 하나하나 생각해서 하나하나 제외해가면서 풀었음

 

코드 구현

def solution(n, words):
    answer = []
    # 1번부터 마지막 순서까지 돌고돈다.
    # 앞사람이 말한 단어의 마지막 문자로 시작하는 단어를 말해야한다. 
    # 이전에 등장했던 단어는 사용할 수 없다. 
    # 한 글자 단어 인정안해줌
    newWords=[] #스택에 쌓음
    newWords.append(words[0]) 
    
    cnt = 1 #words에서 어디를 가리키는지 
    big_phase=0
    check = 0
    check2 = 0
    while 1:
        big_phase+=1
        for i in range(1, n+1):
            if check ==1:
                answer.append(i)
                answer.append(big_phase)
                return answer
            
            if check2 == 1:
                answer.append(i)
                answer.append(big_phase)
                return answer
            
            if cnt == len(words):
                break
            
            if words[cnt][0] == newWords[-1][-1]:
                pass
            else:
                check = 1
                
            
            if words[cnt] in newWords:
                check2 = 1
            else:
                newWords.append(words[cnt])  
                cnt+=1
                
        if cnt == len(words):
                break

    answer.append(0)
    answer.append(0)
    
    return answer

 

시간/공간 복잡도

O(n)

 

최적화 및 개선

최적화 및 개선하지 않음

 

어려웠던 점

 

예전에 작성한 코드랑 그닥 로직이 다른거 같진 않다.. 

스스로 더 로직을 잘 이해하고 풀었다는 차이점이 존재할뿐? 

 

 

 

문제설명

https://school.programmers.co.kr/learn/courses/30/lessons/42892

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

참고 

문제 해결 방법

 

주어진 리스트로 트리 만드는 부분 구현후, 스택을 활용해 트리 순회하는 코드 작성함 

후위 순회는 방문 여부를 체크 하도록 하여 구현하였음


코드 구현

 

 

def solution(nodeinfo):
    answer = []
    original = nodeinfo
    
    cnt = 0
    for i in nodeinfo:
        cnt +=1
        i.append(cnt)
    
    
    nodeinfo.sort(key = lambda x : (-x[1], x[0]))
    

    class Node:
        def __init__(self, key):
            self.left = None
            self.right = None
            self.val = key[2]
            self.x = key[0]
    
    class BST:
        def __init__(self):
            self.root = None
        
        def insert(self, key):
            if not self.root:
                self.root = Node(key)
            else:
                curr = self.root
                while 1:
                    if curr.x > key[0]:
                        if curr.left:
                            curr = curr.left
                        else:
                            curr.left = Node(key)
                            break
                    else:
                        if curr.right:
                            curr = curr.right
                        else:
                            curr.right = Node(key)
                            break
                    
        def preorder(self, result):
            curr = self.root
            stackk=[]
            stackk.append(curr)
            
            while 1:
                if len(stackk) != 0:
                    curr = stackk.pop()
                    
                    if curr is None:
                        continue
                    
                    result.append(curr.val)
                    stackk.append(curr.right)
                    stackk.append(curr.left)
                else:
                    break
            return result
                    
        def postorder(self, result):
            curr = self.root
            stackk=[(self.root, False)]
            # 이코드 대신 위에 코드 stackk.append(curr, False)
            
            while 1:
                if len(stackk) != 0:
                    curr, visited = stackk.pop()
                                      
                    if curr is None:
                        continue
                    if visited:
                        result.append(curr)
                    else:
                        stackk.append((curr.val, True))
                        stackk.append((curr.right, False))
                        stackk.append((curr.left, False))
                else:
                    break
            
            return result
    
    bst = BST()

    for key in nodeinfo:
        bst.insert(key)
        
    
    result = []
    answer.append(bst.preorder(result))
    result = []
    answer.append(bst.postorder(result))
    
    
    return answer

 

 

시간/공간 복잡도

 

O(N^2)


최적화 및 개선

 

하지않음


어려웠던 점

 

트리 구성 까지는 할 수 있는데, 트리 순회할때 재귀함수를 사용하지 않고 스택으로 구현하려니 어려웠다. 

https://school.programmers.co.kr/learn/courses/30/lessons/159993

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

문제설명

1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다. 통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다. 따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.

 

미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1 return 해주세요.

 

문제 해결 방법

문제에서 미로를 탈출하는데 필요한 최소 시간을 구해야한다. 

최소 시간이나 최소 경로 등의 키워드, 노드의 간선에 가중치가 없는 경우,  BFS로 풀수 있다. 

 

코드 구현

from collections import deque
        
def solution(maps):
    answer = 0
    m = len(maps)
    n = len(maps[0])
    
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    
    q = deque()
    
    visited = []
    for i in range(len(maps)):
        listt = []
        for j in range(len(maps[0])):
            listt.append([False, False])
        visited.append(listt)
    
    for i in range(len(maps)):
        for j in range(len(maps[0])):
            if maps[i][j] == 'S':
                visited[i][j][0] = True
                q.append([i, j, 0, 0])
            elif maps[i][j] == 'E':
                endX = i
                endY = j

    while q:
        x, y, k, time = q.popleft()
        
        if k == 1 and endX == x and endY == y:
            return time
        
        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]) or maps[nx][ny] == 'X':
                continue

            if maps[nx][ny] == 'L':
                if visited[nx][ny][1] == False:
                    visited[nx][ny][1] = True 
                    q.append([nx, ny, 1, time + 1])
                
            else:
                if visited[nx][ny][k] == False:
                    visited[nx][ny][k] = True 
                    q.append([nx, ny, k, time + 1])
                
    return -1

 

 

더보기

헤멘 코드 

 

x = [1, -1, 0, 0]
y = [0, 0, 1, -1]

def bfs(rx, ry, cnt, maps, k, visited):
    for i in range(4):
        rx = rx + x[i]
        ry = ry + y[i]
        rx = int(rx)
        ry = int(ry)

        if rx < 0 or rx >= len(maps) or ry < 0 or ry >= len(maps[0]):
            continue

        if visited[rx][ry][k] == True or maps[rx][ry] == 'X' :
            continue

        if maps[rx][ry] == 'L':
            k = 1
        if k == 1 and maps[rx][ry] == 'E':
            return cnt
    
        
        #print(visited)
        if visited[rx][ry][k] == False:
            bfs(rx, ry, cnt, maps, k, visited)
            visited[rx][ry][k] = True
            cnt += 1
            
    return cnt       
                
        
def solution(maps):
    answer = 0
    m = len(maps)
    n = len(maps[0])
    
    #visited = [[[False for _ in range(2)] for _ in range(m)] for _ in range(n)]
    
    visited = []
    for i in range(len(maps)):
        listt = []
        for j in range(len(maps)):
            listt.append([False, False])
            if maps[i][j] == 'S':
                startX = i
                startY = j
            elif maps[i][j] == 'L':
                laberX = i
                laberY = j
            elif maps[i][j] == 'E':
                endX = i
                endX = j
        
        visited.append(listt)
    
    #print('startX',startX,'startY', startY)
    #print(visited)
    
    k = 0
    print(bfs(startX, startY, 0, maps, k, visited))
                
            
            
            
    
    
    return answer

 

시간/공간 복잡도

O(N^2)

 

최적화 및 개선

queue말고 deque를 사용함

 

어려웠던 점

진짜 헤멧다. 문제를 풀다가 시간초과 했다. 

미로가 직사각형이 될 경우를 꼭 고려해야한다. 

처음에는 q를 사용하기 보단, 재귀함수만으로 문제를 구현하려고 했으나 실패하고 큐를 이용하여 문제를 풀었다. 

 

 

https://school.programmers.co.kr/learn/courses/30/lessons/77486

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

문제설명

민호는 다단계 조직을 이용하여 칫솔을 판매하고 있습니다. 판매원이 칫솔을 판매하면 그 이익이 피라미드 조직을 타고 조금씩 분배되는 형태의 판매망입니다. 어느정도 판매가 이루어진 후, 조직을 운영하던 민호는 조직 내 누가 얼마만큼의 이득을 가져갔는지가 궁금해졌습니다. 예를 들어, 민호가 운영하고 있는 다단계 칫솔 판매 조직이 아래 그림과 같다고 합시다.

 

민호는 center이며, 파란색 네모는 여덟 명의 판매원을 표시한 것입니다. 각각은 자신을 조직에 참여시킨 추천인에 연결되어 피라미드 식의 구조를 이루고 있습니다. 조직의 이익 분배 규칙은 간단합니다. 모든 판매원은 칫솔의 판매에 의하여 발생하는 이익에서 10% 를 계산하여 자신을 조직에 참여시킨 추천인에게 배분하고 나머지는 자신이 가집니다. 모든 판매원은 자신이 칫솔 판매에서 발생한 이익 뿐만 아니라, 자신이 조직에 추천하여 가입시킨 판매원에게서 발생하는 이익의 10% 까지 자신에 이익이 됩니다. 자신에게 발생하는 이익 또한 마찬가지의 규칙으로 자신의 추천인에게 분배됩니다. , 10% 를 계산할 때에는 원 단위에서 절사하며, 10%를 계산한 금액이 1 원 미만인 경우에는 이득을 분배하지 않고 자신이 모두 가집니다.

 

 

문제 해결 방법

딕셔너리를 사용하여 문제를 해결함 

money의 10%는 money // 10을 한 값과 같음 


코드 구현

 

def solution(enroll, referral, seller, amount):
    answer = []

    dic = { }
    dic['-'] = []
    for i in enroll:
        if i in dic:
            continue
        else:
            dic[i] = []
    
    for i in range(len(referral)):
        key = enroll[i]
        dic[key] = referral[i]
    
    
    total = {name : 0 for name in enroll}
    
    for i in range(0, len(seller)):
        key = seller[i]
        
        money = amount[i] * 100
        
        curName = seller[i]
        
        while money > 0 and curName != '-':
            total[curName] +=money - money//10
            curName = dic[curName] # curName의 부모
            money = money//10
    
    
    return [total[name] for name in enroll]

 

시간/공간 복잡도

O(N*M)

N: enroll의 길이 

M: seller의 길이 

 

최적화 및 개선

따로 하지 않음

 

어려웠던 점

문제를 권장 시간안에 풀지 못했음, 부모 자식 관계 구현에 대해 서툴어서 문제 해결 방법을 생각해내지 못했음 

딕셔너리로 풀어야겠다는 생각을 늦게함

+ Recent posts