์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- ๋ธ๋ฃจํธํฌ์ค
- dfs
- ๋นํธ๋ง์คํน
- ๊ตฌํ
- DP
- ์๋๋ก์ด๋
- ์ ๋ ฌ
- ๋ถ๋ถ์งํฉ
- Python
- ํ๋ก์ด๋์์ฌ
- SQL
- ํ๋ก๊ทธ๋๋จธ์ค
- ๋ฌธ์์ด
- Deque
- ์ฌ๊ท
- ์กฐํฉ
- ์๋ฎฌ๋ ์ด์
- BOJ
- ๋ค์ต์คํธ๋ผ
- HashMap
- ๋ถํ ์ ๋ณต
- ์ด๋ถํ์
- ํ์ด์ฌ
- bfs
- ๋ฐฑํธ๋ํน
- 3์ฐจ์๋ฐฐ์ด
- heapq
- ๋ฐฐ๋ญ๋ฌธ์
- Java
- ์๊ณ ๋ฆฌ์ฆ
- Today
- Total
๋ชฉ๋กPython (9)
It's easy, if you try
๋ฌธ์ ๋งํฌ: https://www.acmicpc.net/problem/1766 ํ์ด import sys input = sys.stdin.readline import heapq n, m = map(int, input().split()) tree = [[] for _ in range(n+1)] inDegree = [0 for _ in range(n+1)] for _ in range(m): a, b = map(int, input().split()) tree[a].append(b) inDegree[b] += 1 q = [] for i in range(1,n+1): if inDegree[i] == 0: # ์ฐจ์๊ฐ 0 ์ธ ๋ฌธ์ ๋ฅผ ์ต์ ํ์ push heapq.heappush(q, i) result = [] while..
๋ฌธ์ n๋ช ์ด ์ ๊ตญ์ฌ์ฌ๋ฅผ ์ํด ์ค์ ์์ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ต๋๋ค. ๊ฐ ์ ๊ตญ์ฌ์ฌ๋์ ์๋ ์ฌ์ฌ๊ด๋ง๋ค ์ฌ์ฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋ค๋ฆ ๋๋ค. ์ฒ์์ ๋ชจ๋ ์ฌ์ฌ๋๋ ๋น์ด์์ต๋๋ค. ํ ์ฌ์ฌ๋์์๋ ๋์์ ํ ๋ช ๋ง ์ฌ์ฌ๋ฅผ ํ ์ ์์ต๋๋ค. ๊ฐ์ฅ ์์ ์ ์๋ ์ฌ๋์ ๋น์ด ์๋ ์ฌ์ฌ๋๋ก ๊ฐ์ ์ฌ์ฌ๋ฅผ ๋ฐ์ ์ ์์ต๋๋ค. ํ์ง๋ง ๋ ๋นจ๋ฆฌ ๋๋๋ ์ฌ์ฌ๋๊ฐ ์์ผ๋ฉด ๊ธฐ๋ค๋ ธ๋ค๊ฐ ๊ทธ๊ณณ์ผ๋ก ๊ฐ์ ์ฌ์ฌ๋ฅผ ๋ฐ์ ์๋ ์์ต๋๋ค. ๋ชจ๋ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต์๋ก ํ๊ณ ์ถ์ต๋๋ค. ์ ๊ตญ์ฌ์ฌ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์ฌ๋ ์ n, ๊ฐ ์ฌ์ฌ๊ด์ด ํ ๋ช ์ ์ฌ์ฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๋ด๊ธด ๋ฐฐ์ด times๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ ์ ๊ตญ์ฌ์ฌ๋ฅผ ๊ธฐ..
title: "[์๊ณ ๋ฆฌ์ฆ] ๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ - 9252 LCS2 (ํ์ด์ฌ/python)" date: 2020-05-17 18:30:00 tags: ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ LCS(Longest Common Subsequence, ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด)๋ฌธ์ ๋ ๋ ์์ด์ด ์ฃผ์ด์ก์ ๋, ๋ชจ๋์ ๋ถ๋ถ ์์ด์ด ๋๋ ์์ด ์ค ๊ฐ์ฅ ๊ธด ๊ฒ์ ์ฐพ๋ ๋ฌธ์ ์ด๋ค. ์๋ฅผ ๋ค์ด, ACAYKP์ CAPCAK์ LCS๋ ACAK๊ฐ ๋๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค๊ณผ ๋์งธ ์ค์ ๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋ค. ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ์ต๋ 1000๊ธ์๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ฌธ์์ด์ LCS์ ๊ธธ์ด๋ฅผ, ๋์งธ ์ค์ LCS๋ฅผ ์ถ๋ ฅํ๋ค. LCS๊ฐ ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ์๋ ์๋ฌด๊ฑฐ๋ ์ถ๋ ฅํ๊ณ , LCS์ ๊ธธ์ด๊ฐ 0์ธ ๊ฒฝ์ฐ์๋ ๋์งธ ์ค..
๋ฌธ์ LCS(Longest Common Subsequence, ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด)๋ฌธ์ ๋ ๋ ์์ด์ด ์ฃผ์ด์ก์ ๋, ๋ชจ๋์ ๋ถ๋ถ ์์ด์ด ๋๋ ์์ด ์ค ๊ฐ์ฅ ๊ธด ๊ฒ์ ์ฐพ๋ ๋ฌธ์ ์ด๋ค. ์๋ฅผ ๋ค์ด, ACAYKP์ CAPCAK์ LCS๋ ACAK๊ฐ ๋๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค๊ณผ ๋์งธ ์ค์ ๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋ค. ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ์ต๋ 1000๊ธ์๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ฌธ์์ด์ LCS์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค. ์์ ์ ๋ ฅ 1 ACAYKP CAPCAK ์์ ์ถ๋ ฅ 1 4 ์ถ์ฒ ๋ฌธ์ ๋ฅผ ๋ง๋ ์ฌ๋: baekjoon ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ ์ฌ๋: qpwoeiruty ์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ [๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ](https://www.acmicpc.net/problem/tag/๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ..
ํ์ด T = int(input()) # ์ฌ๋ฌ๊ฐ์ ํ ์คํธ ์ผ์ด์ค๊ฐ ์ฃผ์ด์ง๋ฏ๋ก, ๊ฐ๊ฐ์ ์ฒ๋ฆฌํฉ๋๋ค. days = {1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30, 7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31} for test_case in range(1, T + 1): case = str(input()) year = case[0:4] month = case[4:6] day = case[6:8] answer = '' if 0 '1') ๋ก ๋ฐ๊พผ ํ ์ถ๋ ฅํ๋ฉด ์๋๋ค. ๋ง์ฝ ํ๋๋ผ๋ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ๋ชปํ๋ฉด '#[test_case] -1'์ ์ถ๋ ฅํ๋ค. ์ต์ด ๋ฐํ ๋ ์ง: 20..
heapq ๋ชจ๋์ ๋ํด ๊ฐ๋ตํ ์์๋ณด์ ! Heap ์ด๋ ? ํ(heap)์ ์ต๋๊ฐ ๋ฐ ์ต์๊ฐ์ ์ฐพ์๋ด๋ ์ฐ์ฐ์ ๋น ๋ฅด๊ฒ ํ๊ธฐ ์ํด ๊ณ ์๋ ์์ ์ด์งํธ๋ฆฌ(complete binary tree)๋ฅผ ๊ธฐ๋ณธ์ผ๋ก ํ ์๋ฃ๊ตฌ์กฐ(tree-based structure)๋ก์ ๋ค์๊ณผ ๊ฐ์ ํ ์์ฑ(property)์ ๋ง์กฑํ๋ค. A๊ฐ B์ ๋ถ๋ชจ๋ ธ๋(parent node)์ด๋ฉด, A์ ํค(key)๊ฐ๊ณผ B์ ํค๊ฐ ์ฌ์ด์๋ ๋์๊ด๊ณ๊ฐ ์ฑ๋ฆฝํ๋ค. ํ์๋ ๋๊ฐ์ง ์ข ๋ฅ๊ฐ ์์ผ๋ฉฐ, ๋ถ๋ชจ๋ ธ๋์ ํค๊ฐ์ด ์์๋ ธ๋์ ํค๊ฐ๋ณด๋ค ํญ์ ํฐ ํ์ '์ต๋ ํ', ๋ถ๋ชจ๋ ธ๋์ ํค๊ฐ์ด ์์๋ ธ๋์ ํค๊ฐ๋ณด๋ค ํญ์ ์์ ํ์ '์ต์ ํ'์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์๋ ์ฌ์ง์ ์ต๋ ํ์ ์์์ด๋ค. ์ถ์ฒ : ์ํค๋ฐฑ๊ณผ 'ํ (์๋ฃ ๊ตฌ์กฐ)' heapq ์์ ์ด์งํธ๋ฆฌ ๊ธฐ๋ฐ์ ์ต์ ํ ์..
์ธ๋์ค์ฝ์ด(_) ํฌ๊ฒ ๋ค์ฏ๊ฐ์ง์ ์ํฉ์์ ์ฌ์ฉ๋๋ค. ์ธํฐํ๋ฆฌํฐ(Interpreter)์์ ๋ง์ง๋ง ๊ฐ์ ์ ์ฅํ ๋ ๊ฐ์ ๋ฌด์ํ๊ณ ์ถ์ ๋ (ํํ “I don’t care”๋ผ๊ณ ๋ถ๋ฅธ๋ค.) ๋ณ์๋ ํจ์๋ช ์ ํน๋ณํ ์๋ฏธ ๋๋ ๊ธฐ๋ฅ์ ๋ถ์ฌํ๊ณ ์ ํ ๋ ๊ตญ์ ํ(Internationalization, i18n)/์ง์ญํ(Localization, l10n) ํจ์๋ก์จ ์ฌ์ฉํ ๋ ์ซ์ ๋ฆฌํฐ๋ด๊ฐ์ ์๋ฆฟ์ ๊ตฌ๋ถ์ ์ํ ๊ตฌ๋ถ์๋ก์จ ์ฌ์ฉํ ๋ ์ฌ๊ธฐ์ for _ in range(n) ์ 2๋ฒ์งธ ๊ฒฝ์ฐ์ธ ๊ฐ์ ๋ฌด์ํ๊ณ ์ถ์ ๋ ์ฐ์ธ ๊ฒฝ์ฐ์ด๋ค. ์ธ๋ฑ์ค๊ฐ ํ์ํ์ง ์์ ๋ ๊ฐ๋จํ ์ฐ์ธ๋ค. ์ต์ด ๋ฐํ ๋ ์ง: 2020-03-23 21:57:00
๋ฌธ์ ์๋์ ๋น๋ฐ๋ฒํธ๊ฐ ์๊ฐ์ด ๋์ง ์๋๋ค. ๋น๋ฐ๋ฒํธ P๋ 000๋ถํฐ 999๊น์ง ๋ฒํธ ์ค์ ํ๋์ด๋ค. ์ฃผ์ด์ง๋ ๋ฒํธ K๋ถํฐ 1์ฉ ์ฆ๊ฐํ๋ฉฐ ๋น๋ฐ๋ฒํธ๋ฅผ ํ์ธํด ๋ณผ ์๊ฐ์ด๋ค. ์๋ฅผ ๋ค์ด ๋น๋ฐ๋ฒํธ P๊ฐ 123 ์ด๊ณ ์ฃผ์ด์ง๋ ๋ฒํธ K๊ฐ 100 ์ผ ๋, 100๋ถํฐ 123๊น์ง 24๋ฒ ํ์ธํ์ฌ ๋น๋ฐ๋ฒํธ๋ฅผ ๋ง์ถ ์ ์๋ค. P์ K๊ฐ ์ฃผ์ด์ง๋ฉด K๋ถํฐ ์์ํ์ฌ ๋ช ๋ฒ ๋ง์ P๋ฅผ ๋ง์ถ ์ ์๋์ง ์์๋ณด์. [์ ๋ ฅ] ์ ๋ ฅ์ผ๋ก P์ K๊ฐ ๋น ์นธ์ ์ฌ์ด๋ก ์ฃผ์ด์ง๋ค. [์ถ๋ ฅ] ๋ช ๋ฒ ๋ง์ ๋น๋ฐ๋ฒํธ๋ฅผ ๋ง์ถ ์ ์๋์ง ์ถ๋ ฅํ๋ค. ์ ๋ ฅ ์์ 123 100 ์ถ๋ ฅ ์์ 24 ํ์ด SW Expert Academy ๋ชจ์ ํ ์คํธ ๋ฐฉ์์ ์ต์ํด์ง๋ ค๊ณ ํ์ด๋ดค๋ค. ํ์ด 1 P, K = map(int, input().split()) print(P - K..
๋ฌธ์ ์ด์ค ์ฐ์ ์์ ํ๋ ๋ค์ ์ฐ์ฐ์ ํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํฉ๋๋ค. ๋ช ๋ น์ด์์ ํ(๋์ด) I ์ซ์ ํ์ ์ฃผ์ด์ง ์ซ์๋ฅผ ์ฝ์ ํฉ๋๋ค. D 1 ํ์์ ์ต๋๊ฐ์ ์ญ์ ํฉ๋๋ค. D -1 ํ์์ ์ต์๊ฐ์ ์ญ์ ํฉ๋๋ค. ์ด์ค ์ฐ์ ์์ ํ๊ฐ ํ ์ฐ์ฐ operations๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฐ์ฐ์ ์ฒ๋ฆฌํ ํ ํ๊ฐ ๋น์ด์์ผ๋ฉด [0,0] ๋น์ด์์ง ์์ผ๋ฉด [์ต๋๊ฐ, ์ต์๊ฐ]์ return ํ๋๋ก solution ํจ์๋ฅผ ๊ตฌํํด์ฃผ์ธ์. ์ ํ์ฌํญ operations๋ ๊ธธ์ด๊ฐ 1 ์ด์ 1,000,000 ์ดํ์ธ ๋ฌธ์์ด ๋ฐฐ์ด์ ๋๋ค. operations์ ์์๋ ํ๊ฐ ์ํํ ์ฐ์ฐ์ ๋ํ๋ ๋๋ค. ์์๋ “๋ช ๋ น์ด ๋ฐ์ดํฐ” ํ์์ผ๋ก ์ฃผ์ด์ง๋๋ค.- ์ต๋๊ฐ/์ต์๊ฐ์ ์ญ์ ํ๋ ์ฐ์ฐ์์ ์ต๋๊ฐ/์ต์๊ฐ์ด ๋ ์ด์์ธ ๊ฒฝ์ฐ, ํ๋๋ง ์ญ์ ํฉ๋๋ค...