Programming/Algorithm
ํ๋ก๊ทธ๋๋จธ์ค: ์ง์ฌ๊ฐํ ๋ณ์ฐ๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค: ์ง์ฌ๊ฐํ ๋ณ์ฐ๊ธฐ
2020.06.18์ฝ๋ฉํ
์คํธ ์ฐ์ต - ์ง์ฌ๊ฐํ ๋ณ์ฐ๊ธฐ ์ด ๋ฌธ์ ์๋ ํ์ค ์
๋ ฅ์ผ๋ก ๋ ๊ฐ์ ์ ์ n๊ณผ m์ด ์ฃผ์ด์ง๋๋ค. ๋ณ(*) ๋ฌธ์๋ฅผ ์ด์ฉํด ๊ฐ๋ก์ ๊ธธ์ด๊ฐ n, ์ธ๋ก์ ๊ธธ์ด๊ฐ m์ธ ์ง์ฌ๊ฐํ ํํ๋ฅผ ์ถ๋ ฅํด๋ณด์ธ์. ์ ํ ์กฐ๊ฑด n๊ณผ m์ ๊ฐ๊ฐ 1000 ์ดํ์ธ ์์ฐ์๏ฟฝ programmers.co.kr ๊ธฐ๋ณธ์ผ๋ก ์ฃผ์ด์ง๋ ์ฝ๋ a, b = map(int, input().strip().split(' ')) print(a + b) ๋ด๊ฐ ์์ฑํ ์ฝ๋ a, b = map(int, input().strip().split(' ')) for i in range(b): for j in range(a): print('*', end='') print() ์
๋ ฅ๋ ๋ ์ a, b ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ *๋ก ์ฑ์์ ์ถ๋ ฅํ๋ฉด ๋๋ค.
ํ๋ก๊ทธ๋๋จธ์ค: K๋ฒ์งธ ์
ํ๋ก๊ทธ๋๋จธ์ค: K๋ฒ์งธ ์
2020.04.20https://programmers.co.kr/learn/courses/30/lessons/4274 2019๋
์ด ํ์ด ๋๋ณด๊ธฐ ๋ด๊ฐ ํผ ๋ฐฉ๋ฒ์ด ํจ์จ์ ์ด๋ผ๊ณ ํ ์๋ ์๊ฒ ์ง๋ง, ์ด๋ ๊ฒ ํธ๋ ์ฌ๋๋ ์๋ค ์ ๋๋ก ์ฐธ๊ณ ๋ง ํ๋ฉด ์ข๊ฒ ๋ค. ๋๋ ์ฐ์ฐ(๋ฐฐ์ด์ ์๋ฅธ ํ ์ ๋ ฌ, n๋ฒ์งธ ์ ์ฐพ๊ธฐ)์ ์ํด์ ArrayList๋ฅผ ์ฌ์ฉํ๋ค. ์ด ๋ ArrayList ๋์ Vector ํน์ ์ผ๋ฐ ๋ฐฐ์ด์ ์ฌ์ฉํด๋ ์๊ด์๋ค. import java.util.ArrayList; import java.util.Collections; class Solution { public int[] solution(int[] array, int[][] commands) { int[] answer = new int[commands.length]; Arr..
์๋ฃ๊ตฌ์กฐ: ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ(Recursive Algorithms) ๊ธฐ์ด, ์์ฉ
์๋ฃ๊ตฌ์กฐ: ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ(Recursive Algorithms) ๊ธฐ์ด, ์์ฉ
2020.04.20์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ(Recursive algorithms) - ๊ธฐ์ด ์ฌ๊ท ํจ์๋? ํ๋์ ํจ์์์ ์์ ์ ๋ค์ ํธ์ถํ์ฌ ์์
์ ์ํ ๋ง์ ์ข
๋ฅ์ ๋ฌธ์ ๊ฐ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐ ๊ฐ๋ฅ ์ด์ง ํธ๋ฆฌ(Binary trees) ์์ฐ์์ ํฉ ๊ตฌํ๊ธฐ ์ข
๊ฒฐ ์กฐ๊ฑด(trivial case)์ด ๋งค์ฐ ์ค์ํจ ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ํจ์จ ์๊ณ ๋ฆฌ์ฆ์ ๋ณต์ก๋ ์ธก๋ฉด๊ณผ ํจ์จ์ฑ ์ธก๋ฉด ํผ๋ณด๋์น ์์ด ํผ๋ณด๋์น ์์ด ์ฌ๊ท์ ๋ฐฉ๋ฒ def fibonacci(x): if x == 0: return 0 elif x == 1: return 1 else: return fibonacci(x-1) + fibonacci(x-2) ๋ฌธ์ ์ค๋ช
์์ ํผ๋ณด๋์น ์์ด์ ๋ํ ์ ์๊ฐ ์ฃผ์ด์ก๊ณ , ์ฌ๋ฌ ๋ฒ ์์ฑํด๋ณธ ์ ์ด ์๋ ์ฝ๋๋ผ์ ์์ฑํ๋ ๋ฐ ํฐ ์ด๋ ค์์ ๋๋ผ์ง ์์๋ค. ๊ทธ๋๋ ์ฌ๋ฌ ๋ฒ์ ..
BOJ: ๋จ์ด ๋ค์ง๊ธฐ - 9093๋ฒ
BOJ: ๋จ์ด ๋ค์ง๊ธฐ - 9093๋ฒ
2020.03.049093๋ฒ: ๋จ์ด ๋ค์ง๊ธฐ ๋ฌธ์ ๋ฌธ์ฅ์ด ์ฃผ์ด์ก์ ๋, ๋จ์ด๋ฅผ ๋ชจ๋ ๋ค์ง์ด์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋จ, ๋จ์ด์ ์์๋ ๋ฐ๊ฟ ์ ์๋ค. ๋จ์ด๋ ์์ด ์ํ๋ฒณ์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ค. ์
๋ ฅ ์ฒซ์งธ ์ค์ ํ
์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ
์คํธ ์ผ์ด์ค๋ ํ ์ค๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๋ฌธ์ฅ์ด ํ๋ ์ฃผ์ด์ง๋ค. ๋จ์ด์ ๊ธธ์ด๋ ์ต๋ 20, ๋ฌธ์ฅ์ ๊ธธ์ด๋ ์ต๋ 1000์ด๋ค. ๋จ์ด์ ๋จ์ด ์ฌ์ด์๋ ๊ณต๋ฐฑ์ด ํ๋ ์๋ค. ์ถ๋ ฅ ๊ฐ ํ
์คํธ ์ผ์ด์ค์ ๋ํด์, ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ฌธ์ฅ์ ๋จ์ด๋ฅผ ๋ชจ๋ ๋ค์ง์ด www.acmicpc.net import sys T = int(sys.stdin.readline()) for i in range(T): text = list(sys.stdin.readline().strip().split(' ')..
BOJ: ์คํ - 10828๋ฒ
BOJ: ์คํ - 10828๋ฒ
2020.03.04์ด ๊ธ์ ๋ณดํธ๋์ด ์๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ ๋ณด๋ ค๋ฉด ์ํธ๊ฐ ํ์ํฉ๋๋ค.
์๋ฃ๊ตฌ์กฐ: ํธ๋ฆฌ(Tree)
์๋ฃ๊ตฌ์กฐ: ํธ๋ฆฌ(Tree)
2020.02.05ํธ๋ฆฌ Tree ์ ์ node๊ณผ ๊ฐ์ edge๋ฅผ ์ด์ฉํ์ฌ ๋ฐ์ดํฐ์ ๋ฐฐ์น ํํ๋ฅผ ์ถ์ํํ ์๋ฃ๊ตฌ์กฐ 1:n ๊ด๊ณ์ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ ๊ณ์ธต ๊ด๊ณ๋ก ๋ง๋ค์ด์ง ๊ณ์ธตํ ์๋ฃ๊ตฌ์กฐ root node ํธ๋ฆฌ์์ ์ต์์ ๋
ธ๋ leaf node ์์ ๋
ธ๋๊ฐ ์๋ ๋
ธ๋ internal node leaf node๊ฐ ์๋ ๋
ธ๋ parent node ๋
ธ๋ A๊ฐ ๋
ธ๋ B๋ฅผ ๊ฐ๋ฆฌํฌ ๋ A๋ฅผ B์ ๋ถ๋ชจ ๋
ธ๋๋ผ๊ณ ํจ ^์ฐธ์กฐ child node B๋ฅผ A์ ์์ ๋
ธ๋๋ผ๊ณ ํจ ^์ฐธ์กฐ sibling ๋์ผํ ๋ถ๋ชจ๋ฅผ ๊ฐ๋ ํ์ ๋
ธ๋ ancestor ๋ถ๋ชจ์ ๋ถ๋ชจ(...์ ๋ถ๋ชจ์) ๋
ธ๋ descendant ์์์ ์์(...์ ์์์) ๋
ธ๋ ๋
ธ๋์ ์์ค Level root node๋ level 0 root node๋ก ๋ถํฐ ํด๋น ๋
ธ๋๊น์ง ๊ฑฐ์น๋ ๊ฐ์ ์ ๊ฐฏ์ ํธ๋ฆฌ..
BOJ: #10951
BOJ: #10951
2020.02.04#10951 #10950 ๊ณผ ๋ฌ๋ฆฌ ํ
์คํธ ์ผ์ด์ค ๊ฐ์๋ฅผ ์ฃผ์ง ์์์ ๋ฌธ์ ํธ๋๋ฐ ํค๋ฉจ๋ค. ์ฒ์์๋ while(true)๋ฅผ ์ฃผ์ด์ ๋ฐํ์ ์๋ฌ๊ฐ ๋ด์๋ค. ๊ทธ๋์ ํ
์คํธ ์ผ์ด์ค๋ฅผ 100๊ฐ ์ฃผ๊ณ ๋๋ฆฌ๋ฉด ๋์ง ์์๊น? ํ์ง๋ง ๊ฒฐ๊ณผ๋ ์คํจ…. ์ฝ์ง์ฝ๋ 1 import java.util.Scanner; public class Main { public static void main(String args[]) { int a, b; Scanner in = new Scanner(System.in); while (true) { a = in.nextInt(); b = in.nextInt(); System.out.println(a + b); } } } ์ฝ์ง์ฝ๋ 2 import java.util.*; public class Ma..