์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- ๋ชจ๋ฐ์ผ์ฑํ๋ก๊ทธ๋๋ฐ
- ๊ทธ๋ฆฌ๋์๊ณ ๋ฆฌ์ฆ
- ๋ฆฌ์กํธ๋ค์ดํฐ๋ธ
- ํ๋ก๊ทธ๋๋ฐ
- ์ปดํจํฐ๊ณตํ
- ์๋ฃ๊ตฌ์กฐ
- ์ฝ๋ฉ
- spring
- ํ์ด์ฌ
- ๋ฐฑ์คํ์ด
- ์ปด๊ณต
- ๋ฐฑ์ค
- ์๊ณ ๋ฆฌ์ฆ
- ์น๊ฐ๋ฐ
- ์คํ๋ง
- ์ฝ๋ฉํ ์คํธ
- ChatGPT
- ํ๋ก ํธ์ค๋
- ์ดํญ๊ณ์
- boj11653
- ๋ฆฌ์กํธ
- ๊ทธ๋ฆฌ๋
- ์ปด๊ณต์
- ๋จ์ํ ์คํธ
- ๋ฐฑ์๋
- ๋ฐฑ์ค1436
- ์ฐ์ ์์ํ
- ์น๊ฐ๋ฐ๊ธฐ๋ก
- SSE
- ๊ฐ๋ฐ์
- Today
- Total
๋ชฉ๋ก๋ถ๋ฅ ์ ์ฒด๋ณด๊ธฐ (72)
๐ป๐ญ๐ง๐
๋ฌธ์ https://www.acmicpc.net/problem/1041 1041๋ฒ: ์ฃผ์ฌ์ ์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์ ์ฃผ์ฌ์์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์์ ๊ทธ๋ฆผ์์ A, B, C, D, E, F์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋ค. N์ 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๊ณ , ์ฐ์ฌ ์๋ ์ www.acmicpc.net ์ฝ๋ import sys N = int(sys.stdin.readline()) array = list(map(int, sys.stdin.readline().split())) one = min(array) two = 100 # 50 * 2 = ๋ ๋ฉด์ ์ต๋ ํฉ three = 150 # 50 * 3 = ์ธ ๋ฉด์ ์ต๋ ํฉ if N == 1: # N==1์ด๋ผ๋ฉด ์ด ์ฃผ์ฌ์ ์ซ์..
๋ฌธ์ https://www.acmicpc.net/problem/11000 11000๋ฒ: ๊ฐ์์ค ๋ฐฐ์ ์ฒซ ๋ฒ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 200,000) ์ดํ N๊ฐ์ ์ค์ Si, Ti๊ฐ ์ฃผ์ด์ง๋ค. (0 ≤ Si < Ti ≤ 109) www.acmicpc.net ์ฝ๋ import sys import heapq n = int(sys.stdin.readline()) array = [] for i in range(n): array.append(list(map(int, sys.stdin.readline().split()))) array.sort() room = [] heapq.heappush(room,array[0][1]) for i in range(1,n): if array[i][0] < room[0]..
์ฐ์ ์์ ํ๋? ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ์ญ์ ํ๋ ์๋ฃ๊ตฌ์กฐ ์ฐ์ ์์ ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐ์ ์์์ ๋ฐ๋ผ ์ฒ๋ฆฌํ๊ณ ์ถ์ ๋ ์ฌ์ฉํจ. ๊ตฌํ ํ๋ ๋ฐฉ๋ฒ 1) ๋จ์ํ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํ 2) ํ(heap)์ ์ด์ฉํ์ฌ ๊ตฌํ ์ฐ์ ์์ ํ ๊ตฌํ ๋ฐฉ์ ์ฝ์ ์๊ฐ ์ญ์ ์๊ฐ ๋ฆฌ์คํธ O(1) O(N) ํ(Heap) O(logN) O(logN) ๋จ์ํ N๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ์ ๋ฃ์๋ค๊ฐ ๋ชจ๋ ๊บผ๋ด๋ ์์ ์ ์ ๋ ฌ๊ณผ ๋์ผํ๋ค. ์ด ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋๋ O(NlogN) ํ(Heap)์ ํน์ง ํ์ ์์ ์ด์ง ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ์ ์ผ์ข ์ด๋ค. ํ์์๋ ํญ์ ๋ฃจํธ ๋ ธ๋(root node)๋ฅผ ์ ๊ฑฐํ๋ค. ์ต์ ํ(min heap) ๋ฃจํธ ๋ ธ๋๊ฐ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ฐ์ง๋ค ๋ฐ๋ผ์ ๊ฐ์ด ์์ ๋ฐ์ดํฐ๊ฐ ์ฐ์ ์ ์ผ๋ก ์ ๊ฑฐ๋๋ค. ์ต๋ ํ(max he..
๋ฌธ์ https://www.acmicpc.net/problem/1461 1461๋ฒ: ๋์๊ด ์ธ์ค์ด๋ ๋์๊ด์์ ์ผํ๋ค. ๋์๊ด์ ๊ฐ๋ฐฉ์๊ฐ์ด ๋๋์ ์ธ์ค์ด๋ ์ฌ๋๋ค์ด ๋ง๊ตฌ ๋์ ์ฑ ์ ๋ค์ ๊ฐ์ ธ๋ค ๋์์ผ ํ๋ค. ์ธ์ค์ด๋ ํ์ฌ 0์ ์๊ณ , ์ฌ๋๋ค์ด ๋ง๊ตฌ ๋์ ์ฑ ๋ ์ ๋ถ 0์ ์๋ค. ๊ฐ ์ฑ www.acmicpc.net ์ฝ๋ ํ์ด์ ๋ ผ๋ฆฌ๋ ๋ง์ผ๋ ํ๋ฆฐ ์ฝ๋์ด๋ค. ํ๋ฆฐ ์ด์ ์ ์ ๋ต ์ฝ๋๋ ๊ฐ์ฅ ์๋์์ ! import sys from collections import deque n, k = map(int,sys.stdin.readline().split()) init = list(map(int,sys.stdin.readline().split())) init.sort() array = deque(init) count ..
๋ฌธ์ https://www.acmicpc.net/problem/9251 9251๋ฒ: LCS LCS(Longest Common Subsequence, ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด)๋ฌธ์ ๋ ๋ ์์ด์ด ์ฃผ์ด์ก์ ๋, ๋ชจ๋์ ๋ถ๋ถ ์์ด์ด ๋๋ ์์ด ์ค ๊ฐ์ฅ ๊ธด ๊ฒ์ ์ฐพ๋ ๋ฌธ์ ์ด๋ค. ์๋ฅผ ๋ค์ด, ACAYKP์ CAPCAK์ LCS๋ ACAK๊ฐ ๋๋ค. www.acmicpc.net ์ฝ๋ st1 = list(input()) st2 = list(input()) if len(st1)
๋ฌธ์ https://www.acmicpc.net/problem/2631 2631๋ฒ: ์ค์ธ์ฐ๊ธฐ KOI ์ด๋ฆฐ์ด์ง์๋ N๋ช ์ ์์ด๋ค์ด ์๋ค. ์ค๋์ ์ํ์ ๊ฐ๋ ๋ ์ด๋ค. ์ ์๋์ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ์ ํ์๋ ๋ฒํธํ๋ฅผ ์์ด๋ค์ ๊ฐ์ด์ ๋ถ์ฌ์ฃผ์๋ค. ์ ์๋์ ์์ด๋ค์ ํจ๊ณผ์ ์ผ๋ก ๋ณดํธํ๊ธฐ www.acmicpc.net ์ฝ๋ n = int(input()) array = [0] * n dp = [1] * n for i in range(n): array[i] = int(input()) for i in range(1,n): for j in range(0,i): if array[j] < array[i]: dp[i] = max(dp[i],dp[j]+1) print(n-max(dp)) ํ์ด ๋ฒํธ ์์๋๋ก ์ค์ ์ธ์ฐ๊ธฐ ์ํด ์ฎ..
๋ฌธ์ https://www.acmicpc.net/problem/11053 11053๋ฒ: ๊ฐ์ฅ ๊ธด ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด ์์ด A๊ฐ ์ฃผ์ด์ก์ ๋, ๊ฐ์ฅ ๊ธด ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์๋ฅผ ๋ค์ด, ์์ด A = {10, 20, 10, 30, 20, 50} ์ธ ๊ฒฝ์ฐ์ ๊ฐ์ฅ ๊ธด ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด์ A = {10, 20, 10, 30, 20, 50} ์ด www.acmicpc.net ์ฝ๋ a = int(input()) dp = [1] * a array = list(map(int, input().split())) for i in range(1,a): for j in range(0,i): if array[j] < array[i]: dp[i] = max(dp[i], dp[j]+1) print(max..
๋ฌธ์ 45656์ด๋ ์๋ฅผ ๋ณด์. ์ด ์๋ ์ธ์ ํ ๋ชจ๋ ์๋ฆฌ์ ์ฐจ์ด๊ฐ 1์ด๋ค. ์ด๋ฐ ์๋ฅผ ๊ณ๋จ ์๋ผ๊ณ ํ๋ค. N์ด ์ฃผ์ด์ง ๋, ๊ธธ์ด๊ฐ N์ธ ๊ณ๋จ ์๊ฐ ์ด ๋ช ๊ฐ ์๋์ง ๊ตฌํด๋ณด์. 0์ผ๋ก ์์ํ๋ ์๋ ๊ณ๋จ์๊ฐ ์๋๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. N์ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ ๋ต์ 1,000,000,000์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅํ๋ค. ํ์ด dp[์๋ฆฟ์][์์ ์ค๋ ์ซ์] = ๊ฒฝ์ฐ์ ์ ์๋ฆฟ์๊ฐ 1์ผ ๋์๋ ์์ ์ค๋ ์ซ์๊ฐ 1์์ 9์ธ ๊ฒฝ์ฐ๋ ํ๋๋ฟ์ด๋ฏ๋ก for๋ฌธ์ ์ด์ฉํด 1์ ๋ฃ์ด์ค๋ค. (์๋ฆฌ์๊ฐ 1์ผ ๋ ์์ ์ค๋ ์ซ์๊ฐ 0์ธ ๊ฒฝ์ฐ๋ ์์ผ๋ฏ๋ก ๊ทธ๋๋ก 0์ผ๋ก ๋๋ค.) ์์ ์ค๋ ์ซ์๊ฐ 0 ์ธ ๊ฒฝ์ฐ์๋ ๊ทธ ๋ค์ 1๋ง ์ฌ ์ ์๊ณ , ์์ ์ค๋ ์ซ์๊ฐ 9์ธ..

๋ฌธ์ RGB๊ฑฐ๋ฆฌ์๋ ์ง์ด N๊ฐ ์๋ค. ๊ฑฐ๋ฆฌ๋ ์ ๋ถ์ผ๋ก ๋ํ๋ผ ์ ์๊ณ , 1๋ฒ ์ง๋ถํฐ N๋ฒ ์ง์ด ์์๋๋ก ์๋ค. ์ง์ ๋นจ๊ฐ, ์ด๋ก, ํ๋ ์ค ํ๋์ ์์ผ๋ก ์น ํด์ผ ํ๋ค. ๊ฐ๊ฐ์ ์ง์ ๋นจ๊ฐ, ์ด๋ก, ํ๋์ผ๋ก ์น ํ๋ ๋น์ฉ์ด ์ฃผ์ด์ก์ ๋, ์๋ ๊ท์น์ ๋ง์กฑํ๋ฉด์ ๋ชจ๋ ์ง์ ์น ํ๋ ๋น์ฉ์ ์ต์๊ฐ์ ๊ตฌํด๋ณด์. 1๋ฒ ์ง์ ์์ 2๋ฒ ์ง์ ์๊ณผ ๊ฐ์ง ์์์ผ ํ๋ค. N๋ฒ ์ง์ ์์ N-1๋ฒ ์ง์ ์๊ณผ ๊ฐ์ง ์์์ผ ํ๋ค. i(2 ≤ i ≤ N-1)๋ฒ ์ง์ ์์ i-1๋ฒ, i+1๋ฒ ์ง์ ์๊ณผ ๊ฐ์ง ์์์ผ ํ๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์ง์ ์ N(2 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๊ฐ ์ง์ ๋นจ๊ฐ, ์ด๋ก, ํ๋์ผ๋ก ์น ํ๋ ๋น์ฉ์ด 1๋ฒ ์ง๋ถํฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ง์ ์น ํ๋ ๋น์ฉ์ 1,000๋ณด๋ค ..
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ ํ ์ฌ์ฉํ์ฌ ์ํ ์๊ฐ ํจ์จ์ฑ์ ๋น์ฝ์ ์ผ๋ก ํฅ์์ํค๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด๋ฏธ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ(์์ ๋ฌธ์ )๋ ๋ณ๋์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฅํ์ฌ ๋ค์ ๊ณ์ฐํ์ง ์๋๋ก ํ๋ค. ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ตฌํ์ ์ผ๋ฐ์ ์ผ๋ก ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ๊ตฌ์ฑ๋๋ค. Top-down (ํํฅ์) Botton-up (์ํฅ์) ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๋์ ๊ณํ๋ฒ์ด๋ผ๊ณ ๋ ๋ถ๋ฆฐ๋ค. ์ผ๋ฐ์ ์ธ ํ๋ก๊ทธ๋๋ฐ ๋ถ์ผ์์์ ๋์ (Dynamic) ์๋ฏธ์ ์ฐจ์ด์ ์๋ฃ๊ตฌ์กฐ์์ ๋์ ํ ๋น(Dynamic Allocation)์ 'ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๋์ค์ ์คํ์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ ๊ธฐ๋ฒ' ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์์ '๋ค์ด๋๋ฏน'์ ๋ณ๋ค๋ฅธ ์๋ฏธ๊ฐ ์์ - ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ (Optimal Substructure) : ํฐ ๋ฌธ์ ๋ฅผ ์..