diff --git a/README.md b/README.md
index 7afd223..6d751ca 100644
--- a/README.md
+++ b/README.md
@@ -35,13 +35,23 @@
 ## 📖History
 [문제 리스트 Notion](https://www.notion.so/f74fd92e29754d839503669f3ec1057e?v=80c1fd8071bc45af88811cb316e0f782)
 
+🏃week24
+
+|번호|제목|
+|:-:|:-:|
+|17683|[방금그곡](https://school.programmers.co.kr/learn/courses/30/lessons/17683)|
+|42885|[구명보트](https://school.programmers.co.kr/learn/courses/30/lessons/42885)|
+|84512|[모음사전](https://school.programmers.co.kr/learn/courses/30/lessons/84512)|
+|86971|[전력망을 둘로 나누기](https://school.programmers.co.kr/learn/courses/30/lessons/86971)|
+
+
 🏃week23
 
 |번호|제목|
 |:-:|:-:|
 |42584|[주식가격](https://school.programmers.co.kr/learn/courses/30/lessons/42584)|
 |42883|[큰 수 만들기](https://school.programmers.co.kr/learn/courses/30/lessons/42883)|
-|118667|[두 큐 합 같게 만들](https://school.programmers.co.kr/learn/courses/30/lessons/118667)|
+|118667|[두 큐 합 같게 만들기](https://school.programmers.co.kr/learn/courses/30/lessons/118667)|
 |159993|[미로 탈출](https://school.programmers.co.kr/learn/courses/30/lessons/159993)|
 
 🏃week22
diff --git "a/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\235\264\354\210\230\353\271\210.py" "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\235\264\354\210\230\353\271\210.py"
new file mode 100644
index 0000000..68ab8bc
--- /dev/null
+++ "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\235\264\354\210\230\353\271\210.py"
@@ -0,0 +1,46 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/17683
+# 0.03ms, 10.3MB / 1.70ms, 10.3MB
+
+'''
+# 문제 이해
+- #이 있고 없고의 차이를 구분해줘야함 
+- 음악은 반드시 처음부터 재생되며 음악 길이보다 재생된 시간이 길 때는 음악이 끊김 없이 처음부터 반복해서 재생
+- 재생된 시간이 짧을 때는 처음부터 재생 시간만큼만 재생
+- 조건이 일치하는 음악이 여러 개일 때에는 라디오에서 재생된 시간이 제일 긴 음악 제목을 반환한다. 재생된 시간도 같을 경우 먼저 입력된 음악 제목을 반환한다.
+
+# 문제 해석
+- # 차이 구분해주기 위해 replace 활용 (소문자로)
+- 음악이 시작, 끝난, 음악 정보, 악보 정보 등을 구분자로 분리해야함
+- 조건에 맞춰서 포함되는지 안 되는지 변경
+- .. 어렵.. 
+
+'''
+
+def replace_code(cc):
+    cc = cc.replace("C#", "c").replace("D#", "d").replace("F#", "f").replace("G#", "g").replace("A#", "a")
+    return cc
+
+def solution(m, musicinfos):
+    res = []
+
+    for musicinfo in musicinfos: # 구분자로 분리하여 각각 저장
+        info = musicinfo.split(',')
+        start = info[0].split(':')
+        end = info[1].split(':')
+        
+        # 재생 시간 구하기고, 네오가 기억한 멜로디로 바꾸고
+        time = (int(end[0]) - int(start[0])) * 60 + int(end[1]) - int(start[1]) 
+        code = replace_code(info[3])
+        # 재생 시간만큼의 코드 구하기
+        code = code * (time // len(code)) + code[:time%len(code)]
+        
+        # 네오가 기억하는 멜로디가 구한 코드에 포함되는지 확인 
+        if replace_code(m) in code:
+            res.append([info[2], time])
+
+    if len(res) == 0:
+        return "(None)" # 후보군에 없을 시 '(None)' 반환
+    
+    else:
+        res = sorted(res, key = lambda x: (-x[1])) # 재생된 시간과, 입력된 순서 기준으로 정렬
+        return res[0][0] 
diff --git "a/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\240\225\352\264\221\353\260\260.py" "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\240\225\352\264\221\353\260\260.py"
new file mode 100644
index 0000000..6d999bd
--- /dev/null
+++ "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\240\225\352\264\221\353\260\260.py"
@@ -0,0 +1,26 @@
+# 방금그곡
+# 테스트 29 〉	통과 (1.27ms, 10.5MB)
+ 
+def replace_code(s):
+    return s.replace("C#", "c").replace("D#", "d").replace("F#", "f").replace("G#", "g").replace("A#", "a")
+
+def change_time(h, m):
+    return h*60+m
+
+def solution(m, musicinfos):
+    answer = '(None)'
+    m = replace_code(m)
+    l = 0
+    for i in musicinfos:
+        start, end, song, code = i.split(',')
+        s_h, s_m = map(int, start.split(':'))
+        e_h, e_m = map(int, end.split(':'))
+        start = change_time(s_h, s_m)
+        end = change_time(e_h, e_m)
+        now_l = end - start
+        code = replace_code(code)
+        code = code*(now_l//len(code))+code[:now_l%len(code)] # 재생 길이만큼 code 늘려주기
+        if m in code and l < now_l:
+            answer = song
+            l = now_l
+    return answer
\ No newline at end of file
diff --git "a/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\265\234\354\210\230\355\230\204.py" "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\265\234\354\210\230\355\230\204.py"
new file mode 100644
index 0000000..a5cd15e
--- /dev/null
+++ "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\265\234\354\210\230\355\230\204.py"
@@ -0,0 +1,34 @@
+def solution(m, musicinfos):
+    answer = []
+    for string in musicinfos:
+        s, e, title, music_s = string.split(',')
+        # 시간 계산
+        s_h, s_m = map(int, s.split(':'))
+        e_h, e_m = map(int, e.split(':'))
+        run = (e_h - s_h) * 60 + e_m - s_m
+        
+        # 음악을 list로 바꾸기
+        i = 0
+        music = []
+        while i < len(music_s):
+            if music_s[i] == '#':
+                music[-1] += '#'
+            else:
+                music.append(music_s[i])
+            i += 1
+        
+        # 재생 시간동안의 음악 만들기
+        run_music = music * (run//len(music)) + music[:run%len(music)]
+
+        # m과 일치하면 제목과 재생시간 tuple로 저장
+        l = len(m.replace('#', ''))
+        for j in range(len(run_music)-l+1):
+            if ''.join(run_music[j:j+l]) == m:
+                answer.append((title, run))
+        
+    if answer:
+        # 재생시간 긴 순으로 정렬 후 첫번째 항목 반환
+        answer.sort(key=lambda x: x[1], reverse=True)
+        return answer[0][0]
+    else:
+        return '(None)'
\ No newline at end of file
diff --git "a/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\265\234\354\235\200\353\271\204.py" "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\265\234\354\235\200\353\271\204.py"
new file mode 100644
index 0000000..765c082
--- /dev/null
+++ "b/week24_230706/pg17683_\353\260\251\352\270\210\352\267\270\352\263\241/pg17683_\354\265\234\354\235\200\353\271\204.py"
@@ -0,0 +1,56 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/17683
+
+def time_convert(s):
+    h, m = map(int, s.split(":"))
+    return h * 60 + m
+
+
+# 샵이 붙은 음을 다른 문자로 치환
+def sharp_convert(note):
+    sharp = {"C#": "H", "D#": "I", "F#": "J", "G#": "K", "A#": "L"}
+    for j in range(len(note)-1):
+        if j + 1 > len(note) - 1:
+            return note
+
+        tmp = note[j]+note[j+1]
+        if tmp in sharp:
+            note = note.replace(tmp, sharp[tmp])
+            
+    return note
+
+
+def solution(m, musicinfos):
+    answer = ''
+    musics = []
+    m = sharp_convert(m)
+    
+    for i in range(len(musicinfos)):
+        start, end, name, note = musicinfos[i].split(",")
+        # 음악의 재생시간
+        time = time_convert(end) - time_convert(start)
+        note = sharp_convert(note)
+                
+        # 음악 재생시간이 악보보다 짧으면 재생한 만큼을 따로 저장
+        if time < len(note):
+            playing = note[:time]
+        # 재생시간이 악보보다 길면 악보를 이어붙여서 재생시간만큼 늘려주기
+        else:
+            playing = note * (time//len(note)) + note[:(time%len(note))]
+
+        # 멜로디가 겹치면 [재생시간, 곡 이름] 형식으로 리스트에 저장
+        if m in playing:
+            musics.append([time, name])
+
+    # 겹치는 음악이 없을 경우
+    if not musics:
+        answer = "(None)"
+    else:
+        # 가장 긴 재생시간을 따로 저장하고 출력
+        max_playing = max(musics, key=lambda x: x[0])[0]
+        
+        for time, name in musics:
+            if time == max_playing:
+                answer = name
+                break
+        
+    return answer
\ No newline at end of file
diff --git "a/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\235\264\353\257\274\354\232\261.py" "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\235\264\353\257\274\354\232\261.py"
new file mode 100644
index 0000000..f4888e7
--- /dev/null
+++ "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\235\264\353\257\274\354\232\261.py"
@@ -0,0 +1,40 @@
+# 프로그래머스 42885 구명보트
+
+from collections import deque
+
+def solution(people, limit):
+    answer = 0
+    people = deque(sorted(people))      # 정렬해서 deque에 담음
+
+    while people:                       # 모든 인원이 빠질 때까지
+        person = people.pop()           # 제일 무거운 인원을 태움
+        # 현재 인원에서 제일 가벼운 인원을 같이 태울 수 있으면
+        if len(people) > 0 and person + people[0] <= limit:
+            people.popleft()            # 그 인원도 태움
+        answer += 1                     # 보트 + 1
+
+    return answer
+
+# 정확성  테스트
+# 테스트 1 〉	통과 (1.97ms, 10.3MB)
+# 테스트 2 〉	통과 (0.98ms, 10.2MB)
+# 테스트 3 〉	통과 (1.58ms, 10.1MB)
+# 테스트 4 〉	통과 (1.24ms, 10.1MB)
+# 테스트 5 〉	통과 (0.69ms, 10.2MB)
+# 테스트 6 〉	통과 (0.41ms, 10.1MB)
+# 테스트 7 〉	통과 (0.66ms, 10.3MB)
+# 테스트 8 〉	통과 (0.08ms, 10.2MB)
+# 테스트 9 〉	통과 (0.12ms, 10.2MB)
+# 테스트 10 〉	통과 (0.73ms, 10.4MB)
+# 테스트 11 〉	통과 (0.76ms, 10.3MB)
+# 테스트 12 〉	통과 (0.57ms, 10.2MB)
+# 테스트 13 〉	통과 (1.23ms, 10.2MB)
+# 테스트 14 〉	통과 (0.97ms, 10.2MB)
+# 테스트 15 〉	통과 (0.14ms, 10.1MB)
+
+# 효율성  테스트
+# 테스트 1 〉	통과 (11.20ms, 11MB)
+# 테스트 2 〉	통과 (11.78ms, 11MB)
+# 테스트 3 〉	통과 (10.42ms, 11.1MB)
+# 테스트 4 〉	통과 (13.13ms, 11.1MB)
+# 테스트 5 〉	통과 (11.18ms, 11MB)
\ No newline at end of file
diff --git "a/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\235\264\354\210\230\353\271\210.py" "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\235\264\354\210\230\353\271\210.py"
new file mode 100644
index 0000000..c85ab91
--- /dev/null
+++ "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\235\264\354\210\230\353\271\210.py"
@@ -0,0 +1,45 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/42885
+# 0.07ms, 10MB / 1.57ms, 10.3MB (정확성 테스트)
+# 11.33ms, 10.7MB / 29.87ms, 10.5MB (효율성 테스트)
+
+
+'''
+# 문제 이해
+- 보트는 2명씩만 탈 수 있고, 무게제한이 있음
+- 구명 보트를 최대한 적게 사용해서 모든 사람을 구출해야함 
+
+# 문제 해석 
+- 최대한 적게 모든 사람 구출  -> "그리디" 활용
+- 가장 적은 보트를 사용하려면?  
+    : 가장 무거운 사람을 먼저 태우고, 남은 1자리를 제일 가벼운 사람부터  고려해야함 
+-> 따라서, "sort와 queue를 활용하여, 가장 많이 나가는 사람과 적게 나가는 사람을 pop하여 계산"
+
+'''
+ 
+from collections import deque
+
+def solution(people, limit):
+    boat = 0
+    people.sort() # 사람들의 무게를 오름차순 정렬
+
+    q = deque(people)
+    while q:
+        if len(q) >= 2:
+            # 제일 많이 나가는 사람과 적게 나가는 사람을 더해서 limit과  비교 
+
+            if q[0] + q[-1] <= limit: # limit보다 적게 나간다면, 그 두 사람을 pop하고, 보트 수를 하나 증가 
+                q.pop() 
+                q.popleft()
+                boat += 1 # 보트를 타고 나가는 것! 
+
+            elif q[0] + q[-1] > limit: # limit을 초과한다면, 무거운 한 사람만 보트를 타고 나갈 수 있음 
+                q.pop()
+                boat += 1
+        else:
+            # 제일 가벼운 사람 한 사람이 남았을 것 
+            if q[0] <= limit:
+                q.pop()
+                boat += 1
+    return boat
+
+
diff --git "a/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\240\225\352\264\221\353\260\260.py" "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\240\225\352\264\221\353\260\260.py"
new file mode 100644
index 0000000..f972e24
--- /dev/null
+++ "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\240\225\352\264\221\353\260\260.py"
@@ -0,0 +1,15 @@
+# 구명보트
+# 테스트 2 〉	통과 (10.06ms, 10.6MB)
+
+def solution(people, limit):
+    answer = 0
+    people.sort()
+    
+    s = 0
+    e = len(people) - 1
+    while s <= e:
+        if people[s] + people[e] <= limit:
+            s += 1
+        answer += 1
+        e -= 1
+    return answer
\ No newline at end of file
diff --git "a/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\265\234\354\210\230\355\230\204.py" "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\265\234\354\210\230\355\230\204.py"
new file mode 100644
index 0000000..23708b6
--- /dev/null
+++ "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\265\234\354\210\230\355\230\204.py"
@@ -0,0 +1,40 @@
+# 정확성: 75 / 75
+# 효율성: 10 / 25
+# 합계: 85.0 / 100.0
+
+def solution(people, limit):
+    people.sort()
+    check = [False] * len(people)
+    i = 0
+    ans = 0
+    
+    while 1:
+        # 방문한 경우 건너뛰기
+        if check[i]:
+            i += 1
+            continue
+        
+        # 방문하지 않은 경우
+        # 어차피 태워야하므로 방문처리 & ans +1하고 시작
+        check[i] = True
+        ans += 1
+
+        # 같이 탈 수 있는 사람 중 무게가 가장 많이 나가는 사람 고르기
+        max_pair = 0
+        for j in range(i+1,len(people)):
+            if not check[j] and people[i] + people[j] <= limit:
+                max_pair = j
+            else:
+                break
+        
+        # 같이 탈 수 없는 사람이 없으면 뒤에도 어차피 없으므로 break
+        if max_pair == 0:
+            break
+        else:
+            check[max_pair] = True
+            i += 1
+    
+    # 보트에 못 탄 사람 보트 하나씩 써야함
+    ans += len(check) - sum(check)
+    
+    return ans
\ No newline at end of file
diff --git "a/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\265\234\354\235\200\353\271\204.py" "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\265\234\354\235\200\353\271\204.py"
new file mode 100644
index 0000000..411134d
--- /dev/null
+++ "b/week24_230706/pg42885_\352\265\254\353\252\205\353\263\264\355\212\270/pg42885_\354\265\234\354\235\200\353\271\204.py"
@@ -0,0 +1,27 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/42885
+
+from collections import deque
+
+def solution(people, limit):
+    answer = 0
+    # 무게순으로 정렬
+    people = deque(sorted(people))
+    
+    while people:
+        if len(people) > 1:
+            # 가장 무거운 사람과 가장 가벼운 사람을 태웠을 때 무게 제한을 넘으면
+            # 가장 무거운 사람만 보내기
+            if people[0] + people[-1] > limit:
+                people.pop()
+
+            # 제한을 넘지 않으면 둘 다 태우기
+            else:
+                people.popleft()
+                people.pop()
+
+        else:
+            people.pop()
+            
+        answer += 1
+    
+    return answer
\ No newline at end of file
diff --git "a/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\235\264\353\257\274\354\232\261.py" "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\235\264\353\257\274\354\232\261.py"
new file mode 100644
index 0000000..2131fba
--- /dev/null
+++ "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\235\264\353\257\274\354\232\261.py"
@@ -0,0 +1,67 @@
+# 프로그래머스 84512 모음사전
+
+cnt = 0
+def dfs(q,word):
+    global cnt, answer
+    if q == word:
+        answer = cnt
+        return
+    
+    if len(q) == 5: return
+
+    li = ['A','E','I','O','U']
+    for i in range(5):
+        cnt += 1
+        q.append(li[i])
+        dfs(q,word)
+        q.pop()
+
+    return
+
+def solution(word):
+    word = list(word)
+    q = []
+    dfs(q,word)
+
+    return answer
+
+# 테스트 1 〉	통과 (1.25ms, 10.1MB)
+# 테스트 2 〉	통과 (1.43ms, 10.2MB)
+# 테스트 3 〉	통과 (1.42ms, 10.2MB)
+# 테스트 4 〉	통과 (1.32ms, 10.3MB)
+# 테스트 5 〉	통과 (1.34ms, 10.2MB)
+# 테스트 6 〉	통과 (1.30ms, 10.3MB)
+# 테스트 7 〉	통과 (2.41ms, 10.2MB)
+# 테스트 8 〉	통과 (1.60ms, 10.1MB)
+# 테스트 9 〉	통과 (1.29ms, 10.3MB)
+# 테스트 10 〉	통과 (1.87ms, 10.1MB)
+# 테스트 11 〉	통과 (2.28ms, 10.1MB)
+# 테스트 12 〉	통과 (2.24ms, 10.1MB)
+# 테스트 13 〉	통과 (2.03ms, 10.2MB)
+# 테스트 14 〉	통과 (1.33ms, 10.1MB)
+# 테스트 15 〉	통과 (1.30ms, 10.2MB)
+# 테스트 16 〉	통과 (1.44ms, 10.2MB)
+# 테스트 17 〉	통과 (1.40ms, 10.2MB)
+# 테스트 18 〉	통과 (2.51ms, 10.2MB)
+# 테스트 19 〉	통과 (2.58ms, 10.1MB)
+# 테스트 20 〉	통과 (1.37ms, 10.3MB)
+# 테스트 21 〉	통과 (1.49ms, 10.1MB)
+# 테스트 22 〉	통과 (1.94ms, 10.2MB)
+# 테스트 23 〉	통과 (2.82ms, 10.3MB)
+# 테스트 24 〉	통과 (2.45ms, 10.2MB)
+# 테스트 25 〉	통과 (1.37ms, 10.1MB)
+# 테스트 26 〉	통과 (1.71ms, 10.1MB)
+# 테스트 27 〉	통과 (1.34ms, 10.2MB)
+# 테스트 28 〉	통과 (2.57ms, 10.2MB)
+# 테스트 29 〉	통과 (1.36ms, 10.3MB)
+# 테스트 30 〉	통과 (1.22ms, 10.2MB)
+# 테스트 31 〉	통과 (1.27ms, 10.2MB)
+# 테스트 32 〉	통과 (2.63ms, 10.3MB)
+# 테스트 33 〉	통과 (1.45ms, 10.1MB)
+# 테스트 34 〉	통과 (1.24ms, 10.1MB)
+# 테스트 35 〉	통과 (2.13ms, 10.3MB)
+# 테스트 36 〉	통과 (1.34ms, 10.2MB)
+# 테스트 37 〉	통과 (2.52ms, 10.2MB)
+# 테스트 38 〉	통과 (2.58ms, 10.2MB)
+# 테스트 39 〉	통과 (2.22ms, 10.2MB)
+# 테스트 40 〉	통과 (2.38ms, 10.3MB)
\ No newline at end of file
diff --git "a/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\235\264\354\210\230\353\271\210.py" "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\235\264\354\210\230\353\271\210.py"
new file mode 100644
index 0000000..1156da6
--- /dev/null
+++ "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\235\264\354\210\230\353\271\210.py"
@@ -0,0 +1,25 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/84512
+# 1.23ms, 10.3MB / 2.50ms, 10.3MB
+
+'''
+# 문제 이해
+- 알파벳 순서와 길이에 따라 순서가 결정됨 
+- 'A', 'E', 'I', 'O', 'U' 로 만들 수 있는 모든 경우의 수를 판단 
+
+# 문제 해석 
+- word 길이는 1이상 5이하 -> 중복순열로 모든 조합을 계산하고, index로 찾기
+
+'''
+ 
+from itertools import product
+
+def solution(word):
+    words = []
+    for i in range(1, 6):
+        for j in product(['A', 'E', 'I', 'O', 'U'], repeat=i): # 1에서 5개까지 모든 조합을 구함
+            words.append(''.join(list(j))) # 하나의 단어로 
+
+    words.sort() # 정렬
+    # 그 이후 index를 사용하여 찾기 
+    res = words.index(word) + 1
+    return res
diff --git "a/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\240\225\352\264\221\353\260\260.py" "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\240\225\352\264\221\353\260\260.py"
new file mode 100644
index 0000000..3507126
--- /dev/null
+++ "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\240\225\352\264\221\353\260\260.py"
@@ -0,0 +1,15 @@
+# 모음사전
+# 테스트 17 〉	통과 (0.11ms, 10.4MB)
+
+from itertools import product
+
+V = ['A','E','I','O','U']
+words = []
+for i in range(1, 6):
+    for j in product(V, repeat=i):
+        words.append(''.join(j))
+words.sort() # 사전 순 정렬
+
+def solution(word):
+    answer = words.index(word)+1
+    return answer
\ No newline at end of file
diff --git "a/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\265\234\354\210\230\355\230\204.py" "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\265\234\354\210\230\355\230\204.py"
new file mode 100644
index 0000000..bffda4b
--- /dev/null
+++ "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\265\234\354\210\230\355\230\204.py"
@@ -0,0 +1,21 @@
+def solution(word):
+    vowels = ['A', 'E', 'I', 'O', 'U']
+    ans = len(word)
+
+    # word 앞에서부터 한자리씩 보면서 word이전에 나왔을 모든 단어 count
+    # ex) word = 'I'
+    for i in range(len(word)):
+        n = vowels.index(word[i])   # n = 2
+        ans += n                    # I앞에 A,E 2개가 있으므로 +2
+        calc = n                    # 계산할 변수에 A,E 두가지 경우 2 저장
+        for j in range(4-i):        # 현재 자리 문자 뒤에 붙이는 것이므로 5-i-1 -> 4-i
+            calc *= 5               # A, E에 붙일 수 있는 문자 5가지이므로 곱하기 5
+            ans += calc             # 지금 만든 문자의 경우의 수 ans에 더하기
+            
+    return ans
+
+"""
+ans에 word길이만큼을 담는 이유
+ex) 'AAAAA'인 경우
+'AAAAA'이전에 'A', 'AA', 'AAA', 'AAAA'가 있고 'AAAAA'까지 카운트하므로
+"""
\ No newline at end of file
diff --git "a/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\265\234\354\235\200\353\271\204.py" "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\265\234\354\235\200\353\271\204.py"
new file mode 100644
index 0000000..ac69782
--- /dev/null
+++ "b/week24_230706/pg84512_\353\252\250\354\235\214\354\202\254\354\240\204/pg84512_\354\265\234\354\235\200\353\271\204.py"
@@ -0,0 +1,27 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/84512
+
+def solution(word):
+    global answer
+    answer = 0
+    
+    def recursion(tmp):
+        global answer
+        answer += 1
+        
+        if tmp == word:
+            return True
+        
+        if len(tmp) == 5:
+            return False
+        
+        for i in "AEIOU":
+            flag = recursion(tmp+i)
+            if flag:
+                return True
+    
+    for i in "AEIOU":
+        flag = recursion(i)
+        if flag:
+            break
+                
+    return answer
\ No newline at end of file
diff --git "a/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\235\264\353\257\274\354\232\261.py" "b/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\235\264\353\257\274\354\232\261.py"
new file mode 100644
index 0000000..9e09fb1
--- /dev/null
+++ "b/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\235\264\353\257\274\354\232\261.py"
@@ -0,0 +1,49 @@
+# 프로그래머스 86971 전력망을 둘로 나누기
+
+from collections import deque
+
+def bfs(x,g,vi):        # bfs로 연결된 송전탑 개수 구하기
+    q = deque([x])
+    vi[x] = 1
+    cnt = 1
+
+    while q:
+        now = q.popleft()
+        
+        for i in g[now]:
+            if not vi[i]:
+                vi[i] = 1
+                cnt += 1
+                q.append(i)
+                
+    return cnt
+
+def solution(n, wires):
+    answer = n
+    g = [[] for _ in range(n+1)]
+    
+    for v1,v2 in wires:         # 노드 생성
+        g[v1].append(v2)
+        g[v2].append(v1)
+            
+    for a,b in wires:           # 간선 정보를 꺼내서
+        vi = [0] * (n+1)        # 방문 리스트
+        vi[b] = 1               # b를 방문처리해서 a-b 간선을 없앰
+        cnt = bfs(a,g,vi)       # a와 연결된 송전탑 개수 구하는 bfs 실행
+        answer = min(answer, abs(cnt - (n-cnt)))    # 최솟값 갱신
+        
+    return answer
+
+# 테스트 1 〉	통과 (0.24ms, 10.1MB)
+# 테스트 2 〉	통과 (1.20ms, 10.2MB)
+# 테스트 3 〉	통과 (1.93ms, 10.2MB)
+# 테스트 4 〉	통과 (3.84ms, 10.3MB)
+# 테스트 5 〉	통과 (2.07ms, 10.3MB)
+# 테스트 6 〉	통과 (0.02ms, 10.1MB)
+# 테스트 7 〉	통과 (0.01ms, 10.2MB)
+# 테스트 8 〉	통과 (0.07ms, 9.94MB)
+# 테스트 9 〉	통과 (0.05ms, 10.1MB)
+# 테스트 10 〉	통과 (1.25ms, 10.2MB)
+# 테스트 11 〉	통과 (1.12ms, 10.3MB)
+# 테스트 12 〉	통과 (1.94ms, 10.2MB)
+# 테스트 13 〉	통과 (1.93ms, 10.2MB)
\ No newline at end of file
diff --git "a/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\265\234\354\210\230\355\230\204.py" "b/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\265\234\354\210\230\355\230\204.py"
new file mode 100644
index 0000000..740f8f8
--- /dev/null
+++ "b/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\265\234\354\210\230\355\230\204.py"
@@ -0,0 +1,39 @@
+from collections import deque
+
+
+# 인접행렬과 자를 와이어 인자로 전달
+def bfs(arr, cut):
+    check = [False] * len(arr)
+    q = deque([1])
+    check[1] = True
+    cnt = 1
+    
+    while q:
+        x = q.popleft()
+        for connect in arr[x]:
+            if connect in cut and x in cut: # 자르는 와이어인 경우 count안하고 방문처리
+                check[connect] = True
+            if not check[connect]:
+                check[connect] = True
+                q.append(connect)
+                cnt += 1
+    return cnt
+
+
+def solution(n, wires):
+    # 인접행렬 생성
+    matrix = [[] for _ in range(n+1)]
+    for w in wires:
+        a, b = w
+        matrix[a].append(b)
+        matrix[b].append(a)
+    
+    wires.sort(key=lambda x: x[1])
+    ans = 100  # 큰 수 100
+    for w in wires:
+        # 이어진 전력망 bfs탐색으로 count
+        first = bfs(matrix, w)
+        second = n - first
+        ans = min(ans, abs(first-second))
+    
+    return ans
\ No newline at end of file
diff --git "a/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\265\234\354\235\200\353\271\204.py" "b/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\265\234\354\235\200\353\271\204.py"
new file mode 100644
index 0000000..5f6bece
--- /dev/null
+++ "b/week24_230706/pg86971_\354\240\204\353\240\245\353\247\235\354\235\204_\353\221\230\353\241\234_\353\202\230\353\210\204\352\270\260/pg86971_\354\265\234\354\235\200\353\271\204.py"
@@ -0,0 +1,46 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/86971
+
+from collections import deque
+
+def bfs(graph, visited):
+    que = deque()
+    cnt = 1
+    
+    # graph의 첫번째 원소 찾기
+    for i in range(1, len(graph)):
+        if graph[i]:
+            que.append(graph[i][0])
+            break
+            
+    while que:
+        now = que.popleft()
+        visited[now] = True
+        
+        for next in graph[now]:
+            if not visited[next]:
+                que.append(next)
+                cnt += 1
+    
+    return cnt
+
+
+def solution(n, wires):
+    answer = int(1e9)
+
+    for i in range(len(wires)):
+        graph = [[] for _ in range(n+1)]
+
+        # 전선을 하나씩 다 끊어보기
+        for a, b in wires:
+            if a == wires[i][0] and b == wires[i][1]:
+                continue
+                
+            graph[a].append(b)
+            graph[b].append(a)
+            
+        visited = [False] * (n+1)
+        cnt = bfs(graph, visited)
+        
+        answer = min(answer, abs((n-cnt) - cnt))
+        
+    return answer
\ No newline at end of file