๐ Algorithm (61) ์ธ๋ค์ผํ ๋ฆฌ์คํธํ Baekjoon ๋ฐฑ์ค 1100 ํ์ ์นธ ๋ฌธ์ ํ์ด 1100 ๋ฌธ์ ์ฒด์คํ์ 8×8ํฌ๊ธฐ์ด๊ณ , ๊ฒ์ ์นธ๊ณผ ํ์ ์นธ์ด ๋ฒ๊ฐ์๊ฐ๋ฉด์ ์์น ๋์ด ์๋ค. ๊ฐ์ฅ ์ผ์ชฝ ์์นธ (0,0)์ ํ์์์ด๋ค. ์ฒด์คํ์ ์ํ๊ฐ ์ฃผ์ด์ก์ ๋, ํ์ ์นธ ์์ ๋ง์ด ๋ช ๊ฐ ์๋์ง ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ 8๊ฐ์ ์ค์ ์ฒด์คํ์ ์ํ๊ฐ ์ฃผ์ด์ง๋ค. ‘.’์ ๋น ์นธ์ด๊ณ , ‘F’๋ ์์ ๋ง์ด ์๋ ์นธ์ด๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ๋ฌธ์ ์ ์ ๋ต์ ์ถ๋ ฅํ๋ค. ํ์ด chess = [input() for _ in range(8)] cnt = 0 for y in range(8): for x in range(8): if y%2 == x%2 and chess[y][x] == 'F': cnt += 1 print(cnt) Baekjoon ๋ฐฑ์ค 1037 ์ฝ์ ๋ฌธ์ ํ์ด 1037 ๋ฌธ์ ์์ A๊ฐ N์ ์ง์ง ์ฝ์๊ฐ ๋๋ ค๋ฉด, N์ด A์ ๋ฐฐ์์ด๊ณ , A๊ฐ 1๊ณผ N์ด ์๋์ด์ผ ํ๋ค. ์ด๋ค ์ N์ ์ง์ง ์ฝ์๊ฐ ๋ชจ๋ ์ฃผ์ด์ง ๋, N์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ N์ ์ง์ง ์ฝ์์ ๊ฐ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ๊ฐ์๋ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค์๋ N์ ์ง์ง ์ฝ์๊ฐ ์ฃผ์ด์ง๋ค. 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๊ณ , 2๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๊ณ , ์ค๋ณต๋์ง ์๋๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ N์ ์ถ๋ ฅํ๋ค. N์ ํญ์ 32๋นํธ ๋ถํธ์๋ ์ ์๋ก ํํํ ์ ์๋ค. ํ์ด N = int(input()) A_list = [] A_list = list(map(int, input().split())) if N == 1 : res = A_list[0] * A_list[0] else : A.. Baekjoon ๋ฐฑ์ค 1225 ์ด์ํ ๊ณฑ์ ๋ฌธ์ ํ์ด 1225 ๋ฌธ์ A×B๋ฅผ ๊ณ์ฐํ๋ค ์ง๊ฒจ์์ง ํํ์ด๋ A×B๋ฅผ ์๋ก์ด ๋ฐฉ๋ฒ์ผ๋ก ์ ์ํ๋ ค๊ณ ํ๋ค. A์์ ํ ์๋ฆฌ๋ฅผ ๋ฝ๊ณ × B์์ ์์๋ก ํ ์๋ฆฌ๋ฅผ ๋ฝ์ ๊ณฑํ๋ค. ์ ๊ฐ๋ฅํ ๋ชจ๋ ์กฐํฉ (A๊ฐ n์๋ฆฌ, B๊ฐ m์๋ฆฌ ์๋ผ๋ฉด ์ด ๊ฐ๋ฅํ ์กฐํฉ์ n×m๊ฐ)์ ๋ํ ์๋ก ์ ์ํ๋ ค๊ณ ํ๋ค. ์๋ฅผ ๋ค์ด 121×34๋ 1×3 + 1×4 + 2×3 + 2×4 + 1×3 + 1×4 = 28 ์ด ๋๋ค. ์ด๋ฌํ ํํ์ด์ ๊ณฑ์ ๊ฒฐ๊ณผ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ๋ ์๋ ๋ชจ๋ 10,000์๋ฆฌ๋ฅผ ๋์ง ์๋ ์์ด ์๋ ์ ์์ด๋ค. ์๊ฐ 0์ธ ๊ฒฝ์ฐ์๋ 0๋ง ์ฃผ์ด์ง๋ฉฐ, ๊ทธ ์ธ์ ๊ฒฝ์ฐ ์๋ 0์ผ๋ก ์์ํ์ง ์๋๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ํํ์ด์ ๊ณฑ์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค. ํ์ด n1, n2 = map(in.. Baekjoon ๋ฐฑ์ค 1181 ๋จ์ด ์ ๋ ฌ ๋ฌธ์ ํ์ด 1181 ๋ฌธ์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง N๊ฐ์ ๋จ์ด๊ฐ ๋ค์ด์ค๋ฉด ์๋์ ๊ฐ์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 1. ๊ธธ์ด๊ฐ ์งง์ ๊ฒ๋ถํฐ 2. ๊ธธ์ด๊ฐ ๊ฐ์ผ๋ฉด ์ฌ์ ์์ผ๋ก ๋จ, ์ค๋ณต๋ ๋จ์ด๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๊ฑฐํด์ผ ํ๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ๋จ์ด์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 20,000) ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฑธ์ณ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋จ์ด๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ 50์ ๋์ง ์๋๋ค. ์ถ๋ ฅ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ ๋ ฌํ์ฌ ๋จ์ด๋ค์ ์ถ๋ ฅํ๋ค. ํ์ด N = int(input()) word_list = [] for i in range(N) : word_list.append(input()) set_word_list = set(word_list) word_list = lis.. [Baekjoon] ๋ฐฑ์ค 1010 '๋ค๋ฆฌ๋๊ธฐ' ๋ฌธ์ ํ์ด C์ธ์ด, ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด 1010 ๋ฌธ์ ์ฌ์์ด๋ ํ ๋์์ ์์ฅ์ด ๋์๋ค. ์ด ๋์์๋ ๋์๋ฅผ ๋์ชฝ๊ณผ ์์ชฝ์ผ๋ก ๋๋๋ ํฐ ์ผ์ง์ ๋ชจ์์ ๊ฐ์ด ํ๋ฅด๊ณ ์๋ค. ํ์ง๋ง ์ฌ์์ด๋ ๋ค๋ฆฌ๊ฐ ์์ด์ ์๋ฏผ๋ค์ด ๊ฐ์ ๊ฑด๋๋๋ฐ ํฐ ๋ถํธ์ ๊ฒช๊ณ ์์์ ์๊ณ ๋ค๋ฆฌ๋ฅผ ์ง๊ธฐ๋ก ๊ฒฐ์ฌํ์๋ค. ๊ฐ ์ฃผ๋ณ์์ ๋ค๋ฆฌ๋ฅผ ์ง๊ธฐ์ ์ ํฉํ ๊ณณ์ ์ฌ์ดํธ๋ผ๊ณ ํ๋ค. ์ฌ์์ด๋ ๊ฐ ์ฃผ๋ณ์ ๋ฉด๋ฐํ ์กฐ์ฌํด ๋ณธ ๊ฒฐ๊ณผ ๊ฐ์ ์์ชฝ์๋ N๊ฐ์ ์ฌ์ดํธ๊ฐ ์๊ณ ๋์ชฝ์๋ M๊ฐ์ ์ฌ์ดํธ๊ฐ ์๋ค๋ ๊ฒ์ ์์๋ค. (N ≤ M) ์ฌ์์ด๋ ์์ชฝ์ ์ฌ์ดํธ์ ๋์ชฝ์ ์ฌ์ดํธ๋ฅผ ๋ค๋ฆฌ๋ก ์ฐ๊ฒฐํ๋ ค๊ณ ํ๋ค. (์ด๋ ํ ์ฌ์ดํธ์๋ ์ต๋ ํ ๊ฐ์ ๋ค๋ฆฌ๋ง ์ฐ๊ฒฐ๋ ์ ์๋ค.) ์ฌ์์ด๋ ๋ค๋ฆฌ๋ฅผ ์ต๋ํ ๋ง์ด ์ง์ผ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ ์์ชฝ์ ์ฌ์ดํธ ๊ฐ์๋งํผ (N๊ฐ) ๋ค๋ฆฌ๋ฅผ ์ง์ผ๋ ค๊ณ ํ๋ค. ๋ค๋ฆฌ๋ผ๋ฆฌ๋ ์๋ก ๊ฒน์ณ์ง ์ ์๋ค๊ณ ํ ๋ .. Dynamic Programming(DP) ์๊ณ ๋ฆฌ์ฆ - ๋์ ํ๋ก๊ทธ๋๋ฐ, Python์ผ๋ก ํธ๋ ํผ๋ณด๋์น Dynamic Programming ํฐ ๋ฌธ์ ๋ฅผ ๋๋์ด ์์ ๋ฌธ์ ๋ก ํธ๋ ๊ฒ ํ๋์ ๋ฌธ์ ๋ ๋จ ํ ๋ฒ์ ํ์ด๋ง ํ๋ค. Dynamic Programming ๊ณผ Recursion(์ฌ๊ท)์ ์ฐจ์ด์ DP์ ์ฌ๊ท๋ ์ผํ๋ณด๋ฉด '๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ผ์ด๋๋ ์ ' ์์ ๋น์ทํ๋ค๊ณ ์๊ฐํ ์ ์๋ค. ํ์ง๋ง, ํฐ ์ฐจ์ด์ ์ ์ผ๋ฐ์ ์ธ ์ฌ๊ท๋ฅผ ๋จ์ํ ์ฌ์ฉํ๋ฉด ๋์ผํ ์์ ๋ฌธ์ ๋ค์ด ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณต ๋์ด ๋นํจ์จ์ ์ธ ๊ณ์ฐ๋ ์ ์๋ค๋ ๊ฒ์ด๋ค. ๊ฐ์ฅ ๋ํ์ ์ธ ์์๋ ํผ๋ณด๋์น ํจ์์ด๋ค. DP ์กฐ๊ฑด ๋ ๊ฐ์ง ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋ค. 1. ๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ๋ฐ์ 2. ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ ๋์ผํ ์์ ๋ฌธ์ ๋ค์ด ๋ฐ๋ณต์ ์ผ๋ก ์ผ์ด๋ ๋, ๊ฐ์ ๋ฌธ์ ๋ ํญ์ ์ ๋ต๋ ๊ฐ๋ค. ์ฆ, ์ค๋ณต ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค. DP ๋ฌธ์ ํ์ด ๋ฐฉ๋ฒ ๋ชจ๋ ์์ ๋ฌธ์ ๋ ํ ๋ฒ.. ์ด์ 1 ยทยทยท 6 7 8 9 10 11 ๋ค์