This, Too, Shall Pass Away

✏️ 내가 작성한 코드 

def solution(clothes):
    dic = {}
    sum = 1
    
    # 의상 종류별로 의상이름 리스트 만들어서 넣어주기
    for cloth in clothes:
        if cloth[1] not in dic:
            dic[cloth[1]] = []
        dic[cloth[1]].append(cloth[0])
    
    # 의상 이름 개수 세기 위해 리스트로 만들기
    dicValList = list(dic.values())
    
    for i in range (len(dicValList)):
        # 의상 종류에서 아무것도 안입는 경우의 수 1을 추가
        # 예) 안경, 선글라스, 아무것도 안 입기
        sum *= len(dicValList[i]) + 1
        
    return sum - 1 # 전부 입지 않은 경우의 수 빼야함

✏️ 참고  (sum에서 곱할 때 +1 하면서 곱하는 이유?)

선택지를 

dicValList[0] : 동그란 안경, 검정 선글라스, 아무것도 안입기
dicValList[1] : 파란색 티셔츠, 아무것도 안입기
dicValList[2] : 청바지, 아무것도 안입기
dicValList[3] : 긴 코트, 아무것도 안입기

이런식으로 구성한다고 생각하며 +1를 하였다.

그 이유는 예를 들어 의상을 구성할 때

동그란 안경 +  파란색 티셔츠

동그란 안경 + 아무것도 안입기

이런식으로 구성이 가능하기때문에 1개(동그란 안경)만 의상을 착용한 경우도 나타낼 수 있다.

단, 아무것도 안입기 +  아무것도 안입기 +  아무것도 안입기 +  아무것도 안입기 도 sum에 포함되기 때문에 

이건 빼줘야하므로 -1을 하면서 return한다.

✏️ 내가 작성한 코드 - BFS

from collections import deque

def chk(word1, word2):
    cnt = 0
    
    for i in range(len(word1)):
        if word1[i] != word2[i]:
            cnt += 1

    if cnt > 1 or cnt == 0:
        return 0
    else:
        return 1


def solution(begin, target, words):
    step = 0
    visit = [False] * len(words)
    q = deque()
    q.append([begin, 0])

    if target not in words:  # target이 words에 없으면 0 리턴
        step = 0
    else:
        while q:
            word, cnt = q.popleft()

            if word == target:
                step = cnt
                break

            for w in range(len(words)):
                if visit[w] == False and chk(words[w], word):
                    visit[w] = True
                    q.append([words[w], cnt + 1])

    return step

✏️ 참고

1. 한 번에 한 개의 알파벳만 바꿀 수 있습니다.

위 조건을 참고하여, chk 함수를 작성하였다.

두 단어 각 알파벳을 비교하며 cnt를 증가시키고 cnt가 1인 경우에만 조건에 해당한다.

✏️ 내가 작성한 코드

def solution(genres, plays):
    play_dic = {} # 인덱스, 재생수 딕셔너리
    total_play_dic = {} # 총 재생수 딕셔너리
    album_list = [] # 고유번호가 들어있는 최종 베스트 앨범

    for i,genre in enumerate(genres):
        try:
            total_play_dic[genre] += plays[i]
            play_dic[genre] += [(i, plays[i])]
        except:
            total_play_dic[genre] = plays[i]
            play_dic[genre] = [(i,plays[i])]

    for i in sorted(total_play_dic.items(),key=lambda x:x[1],reverse=True):
        sort_play_dic = sorted(play_dic[i[0]], key=lambda x:(-x[1],x[0])) # 내림차순은 -x, 오름차순은 x
        i_cnt = 0
        for play in sort_play_dic:
            if i_cnt == 2: # 장르별로 노래 2개씩만 앨범에 담음. 따라서 2개 되면 break
                break
            album_list.append(play[0])
            i_cnt += 1

    return album_list

✏️ 참고

1 ) 첫번째 for문에서 try, except하는 이유 :

처음에는 딕셔너리 내에 key가 존재하지않기 때문에 total_play_dic[genre], play_dic[genre]에 += 구문을 사용하여 value에 값을 더하려고 하면 에러가 발생한다.

그래서 예외처리로 키와 값을 지정하여 아래처럼 각 딕셔너리에 첫 값을 지정해준다.             

total_play_dic[genre] = plays[i]
play_dic[genre] = [(i,plays[i])]

2 ) 딕셔너리.items()를 사용하면 value값으로 정렬이 가능하다. (sorted() 사용)

* sort() : 딕셔너리, 튜플, 문자열에는 사용 불가,
sorted() :딕셔너리, 튜플, 문자열에도 사용 가능

3 ) sorted에서 key를 여러개 하여 정렬할때, lamda에서 x 통해 여러개 지정 가능.

ex ) key=lambda x:(-x[1],x[0]) 

reverse대신 '-' 사용하여 내림차순 사용 > x 앞에 - 붙으면 '내림차순', 안붙으면 '오름차순'

✏️ 내가 작성한 코드

def solution(n, words):
    answer = [0,0]

    for idx,word in enumerate(words):
        if idx < 1:
            pass
        else:
            if (word in words[:idx]) or (word[0] != words[idx-1][-1]): # 전에 등장한 단어, 이전단어 끝자리로 시작 안하는 단어인 경우
                answer[0] = (idx%n)+1
                answer[1] = (idx//n)+1
                break
    return answer

✏️ 내가 작성한 코드 - BFS

from collections import deque

def solution(maps):

    q = deque()
    q.append([0,0])

    n = len(maps) # 행
    m = len(maps[0]) # 열

    move = [[1,0],[-1,0],[0,-1],[0,1]] # 움직임(상,하,좌,우)
    visit = [[-1]*m for _ in range(n)] # 방문 배열 (visit에 해당 행,열까지의 거리 저장함.)
    visit[0][0] = 1 # 거리구할때 0행0열도 포함해서 구하므로 1부터시작.

    while q:
        dn, dm = q.popleft() # 이동 시작할 행,열

        for i in range(4): # 상,하,좌,우로 4가지 방향으로 이동 가능
            next_dn = dn + move[i][0]
            next_dm = dm + move[i][1]

            if next_dn >= n or next_dn < 0 or next_dm >= m or next_dm < 0: # 지도 범위 벗어나면
                continue
            if maps[next_dn][next_dm] == 1 and visit[next_dn][next_dm] == -1: # 지도에서 벽이아님(1) and 방문한적없음(visit[행][열]=-1)
                visit[next_dn][next_dm] = visit[dn][dm] + 1 # 해당 행열까지의 거리수로 update
                q.append([next_dn,next_dm])
    return visit[n-1][m-1]

✏️ 참고

visit에 방문했냐/안했냐(True/False)를 넣는 게 아니라 해당 [행][열]까지의 거리를 계산해서 넣고

마지막 위치인 [n-1][m-1]을 출력해주면서 최단 거리를 구하면된다.

✏️ 내가 작성한 코드 - DFS

def dfs(i,n,computers,visit):

    visit[i] = True # 제한사항 : computer[i][i]는 항상 1입니다. -> 따라서 일단 방문처리 해야함.

    for com in range(n):
        if computers[com][i] == 1 and (not visit[com]) : # 방문된 적 없는 연결된 다른 컴퓨터 존재
            dfs(com,n,computers,visit)

def solution(n, computers):
    network_cnt = 0
    visit = [False]*n # 컴퓨터 방문 현황 Fasle로 초기화

    for i in range(n):
        if visit[i] == False: # 방문하지 않은 컴퓨터
            dfs(i,n,computers,visit)
            network_cnt += 1

    return network_cnt

✏️ 내가 작성한 코드 - BFS

from collections import deque
def bfs(n,i,computers,visit):
    q = deque()
    q.append(i)
    visit[i] = True

    while q:
        com = q.popleft()
        for c in range(n):
            if computers[c][com] == 1 and visit[c] == False:
                visit[c] = True
                q.append(c)

def solution(n, computers):
    nexwork_cnt = 0
    visit = [False]*n

    for i in range(n):
        if visit[i] == False:
            bfs(n,i,computers,visit)
            nexwork_cnt += 1

    return nexwork_cnt

✏️ 참고

제한사항 중 computer[i][i]는 항상 1입니다.  이 부분 잘 확인해야 함.

✏️ 문제 설명
n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3
사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.

✏️ 제한사항
주어지는 숫자의 개수는 2개 이상 20개 이하입니다.
각 숫자는 1 이상 50 이하인 자연수입니다.
타겟 넘버는 1 이상 1000 이하인 자연수입니다.
입출력 예
numbers target return
[1, 1, 1, 1, 1] 3 5
[4, 1, 2, 1] 4 2
✏️ 입출력 예 설명
입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

+4+1-2+1 = 4
+4-1+2-1 = 4
총 2가지 방법이 있으므로, 2를 return 합니다.

✏️ 내가 작성한 코드 - BFS

from collections import deque

def solution(numbers, target):

    # bfs
    answer = 0
    queue = deque()
    queue.append([numbers[0],0]) # numbers 첫번째 원소 +,-해서 큐에 넣어줌
    queue.append([-(numbers[0]),0])

    while queue:

        pop_number = queue.popleft()

        idx = pop_number[1]  
        number = pop_number[0] 
        idx += 1

        if idx < len(numbers):
            queue.append([number + numbers[idx], idx])
            queue.append([number - numbers[idx], idx])
        else: # 배열의 끝까지 덧셈해줬을때 카운팅해줌
            if number == target:
                answer += 1

    return answer

✏️ 문제 설명
전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

구조대 : 119
박준영 : 97 674 223
지영석 : 11 9552 4421
전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

✏️ 제한 사항
phone_book의 길이는 1 이상 1,000,000 이하입니다.
각 전화번호의 길이는 1 이상 20 이하입니다.
같은 전화번호가 중복해서 들어있지 않습니다.

✏️ 입출력 예제

✏️ 입출력 예 설명
입출력 예 #1
앞에서 설명한 예와 같습니다.

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

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

✏️ 내가 작성한 코드 - 1 (효율성 테스트 3,4 시간초과로 통과 X >> 이유 : for문 2개)

def solution(phone_book):
    phone_book.sort(key=lambda x:len(x))
    answer = True

    for i in range(len(phone_book)):

        phone_len = len(phone_book[i])

        if phone_book[i] in [i[:phone_len] for i in phone_book[i+1:]]:
            answer = False
            break

    return answer

✏️ 내가 작성한 코드 - 2 (통과 O)

def solution(phone_book):
    phone_book.sort() # 배열 정렬 : 번호는 문자열로 들어가있으므로, 문자열 기준으로 정렬됨
    answer = True

    for i,phone in enumerate(phone_book):
        if i+1 == len(phone_book): # 배열의 끝까지 순회했음에도 불구하고 한번호가 다른번호의 접두어인 경우가 없을때는 break해줘야함
            break

        # int정렬이 아닌 str정렬이므로 바로 다음 번호에서 앞 번호가 포함되어있는지 확인하면됨
        if phone_book[i+1].startswith(phone): # startswith() : 괄호안의 문자열이 포함되어 있는지 확인할 수 있음
            answer = False
            break

    return answer

✏️ 참고

arr1 = ["12","123","1235","567","88"]
arr2 = [12, 123, 1235, 567, 88]
arr1.sort() # ['12', '123', '1235', '567', '88']
arr2.sort() # [12, 88, 123, 567, 1235]

phone_book의 원소들은 '문자열'이다.

위에 보다시피 정수일때 sort()는 숫자 크기에 따라 정렬되지만,

문자열일때 sort()는 아스키코드 숫자로 변환돼서 맨앞자리부터 비교되면서 정렬된다.

따라서 다른 번호를 접두어로 가지고 있는 번호는 다른번호의 바로 다음 위치에 존재할 수 있게된다.