├── .github └── PULL_REQUEST_TEMPLATE.md ├── README.md └── src ├── Do-ho ├── README.md ├── bitmasking │ ├── boj_1094_막대기 │ │ └── boj_1094.py │ ├── boj_1194_달이차오른다 │ │ └── boj_1194.py │ ├── boj_14889_스타트와링크 │ │ └── boj_14889.py │ └── boj_18233_러버덕 │ │ └── boj_18233.py ├── dataStructor │ ├── boj_11286 │ │ ├── README.md │ │ ├── boj.11286_3.py │ │ ├── boj_11286.py │ │ └── boj_11286_2.py │ ├── boj_1158.py │ ├── boj_1406.py │ ├── boj_1991 │ │ ├── README.md │ │ └── boj_1991.py │ ├── boj_2346.py │ └── pgs_위장 │ │ ├── README.md │ │ ├── pgs_위장.js │ │ └── pgs_위장.py ├── dfsbfs │ ├── boj_1260_DFS와BFS │ │ ├── README.md │ │ └── boj_1260.py │ ├── boj_1697_숨바꼭질 │ │ ├── README.md │ │ └── boj_1697.py │ ├── boj_19238_스타트택시 │ │ ├── README.md │ │ └── boj_19238.py │ ├── boj_2178_미로탐색 │ │ ├── README.md │ │ └── boj_2178.py │ ├── boj_2606_바이러스 │ │ ├── README.md │ │ └── boj_2606.py │ ├── boj_2644_촌수계산 │ │ ├── README.md │ │ └── boj_2644.py │ ├── boj_7569_토마토 │ │ ├── README.md │ │ ├── boj_7569.py │ │ └── boj_7569_2.py │ └── pgs_네트워크 │ │ └── pgs_네트워크.js ├── divide_conquer │ ├── boj_1780_종이의개수 │ │ ├── README.md │ │ └── boj_1780.py │ ├── boj_1992_쿼드트리 │ │ └── boj_1992.py │ └── boj_2630_색종이만들기 │ │ └── boj_2630.py ├── dp │ ├── boj_1010_다리놓기 │ │ ├── README.md │ │ └── boj_1010.py │ ├── boj_1149_RGB거리 │ │ ├── README.md │ │ └── boj_1149.py │ ├── boj_11727_2n타일링2 │ │ ├── README.md │ │ └── boj_11727.py │ ├── boj_12865_평범한배낭 │ │ ├── README.md │ │ └── boj_12865.py │ ├── boj_1932_정수삼각형 │ │ ├── README.md │ │ └── boj_1932.py │ ├── boj_2011_암호코드 │ │ ├── README.md │ │ └── boj_2011.py │ ├── boj_2502_떡먹는호랑이 │ │ ├── README.md │ │ └── boj_2502.py │ ├── boj_2579_계단오르기 │ │ ├── README.md │ │ └── boj_2579.py │ └── boj_9096_123더하기 │ │ ├── README.md │ │ └── boj_9095.py ├── greedy │ ├── boj_11047_동전0 │ │ ├── README.md │ │ └── boj_11047.py │ ├── boj_11399_ATM │ │ ├── README.md │ │ └── boj_11399.py │ ├── boj_11497_통나무 │ │ └── boj_11497.py │ ├── boj_17609_회문 │ │ ├── README.md │ │ └── boj_17609.py │ └── boj_1946_신입사원 │ │ └── boj_1946.py ├── implementation │ ├── boj_1254_팰린드롬만들기 │ │ ├── README.md │ │ └── boj_1254.py │ ├── boj_12731_열차시간표small │ │ ├── README.md │ │ └── boj_12731.py │ ├── pgs_가장긴팰린드롬 │ │ └── pgs_palindrome.js │ ├── pgs_영어끝말잇기 │ │ └── pgs_영어끝말잇기.js │ ├── pgs_크레인인형뽑기 │ │ └── pgs_crane.js │ └── pgs_튜플 │ │ └── pgs_tuple.js ├── string │ ├── boj_1316 │ │ ├── README.md │ │ └── boj_1316.py │ └── pgs_문자열압축 │ │ ├── README.md │ │ └── source.py └── week1.md ├── do02reen24 ├── .gitignore ├── BFS │ ├── baekjoon_1697.cpp │ ├── baekjoon_2178.py │ ├── baekjoon_2606.py │ ├── baekjoon_2644.py │ ├── baekjoon_7569.py │ └── programmers_43162.js ├── README.md ├── Review │ ├── unsolved.md │ ├── week1.md │ ├── week10.md │ ├── week11.md │ ├── week12.md │ ├── week13.md │ ├── week14.md │ ├── week15.md │ ├── week2.md │ ├── week3.md │ ├── week4.md │ ├── week5.md │ ├── week6.md │ ├── week7.md │ ├── week8.md │ └── week9.md ├── bit-masking │ ├── baekjoon_1094.py │ ├── baekjoon_14889.cpp │ └── baekjoon_18233.cpp ├── brute-force │ ├── baekjoon_1254.py │ └── baekjoon_18233.py ├── data-structure │ ├── baekjoon_10799.py │ ├── baekjoon_11286.py │ ├── baekjoon_1158.py │ ├── baekjoon_1406.py │ ├── baekjoon_1874.py │ ├── baekjoon_1991.py │ ├── baekjoon_2346.py │ ├── baekjoon_2504.py │ ├── baekjoon_9012.py │ └── programmers_42578.py ├── divide-and-conquer │ ├── baekjoon_1780.py │ ├── baekjoon_1992.py │ └── baekjoon_2630.py ├── dynamic-programming │ ├── baekjoon_1010.py │ ├── baekjoon_1149.py │ ├── baekjoon_11727.py │ ├── baekjoon_1932.py │ ├── baekjoon_2011.py │ ├── baekjoon_2502.py │ ├── baekjoon_2579.py │ └── baekjoon_9059.py ├── etc │ ├── baekjoon_12731.py │ ├── programmers_12981.js │ └── programmers_42578.js ├── greedy │ ├── baekjoon_11047.py │ ├── baekjoon_11399.py │ ├── baekjoon_11497.py │ ├── baekjoon_17609.py │ └── baekjoon_1946.py ├── simulation │ └── programmers_64061.js ├── string │ ├── baekjoon_1316.py │ ├── programmers_12904.js │ ├── programmers_60057.py │ └── programmers_64065.js └── 실전연습 │ └── codility │ ├── 1_BinaryGap.js │ ├── 2_CyclicRotation.js │ ├── 2_OddOccurrencesInArray.js │ ├── 3_FrogJmp.js │ ├── 3_PermMissingElem.js │ ├── 3_TapeEquilibrium.js │ ├── 7_StoneWall.js │ └── score.md ├── grap3fruit ├── README.md ├── js │ ├── boj │ │ ├── input1_1.js │ │ ├── input1_2.js │ │ ├── test │ │ └── test2 │ ├── doublyLinkedList.js │ ├── goorm │ │ ├── input1.js │ │ ├── input1_1.js │ │ ├── input1_2.js │ │ ├── input1_3.js │ │ └── input2.js │ ├── input.md │ └── programmers │ │ ├── 12904.js │ │ ├── 12904.md │ │ ├── 12981.js │ │ ├── 12981.md │ │ ├── 42578.js │ │ ├── 42578.md │ │ ├── 42578_2.js │ │ ├── 43162.js │ │ ├── 43162.md │ │ ├── 64061.js │ │ ├── 64061.md │ │ ├── 64061_2.js │ │ ├── 64065.js │ │ └── 64065.md └── py │ ├── boj │ ├── 1010.md │ ├── 1010.py │ ├── 1094.md │ ├── 1094.py │ ├── 11047.md │ ├── 11047.py │ ├── 11286.py │ ├── 11399.md │ ├── 11399.py │ ├── 1149.md │ ├── 1149.py │ ├── 11497.md │ ├── 11497.py │ ├── 11727.md │ ├── 11727.py │ ├── 1254.md │ ├── 1254.py │ ├── 12731.md │ ├── 12731.py │ ├── 1316.py │ ├── 14889.md │ ├── 14889.py │ ├── 1697.md │ ├── 1697.py │ ├── 17609.md │ ├── 17609.py │ ├── 18233.md │ ├── 18233.py │ ├── 19238.py │ ├── 1932.md │ ├── 1932.py │ ├── 1946.md │ ├── 1946.py │ ├── 1991.py │ ├── 2011.md │ ├── 2011.py │ ├── 2178.md │ ├── 2178.py │ ├── 2502.md │ ├── 2502.py │ ├── 2579.md │ ├── 2579.py │ ├── 2606.md │ ├── 2606.py │ ├── 2644.md │ ├── 2644.py │ ├── 2957.py │ ├── 7569.md │ ├── 7569.py │ ├── 9095.md │ └── 9095.py │ ├── input_test.py │ └── programmers │ ├── 17685.py │ ├── 42578.py │ └── 60057.py └── kyu9341 ├── 1158 ├── Main.java └── README.md ├── 1406 ├── Main.java └── README.md ├── 1697 ├── Main.java └── README.md ├── 1991 ├── Main.java └── README.md ├── 2346 ├── Main.java └── README.md ├── 2606 ├── Main.java └── README.md ├── 2957 ├── Main.java └── README.md ├── 7569 ├── Main.java └── README.md ├── 11286 ├── Main.java └── README.md ├── README.md ├── boj1010_다리놓기 └── Main.java ├── boj11047_동전0 └── Main.java ├── boj11399_ATM └── 11399_ATM.cpp ├── boj11497_통나무건너뛰기 └── Main.java ├── boj1149_RGB거리 └── Main.java ├── boj1254_팰린드롬 └── Main.java ├── boj17609_회문 └── 17609_회문.cpp ├── boj1932_정수삼각형 └── Main.java ├── boj1946_신입사원 └── Main.java ├── boj2178_미로탐색 └── 2178_미로탐색.cpp ├── boj2502_떡먹는호랑이 └── 2502_떡먹는호랑이.cpp ├── boj2579_계단오르기 └── Main.java ├── boj2644_촌수계산 └── 2644_촌수계산.cpp ├── programmers_가장긴팰린드롬 └── index.js ├── programmers_네트워크 └── index.js ├── programmers_영어끝말잇기 └── index.js ├── programmers_위장 ├── Main.java ├── README.md └── index.js ├── programmers_크레인인형뽑기게임 └── index.js ├── programmers_튜플 └── index.js └── queue └── queue.js /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | ## 📚 문제 2 | - 문제 1 3 | - 문제 2 4 | - 문제 3 5 | - 문제 4 6 | 7 | ## 📋 하고 싶은 말 8 | - 하고 싶은 말 1 -------------------------------------------------------------------------------- /src/Do-ho/README.md: -------------------------------------------------------------------------------- 1 | # :fire: Week2 2 | 3 | [[절대값 힙](./dataStructor/boj_11286/README.md)] -------------------------------------------------------------------------------- /src/Do-ho/bitmasking/boj_1094_막대기/boj_1094.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | X = int(sys.stdin.readline()) 4 | 5 | count = 0 6 | while(X!=0): 7 | if X%2==1: count += 1 8 | X = X >> 1 9 | 10 | sys.stdout.write(str(count)) -------------------------------------------------------------------------------- /src/Do-ho/bitmasking/boj_1194_달이차오른다/boj_1194.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import copy 3 | from itertools import combinations 4 | from collections import deque 5 | 6 | [N, M] = list(map(int, sys.stdin.readline().split())) 7 | directions = [(-1, 0), (0, -1), (1, 0), (0, 1)] 8 | alphabet = { 9 | 'A': 0, 10 | 'B': 1, 11 | 'C': 2, 12 | 'D': 3, 13 | 'E': 4, 14 | 'F': 5 15 | } 16 | 17 | myMap = [] 18 | myCheck = [[[False for _ in range(64)] for _ in range(M)] for _ in range(N)] 19 | 20 | for _ in range(N): 21 | myMap.append(list(sys.stdin.readline()[:-1])) 22 | 23 | # 맵 중 민식이 위치 찾기 (민식이는 무조건 있다) 24 | def findMinsik(): 25 | for i in range(len(myMap)): 26 | for j in range(len(myMap[0])): 27 | if myMap[i][j]=='0': 28 | return (i, j, 0, 0) 29 | 30 | def findMoon(): 31 | queue = deque() 32 | queue.append(findMinsik()) 33 | myCheck[queue[0][0]][queue[0][1]][0] = True 34 | while queue: 35 | target = queue.popleft() 36 | for direction in directions: 37 | nr = target[0] + direction[0] 38 | nc = target[1] + direction[1] 39 | nk = copy.deepcopy(target[2]) 40 | 41 | if nr >= N or nr < 0 or nc >= M or nc < 0: continue 42 | if myMap[nr][nc] == '1': return target[3] + 1 43 | if myMap[nr][nc] == '#' or myCheck[nr][nc][nk]: continue 44 | if myMap[nr][nc].isupper(): 45 | if nk == 0 or (nk >> alphabet[myMap[nr][nc]]) % 2 != 1: continue 46 | if myMap[nr][nc].islower(): 47 | uA = myMap[nr][nc].upper() 48 | if nk == 0 or (nk >> alphabet[uA]) % 2 != 1: nk += pow(2,alphabet[uA]) 49 | 50 | myCheck[nr][nc][nk] = True 51 | queue.append((nr, nc, nk, target[3]+1)) 52 | return -1 53 | 54 | print(findMoon()) -------------------------------------------------------------------------------- /src/Do-ho/bitmasking/boj_14889_스타트와링크/boj_14889.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from itertools import combinations 3 | 4 | def getTeamStats(comb): 5 | startTeamStat = getStat(comb) 6 | 7 | linkTeam = [] 8 | for people in peoples: 9 | if people not in comb: 10 | linkTeam.append(people) 11 | 12 | linkTeamStat = getStat(linkTeam) 13 | 14 | return [startTeamStat, linkTeamStat] 15 | 16 | def getStat(peoples): 17 | result = 0 18 | for item1 in peoples: 19 | for item2 in peoples: 20 | if item1==item2: continue 21 | result += stats[item1][item2] 22 | 23 | return result 24 | 25 | N = int(sys.stdin.readline()) 26 | halfN = N//2 27 | stats = [] 28 | peoples = [i for i in range(N)] 29 | team_combinations = [] 30 | balanceStat = 10000 31 | 32 | for _ in range(N): 33 | stats.append(list(map(int, sys.stdin.readline().split()))) 34 | 35 | for team in list(combinations(peoples, halfN)): 36 | team_combinations.append(team) 37 | 38 | for comb in team_combinations: 39 | [startTeamStat, linkTeamStat] = getTeamStats(comb) 40 | if balanceStat > abs(startTeamStat - linkTeamStat): 41 | balanceStat = abs(startTeamStat - linkTeamStat) 42 | 43 | sys.stdout.write(str(balanceStat)) -------------------------------------------------------------------------------- /src/Do-ho/bitmasking/boj_18233_러버덕/boj_18233.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from itertools import combinations 3 | 4 | [N, P, E] = map(int, sys.stdin.readline().split()) 5 | 6 | peoples = [i for i in range(N)] 7 | 8 | combs = [] 9 | for comb in list(combinations(peoples, P)): 10 | combs.append(comb) 11 | 12 | peopleDolls = [] 13 | for _ in range(N): 14 | data = sys.stdin.readline().split() 15 | peopleDolls.append({'min': int(data[0]), 'max': int(data[1])}) 16 | 17 | def f(): 18 | global combs 19 | for comb in combs: 20 | result = [0 for _ in range(N)] 21 | total = 0 22 | for i in comb: 23 | total += peopleDolls[i]['min'] 24 | result[i] = peopleDolls[i]['min'] 25 | 26 | if total>E: continue 27 | elif total==E: return result 28 | 29 | # E-total은 남은 인형 개수 30 | for i in comb: 31 | remainTotalDoll = E - total 32 | remainCombDoll = peopleDolls[i]['max'] - peopleDolls[i]['min'] 33 | 34 | if remainTotalDoll >= remainCombDoll: 35 | result[i] += remainCombDoll 36 | total += remainCombDoll 37 | remainTotalDoll -= remainCombDoll 38 | else: 39 | result[i] += remainTotalDoll 40 | total += remainTotalDoll 41 | remainTotalDoll = 0 42 | 43 | if remainTotalDoll==0: return result 44 | return [-1] 45 | 46 | for i in f(): 47 | sys.stdout.write(str(i) + ' ') -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_11286/README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## 우선 순위 큐 4 | 5 | 1. PriorityQueue를 이용한 방법 6 | 7 | ```python 8 | import sys 9 | from queue import PriorityQueue 10 | 11 | que = PriorityQueue() 12 | 13 | N = int(sys.stdin.readline()) 14 | 15 | for i in range(N): 16 | x = int(sys.stdin.readline()) 17 | if(x!=0): que.put((abs(x), x)) 18 | else: 19 | if que.empty(): print(0) 20 | else: print(que.get()[1]) 21 | ``` 22 | 23 | 2. heapq를 이용한 방법 24 | 25 | ```python 26 | import sys 27 | import heapq 28 | 29 | N = int(input()) 30 | heap = [] 31 | 32 | for i in range(N): 33 | x = int(sys.stdin.readline()) 34 | if(x!=0): heapq.heappush(heap, (abs(x), x)) 35 | else: 36 | if len(heap)==0: print(0) 37 | else: print(heapq.heappop(heap)[1]) 38 | ``` 39 | 40 | 41 | 42 | ## 알게된 점 43 | 44 | - input()과 sys.stdin.readline의 속도 차이 [참조](https://www.acmicpc.net/blog/view/56) 45 | 46 | - N(=10,000,000), 자연수(10,000 이하)가 적힌 파일을 입력받는데 걸리는 시간을 측정 47 | 48 | - input()은 12.4443초 49 | 50 | - int(sys.stdin.readline())은 4.4394초 51 | 52 | - 제일 빠른건 map(int,os.read(0, 100000000).decode('utf-8').split('\n')) 53 | 54 | - 하지만 0.03초 차이밖에 나지 않음 55 | 56 | 57 | 58 | ## 참조 59 | 60 | [참조](https://www.youtube.com/watch?v=jfwjyJvbbBI) -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_11286/boj.11286_3.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import heapq 3 | 4 | N = int(input()) 5 | heap = [] 6 | 7 | for i in range(N): 8 | x = int(sys.stdin.readline()) 9 | if(x!=0): heapq.heappush(heap, (abs(x), x)) 10 | else: 11 | if len(heap)==0: print(0) 12 | else: print(heapq.heappop(heap)[1]) -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_11286/boj_11286_2.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from queue import PriorityQueue 3 | 4 | que = PriorityQueue() 5 | 6 | N = int(sys.stdin.readline()) 7 | 8 | for i in range(N): 9 | x = int(sys.stdin.readline()) 10 | if(x!=0): que.put((abs(x), x)) 11 | else: 12 | if que.empty(): print(0) 13 | else: print(que.get()[1]) -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_1158.py: -------------------------------------------------------------------------------- 1 | N, K = map(int, input().split()) 2 | 3 | numArr = [] 4 | queue = [] 5 | idx = 0 6 | 7 | for i in range(N): 8 | numArr.append(str(i+1)) 9 | 10 | while(len(numArr)!=0): 11 | idx = (idx + (K-1)) % len(numArr) 12 | popData = numArr.pop(idx) 13 | queue.append(popData) 14 | 15 | print('<'+', '.join(queue)+'>') -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_1406.py: -------------------------------------------------------------------------------- 1 | initString = input() 2 | M = int(input()) 3 | cursor = len(initString) 4 | 5 | def process(command): 6 | global initString 7 | if len(command)==1: 8 | singleCommand(command[0]) 9 | else: 10 | commandP(command[1]) 11 | 12 | def singleCommand(command): 13 | if command == 'L' : 14 | commandL() 15 | elif command == 'D': 16 | commandD() 17 | elif command == 'B': 18 | commandB() 19 | 20 | def commandP(ch): 21 | global initString, cursor, M 22 | if cursor == len(initString): 23 | initString = initString + ch 24 | else: 25 | initString = initString[:cursor] + ch + initString[cursor:] 26 | M += 1 27 | cursor += 1 28 | 29 | def commandL(): 30 | global cursor 31 | if cursor==0: 32 | return 33 | cursor -= 1 34 | 35 | def commandD(): 36 | global cursor 37 | if cursor==0: 38 | return 39 | cursor += 1 40 | 41 | def commandB(): 42 | global cursor, initString 43 | if cursor==0: 44 | return 45 | elif cursor==len(initString): 46 | initString = initString[:cursor-1] 47 | cursor -= 1 48 | else: 49 | initString = initString[:cursor-1] + initString[cursor:] 50 | cursor -= 1 51 | 52 | for i in range(M): 53 | inputString = input() 54 | command = inputString.split(' ') 55 | process(command) 56 | 57 | print(initString) 58 | 59 | -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_1991/README.md: -------------------------------------------------------------------------------- 1 | ## 트리 2 | 3 | - preorder(전위 순회) 4 | - 루트 / 왼쪽 자식 / 오른쪽 자식 5 | - inorder(중위 순회) 6 | - 왼쪽 자식 / 루트 / 오른쪽 자식 7 | - postorder(후위 순회) 8 | - 왼쪽 자식 / 오른쪽 자식 / 루트 9 | 10 | 11 | 12 | - python에서 트리는 어떻게 나타낼 지 모르겠어서 일단 dictionary로 만들었다. 13 | - 만들고 난 뒤 루트 노드인 'A'노드 부터 재귀적으로 값을 저장해주면 될 것 같다는 생각이 들었다. -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_1991/boj_1991.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def preorder(ch): 4 | result = '' 5 | if(ch!='.'): 6 | result += ch 7 | result += preorder(tree[ch][0]) 8 | result += preorder(tree[ch][1]) 9 | return result 10 | 11 | def inorder(ch): 12 | result = '' 13 | if(ch!='.'): 14 | result += inorder(tree[ch][0]) 15 | result += ch 16 | result += inorder(tree[ch][1]) 17 | return result 18 | 19 | def postorder(ch): 20 | result = '' 21 | if(ch!='.'): 22 | result += postorder(tree[ch][0]) 23 | result += postorder(tree[ch][1]) 24 | result += ch 25 | return result 26 | 27 | N = int(sys.stdin.readline()) 28 | tree = {} 29 | 30 | for i in range(N): 31 | line = sys.stdin.readline().replace('\n', '').split(' ') 32 | tree[line[0]] = [line[1], line[2]] 33 | 34 | print(preorder('A')) 35 | print(inorder('A')) 36 | print(postorder('A')) -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/boj_2346.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | 3 | inputString = input().split(' ') 4 | numArr = [] 5 | queue = [] 6 | idx = 0 7 | 8 | for i in range(N): 9 | numArr.append(str(i+1)) 10 | 11 | queue.append(numArr.pop(0)) 12 | inputString.pop(0) 13 | idx = ((idx + int(inputString[idx])) + len(numArr)) % len(numArr) 14 | print(idx) 15 | while(len(numArr)!=0): 16 | popData = numArr.pop(idx) 17 | idx = ((idx + (int(inputString[idx])-1)) + len(numArr)) % len(numArr) 18 | inputString.pop(idx) 19 | queue.append(popData) 20 | 21 | print('<'+', '.join(queue)+'>') 22 | 23 | 24 | # 움직이는거 queue로 하면 될 듯했는데.. 졸려서 잤어요... -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/pgs_위장/README.md: -------------------------------------------------------------------------------- 1 | ## 해시 2 | 3 | - python에서 hash는 dictionary 형태로 구현 가능하다. 4 | 5 | 6 | 7 | ## 아이디어 8 | 9 | - 처음에는 조합에 대해서 생각을 해봤다. 하지만 부분 집합의 개수를 구하는 데 많은 시간이 걸릴 것 같았다. 10 | 11 | - 다르게 생각을 해보며 몇 개 계산을 해보니 규칙이 눈에 보였다. 12 | 13 | - 의상의 개수가 [2, 2] 일 때 14 | 15 | > (2+1) * (2+1) - 1 = 8개였다. 16 | 17 | - 의상의 개수가 [2, 2, 3] 일 때 18 | 19 | > (2+1) * (2+1) * (3+1) - 1= 35개였다. 20 | 21 | - 결국 규칙은 구해온 values 모든 수에 1을 더하고 곱한 뒤 1을 뺀 값이다. 22 | 23 | - 생각을 해보니 입지 않은 경우의 수를 생각해 모든 경우의 수를 구한 뒤 모두 입지 않은 경우의 수인 1개를 빼기만 하면 되는 간단한 구현 문제였던 것 같다. -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/pgs_위장/pgs_위장.js: -------------------------------------------------------------------------------- 1 | const solution = clothes => { 2 | const clothesObject = clothes.reduce((acc, [name, kind]) => { 3 | acc.hasOwnProperty(kind)? acc[kind] += 1 : acc[kind] = 1; 4 | return acc; 5 | }, new Object()); 6 | 7 | return Object.values(clothesObject).reduce((acc, val) => acc *= val + 1, 1) - 1; 8 | } -------------------------------------------------------------------------------- /src/Do-ho/dataStructor/pgs_위장/pgs_위장.py: -------------------------------------------------------------------------------- 1 | def solution(clothes): 2 | answer = 1 3 | hash = {} 4 | for item in clothes: 5 | try: hash[item[1]] += 1 6 | except: hash[item[1]] = 1 + 1 7 | 8 | for val in list(hash.values()): answer *= val 9 | 10 | return answer - 1 -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_1260_DFS와BFS/README.md: -------------------------------------------------------------------------------- 1 | # DFS와 BFS 2 | 3 | - BFS (너비 우선 탐색) 4 | - queue를 이용해 해당 노드에 연결된 정점들을 정렬 후 추가 5 | - DFS(깊이 우선 탐색) 6 | - stack을 이용해 해당 노드에 연결된 정점들을 역정렬 후 추가 -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_1260_DFS와BFS/boj_1260.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def bfs(graph, start): 4 | visited = [] 5 | queue = [start] 6 | 7 | while queue: 8 | n = queue.pop(0) 9 | if n not in visited: 10 | visited.append(n) 11 | if n in graph: 12 | queue += sorted(graph[n] - set(visited)) 13 | return visited 14 | 15 | def dfs(graph, start): 16 | visited = [] 17 | stack = [start] 18 | 19 | while stack: 20 | n = stack.pop() 21 | if n not in visited: 22 | visited.append(n) 23 | if n in graph: 24 | stack += sorted(graph[n] - set(visited), reverse=True) 25 | return visited 26 | 27 | [N, M, V] = map(int, sys.stdin.readline()[:-1].split(' ')) 28 | 29 | tree = {} 30 | 31 | for i in range(N+1): 32 | tree[i] = set() 33 | 34 | for i in range(M): 35 | [startPoint, endPoint] = list(map(int, sys.stdin.readline()[:-1].split(' '))) 36 | tree[startPoint].add(endPoint) 37 | tree[endPoint].add(startPoint) 38 | 39 | print(" ".join(map(str, dfs(tree, V)))) 40 | print(" ".join(map(str, bfs(tree, V)))) 41 | -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_1697_숨바꼭질/README.md: -------------------------------------------------------------------------------- 1 | # 숨바꼭질 2 | 3 | ##### 1. 재귀를 통한 풀이 4 | 5 | ```python 6 | import sys 7 | 8 | maxCount = 100001 9 | 10 | def search(start, end, count): 11 | global maxCount 12 | if(count>=maxCount): 13 | return 14 | if start==end: 15 | if maxCount>=count: 16 | maxCount = count 17 | return 18 | elif (end*2)<=start: 19 | return 20 | elif start<=-1: 21 | return 22 | else: 23 | if start==0: 24 | search(start+1, end, count+1) 25 | if start < end: 26 | search(start*2, end, count+1) 27 | search(start+1, end, count+1) 28 | search(start-1, end, count+1) 29 | else: 30 | count += end-start 31 | return 32 | 33 | [N, K] = map(int, sys.stdin.readline()[:-1].split(' ')) 34 | search(N, K, 0) 35 | 36 | print(maxCount) 37 | ``` 38 | - 해당 풀이는 재귀의 호출이 너무 많아 런타임이 나옴 39 | 40 | 41 | 42 | ##### 2. bfs를 통한 풀이 43 | 44 | ```python 45 | import sys 46 | 47 | checkList = [False for i in range(100001)] 48 | 49 | def search(start, end): 50 | global checkList 51 | 52 | queue = [(start, 0)] 53 | 54 | while len(queue)!=0: 55 | target = queue.pop(0) 56 | if target[0] > 100000 or target[0] < 0: continue 57 | if checkList[target[0]]: continue 58 | 59 | checkList[target[0]] = True 60 | 61 | if target[0] == end: 62 | print(target[1]) 63 | break 64 | 65 | queue.append((target[0]*2, target[1] + 1)) 66 | queue.append((target[0]-1, target[1] + 1)) 67 | queue.append((target[0]+1, target[1] + 1)) 68 | 69 | [N, K] = map(int, sys.stdin.readline()[:-1].split(' ')) 70 | 71 | search(N, K) 72 | ``` 73 | 74 | - bfs를 통해 가장 먼저 찾아지는 카운트를 활용 -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_1697_숨바꼭질/boj_1697.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | checkList = [False for i in range(100001)] 4 | 5 | def search(start, end): 6 | global checkList 7 | 8 | queue = [(start, 0)] 9 | 10 | while len(queue)!=0: 11 | target = queue.pop(0) 12 | if target[0] > 100000 or target[0] < 0: continue 13 | if checkList[target[0]]: continue 14 | 15 | checkList[target[0]] = True 16 | 17 | if target[0] == end: 18 | print(target[1]) 19 | break 20 | 21 | queue.append((target[0]*2, target[1] + 1)) 22 | queue.append((target[0]-1, target[1] + 1)) 23 | queue.append((target[0]+1, target[1] + 1)) 24 | 25 | [N, K] = map(int, sys.stdin.readline()[:-1].split(' ')) 26 | 27 | search(N, K) -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_19238_스타트택시/README.md: -------------------------------------------------------------------------------- 1 | # 스타트 택시 2 | 3 | - 맵에다가 해당 사람을 표현 4 | 5 | - 1은 벽, 2와 -2를 동시에 표현해 시작점과 도착점을 표기 6 | 7 | - 이렇게 할 경우 겹칠 위험이 있을듯 8 | - 따라서 맵에 넣고 비교하는 것도 좋을듯 9 | 10 | - 길 찾기 알고리즘으로 bfs를 채택 11 | 12 | - 모든 맵을 찾지 않고 중간에 break 가능할까? 13 | 14 | ```python 15 | def bfs(graph, start): 16 | visited = [] 17 | queue = [start] 18 | 19 | while queue: 20 | n = queue.pop(0) 21 | if n not in visited: 22 | visited.append(n) 23 | if n in graph: 24 | queue += sorted(graph[n] - set(visited)) 25 | return visited 26 | ``` 27 | 28 | - 재귀 구조가 아니라서 가능할 것 같음! 29 | - 어디로 움직일 지에 대한 설계가 필요 30 | 31 | - 32 | 33 | -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_19238_스타트택시/boj_19238.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | # N : 활동 영역(가로 * 세로) 4 | # M : 승객의 수 5 | # fuel : 처음 소지한 연료 6 | [N, M, fuel] = map(int, sys.stdin.readline()[:-1].split(' ')) 7 | 8 | road = [] 9 | 10 | # 길 입력 11 | for i in range(N): 12 | appendArr = list(map(int, sys.stdin.readline()[:-1].split(' '))) 13 | road.append(appendArr) 14 | 15 | # 택시 처음 좌표 입력 16 | [taxiX, texiY] = map(int, sys.stdin.readline()[:-1].split(' ')) 17 | 18 | # 손님 위치 및 목적지 입력 19 | for i in range(M): 20 | cus = list(map(int, sys.stdin.readline()[:-1].split(' '))) 21 | road[cus[0]-1][cus[1]-1] = i+2 22 | road[cus[2]-1][cus[3]-1] = -(i+2) 23 | 24 | print(road) 25 | 26 | def dfs(startPoint, endPoint): 27 | num = 0 28 | 29 | # if(startPoint[0]>=endPoint[0]): 30 | 31 | 32 | return num -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_2178_미로탐색/README.md: -------------------------------------------------------------------------------- 1 | # 미로 탐색 2 | 3 | - 31782KB, 132ms 4 | - 너비 우선 탐색으로 해결 5 | 6 | ``` 7 | import sys 8 | from collections import deque 9 | 10 | D = [(1, 0), (0, 1), (-1, 0), (0, -1)] 11 | 12 | N, M = map(int, sys.stdin.readline().strip().split()) 13 | MAZE = deque() 14 | for _ in range(N): MAZE.append(sys.stdin.readline().strip()) 15 | 16 | q = deque() 17 | visited = [[False for _ in range(M)] for _ in range(N)] 18 | q.append((0,0,1)) 19 | visited[0][0] = True 20 | 21 | while q: 22 | tx, ty, moves = q.popleft() 23 | if(tx == N-1 and ty == M-1): 24 | sys.stdout.write(str(moves)+'\n') 25 | break 26 | for DIR in D: 27 | nx, ny = [tx + DIR[0], ty + DIR[1]] 28 | if(nx < 0 or nx >= N or ny < 0 or ny >= M): continue 29 | if(MAZE[nx][ny] == '0' or visited[nx][ny]): continue 30 | q.append((nx, ny, moves+1)) 31 | visited[nx][ny] = True 32 | ``` 33 | -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_2178_미로탐색/boj_2178.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | D = [(1, 0), (0, 1), (-1, 0), (0, -1)] 5 | 6 | N, M = map(int, sys.stdin.readline().strip().split()) 7 | MAZE = deque() 8 | for _ in range(N): MAZE.append(sys.stdin.readline().strip()) 9 | 10 | q = deque() 11 | visited = [[False for _ in range(M)] for _ in range(N)] 12 | q.append((0,0,1)) 13 | visited[0][0] = True 14 | 15 | while q: 16 | tx, ty, moves = q.popleft() 17 | if(tx == N-1 and ty == M-1): 18 | sys.stdout.write(str(moves)+'\n') 19 | break 20 | for DIR in D: 21 | nx, ny = [tx + DIR[0], ty + DIR[1]] 22 | if(nx < 0 or nx >= N or ny < 0 or ny >= M): continue 23 | if(MAZE[nx][ny] == '0' or visited[nx][ny]): continue 24 | q.append((nx, ny, moves+1)) 25 | visited[nx][ny] = True -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_2606_바이러스/README.md: -------------------------------------------------------------------------------- 1 | # 바이러스 2 | 3 | - bfs로 가뿐하게 통과~~!! -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_2606_바이러스/boj_2606.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def bfs(graph, start): 4 | visited = [] 5 | queue = [start] 6 | 7 | while len(queue)!=0: 8 | target = queue.pop(0) 9 | if target not in visited: 10 | visited.append(target) 11 | for item in graph[target]: 12 | queue.append(item) 13 | return len(visited)-1 14 | 15 | computerNum = int(sys.stdin.readline()[:-1]) 16 | lineNum = int(sys.stdin.readline()[:-1]) 17 | graph = {} 18 | 19 | for i in range(lineNum): 20 | [node1, node2] = map(int, sys.stdin.readline()[:-1].split(' ')) 21 | try: graph[node1].append(node2) 22 | except: graph[node1] = [node2] 23 | 24 | try: graph[node2].append(node1) 25 | except: graph[node2] = [node1] 26 | 27 | print(bfs(graph, 1)) -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_2644_촌수계산/README.md: -------------------------------------------------------------------------------- 1 | # 촌수 계산 2 | 3 | dfs로 풀어버리자~~~ 4 | 5 | 근데 ... exit()를 쓰면 런타임 오류가 나옴.. ㅠㅠ -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_2644_촌수계산/boj_2644.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | n = int(sys.stdin.readline()) 5 | a, b = map(int, sys.stdin.readline().rstrip().split()) 6 | m = int(sys.stdin.readline()) 7 | 8 | r = {} 9 | 10 | for _ in range(m): 11 | x, y = map(int, sys.stdin.readline().rstrip().split()) 12 | try: r[x].append(y) 13 | except: r[x] = [y] 14 | try: r[y].append(x) 15 | except: r[y] = [x] 16 | 17 | def dfs(): 18 | q = deque() 19 | q.append((a, 0)) 20 | visited = [False for _ in range(n+1)] 21 | 22 | while(q): 23 | target, chon = q.pop() 24 | if(target == b): 25 | return chon 26 | for item in r[target]: 27 | if(visited[item]): continue 28 | q.append((item, chon+1)) 29 | visited[item] = True 30 | return -1 31 | 32 | print(dfs()) -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/boj_7569_토마토/boj_7569_2.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | directions = [(-1, 0, 0), (1, 0, 0), (0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1)] 5 | 6 | [M, N, H] = map(int, sys.stdin.readline().split()) 7 | 8 | tomato = [] 9 | 10 | for i in range(H): 11 | tmp = [] 12 | for j in range(N): 13 | tmp.append(list(map(int, sys.stdin.readline().split()))) 14 | tomato.append(tmp) 15 | 16 | def function(): 17 | ripeTomatos = deque() 18 | visited = [[[False for i in range(M)] for i in range(N)] for i in range(H)] 19 | 20 | for i in range(H): 21 | for j in range(N): 22 | for k in range(M): 23 | if tomato[i][j][k] == 1: 24 | ripeTomatos.append((i, j, k, 0)) 25 | 26 | day = 0 27 | 28 | while ripeTomatos: 29 | z, y, x, day = ripeTomatos.popleft() 30 | if tomato[z][y][x]==0: tomato[z][y][x] = 1 31 | for dx, dy, dz in directions: 32 | nx, ny, nz = x+dx, y+dy, z+dz 33 | if nx<0 or ny<0 or nz<0 or nx>=M or ny>=N or nz>=H: continue 34 | if tomato[nz][ny][nx] == 0: 35 | if not visited[nz][ny][nx]: 36 | ripeTomatos.append((nz, ny, nx, day+1)) 37 | visited[nz][ny][nx] = True 38 | 39 | for i in range(H): 40 | for j in range(N): 41 | for k in range(M): 42 | if tomato[i][j][k] == 0: 43 | return -1 44 | 45 | return day 46 | 47 | sys.stdout.write(str(function())) -------------------------------------------------------------------------------- /src/Do-ho/dfsbfs/pgs_네트워크/pgs_네트워크.js: -------------------------------------------------------------------------------- 1 | const solution = (n, computers) => { 2 | let answer = 0; 3 | let visited = new Array(n).fill(false); 4 | let queue = []; 5 | const loopArray = [... new Array(n).keys()]; 6 | const isEmpty = () => queue.length !== 0; 7 | 8 | const dfs = () => { 9 | const targetIdx = queue.pop(); 10 | const target = computers[targetIdx] 11 | loopArray.forEach((idx) => { 12 | if(visited[idx] || target[idx] === 0) return; 13 | queue.push(idx); 14 | visited[idx] = true; 15 | }); 16 | } 17 | 18 | loopArray.forEach((computerID) => { 19 | if(visited[computerID]) return; 20 | queue.push(computerID); 21 | while(isEmpty()) dfs(); 22 | answer++; 23 | }) 24 | 25 | return answer; 26 | } -------------------------------------------------------------------------------- /src/Do-ho/divide_conquer/boj_1780_종이의개수/boj_1780.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | def conquer(arr): 5 | L = len(arr) 6 | A = L * L 7 | 8 | if A==1: return arr[0][0] 9 | 10 | check = arr[0][0] 11 | 12 | for i in range(L): 13 | for j in range(L): 14 | if arr[i][j] != check: return "-2" 15 | 16 | return check 17 | 18 | def divide(arr): 19 | L = len(arr) 20 | 21 | area = [deque() for i in range(9)] 22 | k = int(L/3) 23 | 24 | for i in range(0, k): 25 | area[0].append(arr[i][:k]) 26 | area[1].append(arr[i][k:2*k]) 27 | area[2].append(arr[i][2*k:]) 28 | for i in range(k, 2*k): 29 | area[3].append(arr[i][:k]) 30 | area[4].append(arr[i][k:2*k]) 31 | area[5].append(arr[i][2*k:]) 32 | for i in range(2*k, L): 33 | area[6].append(arr[i][:k]) 34 | area[7].append(arr[i][k:2*k]) 35 | area[8].append(arr[i][2*k:]) 36 | 37 | return area 38 | 39 | def f(arr): 40 | minus_one_paper = 0 41 | zero_paper = 0 42 | one_paper = 0 43 | 44 | status = conquer(arr) 45 | if status == '0': zero_paper +=1 46 | elif status == '1': one_paper += 1 47 | elif status == '-1': minus_one_paper += 1 48 | else: 49 | dividearr = divide(arr) 50 | for da in dividearr: 51 | result = f(da) 52 | minus_one_paper += result[0] 53 | zero_paper += result[1] 54 | one_paper += result[2] 55 | 56 | return [minus_one_paper, zero_paper, one_paper] 57 | 58 | N = int(sys.stdin.readline()) 59 | 60 | paper = [] 61 | 62 | for i in range(N): 63 | paper.append(sys.stdin.readline().split()) 64 | 65 | papernum = f(paper) 66 | 67 | sys.stdout.write(str(papernum[0])+'\n') 68 | sys.stdout.write(str(papernum[1])+'\n') 69 | sys.stdout.write(str(papernum[2])+'\n') -------------------------------------------------------------------------------- /src/Do-ho/divide_conquer/boj_1992_쿼드트리/boj_1992.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | def conquer(arr): 5 | L = len(arr) 6 | A = L * L 7 | one = 0 8 | zero = 0 9 | 10 | if A==1: return arr[0][0] 11 | 12 | for i in range(L): 13 | for j in range(L): 14 | if arr[i][j] == '1': one += 1 15 | else: zero += 1 16 | 17 | if one==A: return '1' 18 | elif zero==A: return '0' 19 | else: return '-1' 20 | 21 | def divide(arr): 22 | L = len(arr) 23 | 24 | area1 = deque() 25 | area2 = deque() 26 | area3 = deque() 27 | area4 = deque() 28 | 29 | for i in range(0, int(L/2)): 30 | area1.append(arr[i][:int(L/2)]) 31 | area2.append(arr[i][int(L/2):]) 32 | for i in range(int(L/2), L): 33 | area3.append(arr[i][:int(L/2)]) 34 | area4.append(arr[i][int(L/2):]) 35 | 36 | return [area1, area2, area3, area4] 37 | 38 | def quad(arr): 39 | result = "" 40 | status = conquer(arr) 41 | 42 | if status == '0': result += "0" 43 | elif status == '1': result += "1" 44 | else: 45 | result += "(" 46 | dividearr = divide(arr) 47 | for da in dividearr: 48 | result += quad(da) 49 | result += ")" 50 | return result 51 | 52 | N = int(sys.stdin.readline()) 53 | 54 | video = [] 55 | 56 | for i in range(N): 57 | value = sys.stdin.readline() 58 | video.append(value) 59 | 60 | sys.stdout.write(quad(video)) -------------------------------------------------------------------------------- /src/Do-ho/divide_conquer/boj_2630_색종이만들기/boj_2630.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | def conquer(arr): 5 | L = len(arr) 6 | A = L * L 7 | white = 0 8 | blue = 0 9 | 10 | if A==1: return arr[0][0] 11 | 12 | for i in range(L): 13 | for j in range(L): 14 | if arr[i][j] == 0: white += 1 15 | else: blue += 1 16 | 17 | if white==A: return 0 18 | elif blue==A: return 1 19 | else: return -1 20 | 21 | def divide(arr): 22 | L = len(arr) 23 | 24 | area1 = deque() 25 | area2 = deque() 26 | area3 = deque() 27 | area4 = deque() 28 | 29 | for i in range(0, int(L/2)): 30 | area1.append(arr[i][:int(L/2)]) 31 | area2.append(arr[i][int(L/2):]) 32 | for i in range(int(L/2), L): 33 | area3.append(arr[i][:int(L/2)]) 34 | area4.append(arr[i][int(L/2):]) 35 | 36 | return [area1, area2, area3, area4] 37 | 38 | N = int(sys.stdin.readline()) 39 | 40 | paper = [] 41 | white_paper = 0 42 | blue_paper = 0 43 | 44 | for i in range(N): 45 | paper.append(list(map(int, sys.stdin.readline().split()))) 46 | 47 | queue = deque() 48 | queue.append(paper) 49 | 50 | while queue: 51 | target = queue.popleft() 52 | status = conquer(target) 53 | if status == 0: white_paper +=1 54 | elif status == 1: blue_paper += 1 55 | else: 56 | queue.extend(divide(target)) 57 | 58 | print(white_paper) 59 | print(blue_paper) -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_1010_다리놓기/README.md: -------------------------------------------------------------------------------- 1 | # 다리 놓기 2 | 3 | f(1, 1) = 1 4 | f(1, 2) = 2 5 | f(1, 3) = 3 6 | ~~ 7 | 8 | f(2, 2) = f(1, 1) 9 | f(2, 3) = f(1, 2) + f(1, 1) 10 | f(2, 4) = f(1, 3) + f(1, 2) + f(1, 1) = f(1, 3) + f(2, 3) 11 | f(3, 3) = f(2, 2) 12 | f(3, 4) = f(2, 3) + f(2, 2) 13 | f(3, 5) = f(2, 4) + f(2, 3) + f(2, 2) = f(2, 4) + f(3, 4) 14 | 15 | 따라서 점화식 16 | 17 | f(n, k) = f(n-1, k-1) + f(n, k-1) 18 | = f(n, k-1) + f(n-1, k-1) 19 | 20 | -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_1010_다리놓기/boj_1010.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | D = [[0 for _ in range(30)] for _ in range(30)] 4 | 5 | def f(i, j): 6 | if j 어떤 문제의 입력사례의 최적해가 그 입력사례를 분할한 부분사례에 대한 최적해를 항상 포함하고 있으면, 그 문제에 대하여 최적의 원리가 성립한다. 5 | 6 | ### [참고](https://gsmesie692.tistory.com/113) 7 | 8 | 1개. 2개. 3개 9 | 10 | 2차원 배열적으로 생각해볼까? 11 | 12 | W V 13 | 6 13 14 | 4 8 15 | 3 6 16 | 5 12 17 | 18 | D[i][k] = i번째 물건까지 사용하여 k 용량의 가방에 물건을 채울때 최대 가치 19 | 20 | [0, 0, 0, 0, 0, 13, 13] 21 | [0, 0, 0, 8, 8, 13, 13] 22 | [0, 0, 6, 8, 8, 13, 14] 23 | [0, 0, 6, 8, 12, 13, 14] 24 | 25 | 이 문제를 봤을 때 D[i][j] = V[i] + D[i-1][j-w[i]]의 점화식이 적용된다. 26 | 여기서 j는 현재 검사하는 배낭의 무게 w[i]는 i의 무게이다. 27 | 현재 검사하는 배낭의 무게 - 넣으려고하는 것의 무게를 빼면 28 | 지금까지 알아온 배낭 배열에서 그 무게에 해당하는 값이 최적이므로 29 | 검사 대상이다. 30 | 31 | 결국 32 | w[i] > j D[i][j] = D[i-1][j] 33 | w[i] <= j D[i][j] = max(V[i] + D[i-1][j-w[i]] , D[i-1][j]) 34 | 35 | 하면 된다. -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_12865_평범한배낭/boj_12865.py: -------------------------------------------------------------------------------- 1 | # w[i] > j D[i][j] = D[i-1][j] 2 | # w[i] <= j D[i][j] = max(V[i] + D[i-1][j-w[i]] , D[i-1][j]) 3 | 4 | import sys 5 | 6 | [N, K] = map(int, sys.stdin.readline().strip().split()) 7 | 8 | B = [] 9 | D = [[0 for _ in range(K)] for _ in range(N)] 10 | 11 | for _ in range(N): 12 | B.append(list(map(int, sys.stdin.readline().strip().split()))) 13 | 14 | for i in range(N): 15 | if i==1: 16 | D[i][B[0][0]] = B[0][1] 17 | continue 18 | for j in range(K): 19 | -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_1932_정수삼각형/README.md: -------------------------------------------------------------------------------- 1 | # 정수삼각형 2 | 3 | D에 저장하면서 밑으로 내려감 4 | 5 | 맨 왼쪽에 대해서만 예외처리를 해주면 좋을듯 -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_1932_정수삼각형/boj_1932.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | n = int(sys.stdin.readline()) 4 | 5 | D = [[0 for _ in range(n)] for _ in range(n)] 6 | 7 | def f(idx): 8 | return 0 9 | 10 | triangle = [] 11 | 12 | for i in range(n): 13 | triangle.append(list(map(int, sys.stdin.readline().strip().split()))) 14 | 15 | D[0][0] = triangle[0][0] 16 | 17 | for i in range(1, n): 18 | for j in range(i+1): 19 | try: D[i][j] = triangle[i][j] + max(D[i-1][j-1], D[i-1][j]) 20 | except: D[i][j] = triangle[i][j] + D[i-1][j] 21 | 22 | print(max(D[n-1])) -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_2011_암호코드/README.md: -------------------------------------------------------------------------------- 1 | # 암호코드 2 | 3 | 탑다운으로 생각해서 적용해봄 재귀 너무 많이 도는 듯.. 4 | ```런다임 에러``` 5 | 6 | ``` 7 | import sys 8 | 9 | def isDivision(n): 10 | return n>=10 and n<=26 11 | 12 | def DP(n, l): 13 | if (l<=0): return 0 14 | if (l==1): return 1 15 | if (l==2): 16 | if(isDivision(int(n[:l]))): return 2 17 | return 1 18 | if(isDivision(int(n[l-2:l]))): return DP(n, l-1) + DP(n, l-2) 19 | return DP(n, l-1) 20 | 21 | N = sys.stdin.readline().strip() 22 | L = len(N) 23 | 24 | print(DP(N, L)%1000000) 25 | ``` 26 | 27 | 바텀 업으로 풀어보자.... 28 | 29 | D(n) = D(n-1) + D(n-2) (분기가 될 경우) 30 | D(n) = D(n-1) (분기가 되지 않을 경우) 31 | 32 | 입력이 0인것도 처리... 33 | 34 | 반례 찾기... 35 | 1. 100일때 -> 0 36 | 2. 36036일때 -> 0 37 | 38 | 0앞에 1개나 2개가 잘못되면 안됨 39 | 40 | 100 -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_2011_암호코드/boj_2011.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def isAlpha(n): 4 | return int(n)>=1 and int(n)<=26 5 | 6 | def isDivision(n): 7 | return int(n)>10 and int(n)<=26 and int(n)!=20 8 | 9 | def validation(n): 10 | if(n[0]=='0'): return False 11 | prev = n[0] 12 | for i in range(1, len(n)): 13 | if(n[i]=='0' and (prev != '1' and prev != '2')): return False 14 | prev = n[i] 15 | return True 16 | 17 | def decode(N): 18 | L = len(N) + 1 19 | D = [0 for _ in range(L)] 20 | if(not validation(N)): return 0 21 | D[0] = 1 22 | 23 | if(isDivision(N[:2])): D[1] = 2 24 | else: D[1] = 1 25 | 26 | if(L > 2): prev = N[1] 27 | 28 | for i in range(2, len(N)): 29 | target = N[i] 30 | word = prev + target 31 | if(word=='10' or word=='20'): D[i] = D[i-2] 32 | elif(not isAlpha(word)): D[i] = D[i-1] 33 | elif(prev == '0'): D[i] = D[i-2] 34 | elif(target == '0'): D[i] = D[i-2] 35 | else: D[i] = D[i-1] + D[i-2] 36 | prev = N[i] 37 | print(D) 38 | return D[L-2] % 1000000 39 | 40 | N = sys.stdin.readline().strip() 41 | print(decode(N)) -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_2502_떡먹는호랑이/README.md: -------------------------------------------------------------------------------- 1 | # 떡 먹는 호랑이 2 | 3 | R3 = R2 + R1 4 | R4 = R3 + R2 = R2 + R2 + R1 = 2R2 + R1 5 | R5 = R4 + R3 = 2R3 + R2 = 2(R2 + R1) + R2 = 3R2 + 2R1 6 | R6 = R5 + R4 = 2R4 + R3 = 2(2R2 + R1) + (R2 + R1) = 5R2 + 3R1 7 | 8 | 계수가 규칙이 있는듯! 9 | 10 | 1 1 2 3 5 8 13 11 | 12 | 피보나치로 증가 13 | 14 | R3 = 1 1 >> 얘가 1 1으로 시작하니 반복 시작하면 될듯 15 | 16 | ``` 17 | import sys 18 | 19 | def calculate(a, b, A, B): 20 | return a*A + b*B 21 | 22 | D, K = map(int, sys.stdin.readline().rstrip().split()) 23 | 24 | FIBO = [1 for _ in range(D)] 25 | for i in range(2, D): 26 | FIBO[i] = FIBO[i-1] + FIBO[i-2] 27 | 28 | a, b = FIBO[D-3], FIBO[D-2] 29 | 30 | def getResult(): 31 | for i in range(1, K): 32 | for j in range(1, K): 33 | result = calculate(a, b, i, j) 34 | if(result > K): break 35 | if(result==K): 36 | return str(i)+'\n'+str(j)+'\n' 37 | 38 | sys.stdout.write(getResult()) 39 | ``` 40 | 41 | 반복문 하나 줄이기 42 | ``` 43 | import sys 44 | 45 | def calculate(a, b, A, B): 46 | return a*A + b*B 47 | 48 | D, K = map(int, sys.stdin.readline().rstrip().split()) 49 | 50 | FIBO = [1 for _ in range(D)] 51 | for i in range(2, D): 52 | FIBO[i] = FIBO[i-1] + FIBO[i-2] 53 | 54 | a, b = FIBO[D-3], FIBO[D-2] 55 | 56 | def getResult(): 57 | for i in range(1, K): 58 | j = (K - a*i)/b 59 | if j.is_integer(): return str(i)+'\n'+str(int(j))+'\n' 60 | 61 | sys.stdout.write(getResult()) 62 | ``` -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_2502_떡먹는호랑이/boj_2502.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def calculate(a, b, A, B): 4 | return a*A + b*B 5 | 6 | D, K = map(int, sys.stdin.readline().rstrip().split()) 7 | 8 | FIBO = [1 for _ in range(D)] 9 | for i in range(2, D): 10 | FIBO[i] = FIBO[i-1] + FIBO[i-2] 11 | 12 | a, b = FIBO[D-3], FIBO[D-2] 13 | 14 | def getResult(): 15 | for i in range(1, K): 16 | j = (K - a*i)/b 17 | if j.is_integer(): return str(i)+'\n'+str(int(j))+'\n' 18 | 19 | sys.stdout.write(getResult()) -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_2579_계단오르기/README.md: -------------------------------------------------------------------------------- 1 | # 계단 오르기 2 | 3 | 처음 생각난 것은 베스킨라빈스 생각남... 4 | 필승법.. 5 | 6 | 마지막을 무조건 부르면 지는 게임에서 똑같이 3단계를 고려했을 때 7 | 4단계를 고려하면 이기는 게임 8 | 9 | 마지막을 무조건 밟아야하므로 마지막으로부터 필승법을 생각! 10 | 11 | 마지막 이전꺼를 밟을 경우 = 마지막 점수 + 마지막 이전꺼 점수 + 마지막 전전전꺼까지의 최고값 12 | 13 | 마지막 전전꺼를 밟는 경우 = 마지막 점수 + 마지막 전전꺼까지의 최고값 14 | 15 | 점화식으로 보면 16 | 17 | f(n) = s(n) + s(n-1) + f(n-3) 18 | f(n) = s(n) + f(n-2) 19 | 단 n>3 -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_2579_계단오르기/boj_2579.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | T = int(sys.stdin.readline()) 4 | S = [0 for _ in range(T)] 5 | D = [0 for _ in range(T)] 6 | 7 | for i in range(T): 8 | S[i] = int(sys.stdin.readline()) 9 | 10 | D[0] = S[0] 11 | if T>1: D[1] = S[1] + D[0] 12 | if T>2: D[2] = max(S[0]+S[2], S[1]+S[2]) 13 | 14 | for i in range(3, T): 15 | D[i] = max(S[i] + S[i-1] + D[i-3], S[i] + D[i-2]) 16 | 17 | print(D[T-1]) -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_9096_123더하기/README.md: -------------------------------------------------------------------------------- 1 | # 1,2,3 더하기 2 | 3 | 1일 때 4 | 1 5 | 6 | 2일 때 7 | 1+1 8 | 2 9 | 10 | 3일 때 11 | 1+1+1 12 | 1+2 13 | 2+1 14 | 3 15 | 16 | 4일 때 17 | 1+1+1+1 18 | 1+1+2 19 | 1+2+1 20 | 2+1+1 21 | 2+2 22 | 1+3 23 | 3+1 24 | 25 | 1의 경우에 수에 3을 더한 경우의 수 26 | 2의 경우에 수에 2를 더한 경우의 수 27 | 3의 경우에 수에 1을 더한 경우의 수 28 | 29 | F(1) + 3 -> 1 30 | F(2) + 2 -> 2 31 | F(3) + 1 -> 4 32 | F(4) = F(1) + F(2) + F(3) = 7 -------------------------------------------------------------------------------- /src/Do-ho/dp/boj_9096_123더하기/boj_9095.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | T = int(sys.stdin.readline()) 4 | 5 | D = [0 for _ in range(12)] 6 | D[1] = 1 7 | D[2] = 2 8 | D[3] = 4 9 | 10 | for i in range(4, 12): 11 | D[i] = D[i-3] + D[i-2] + D[i-1] 12 | 13 | for _ in range(T): 14 | n = int(sys.stdin.readline()) 15 | sys.stdout.write(str(D[n])+'\n') -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_11047_동전0/README.md: -------------------------------------------------------------------------------- 1 | # 동전 0 2 | 3 | - 1번 째 시도 (시간 초과) 4 | ```python 5 | import sys 6 | 7 | def diff(a, b): 8 | return a-b 9 | 10 | [N, K] = map(int, sys.stdin.readline().split()) 11 | 12 | coinKinds = [] 13 | 14 | for _ in range(N): 15 | coinKinds.append(int(sys.stdin.readline())) 16 | 17 | coinKinds.sort() 18 | 19 | count = 0 20 | while K!=0: 21 | mindiff = diff(K, coinKinds[0]) 22 | for coinKind in coinKinds: 23 | value = diff(K, coinKind) 24 | if value < 0: break 25 | if mindiff > value: 26 | mindiff = value 27 | K = mindiff 28 | count += 1 29 | 30 | print(count) 31 | ``` 32 | 33 | - 2번째 시도 (한번에 처리) 34 | ```python 35 | import sys 36 | 37 | def diff(a, b): 38 | return a-b 39 | 40 | [N, K] = map(int, sys.stdin.readline().split()) 41 | 42 | coinKinds = [] 43 | 44 | for _ in range(N): 45 | coinKinds.append(int(sys.stdin.readline())) 46 | 47 | coinKinds.sort() 48 | 49 | count = 0 50 | while K!=0: 51 | mindiff = diff(K, coinKinds[0]) 52 | minIdx = 0 53 | for idx, coinKind in enumerate(coinKinds): 54 | value = diff(K, coinKind) 55 | if value < 0: break 56 | if mindiff > value: 57 | mindiff = value 58 | minIdx = idx 59 | count += K//coinKinds[minIdx] 60 | K -= coinKinds[minIdx] * (K//coinKinds[minIdx]) 61 | 62 | 63 | print(count) 64 | ``` -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_11047_동전0/boj_11047.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def diff(a, b): 4 | return a-b 5 | 6 | [N, K] = map(int, sys.stdin.readline().split()) 7 | 8 | coinKinds = [] 9 | 10 | for _ in range(N): 11 | coinKinds.append(int(sys.stdin.readline())) 12 | 13 | coinKinds.sort() 14 | 15 | count = 0 16 | while K!=0: 17 | mindiff = diff(K, coinKinds[0]) 18 | minIdx = 0 19 | for idx, coinKind in enumerate(coinKinds): 20 | value = diff(K, coinKind) 21 | if value < 0: break 22 | if mindiff > value: 23 | mindiff = value 24 | minIdx = idx 25 | count += K//coinKinds[minIdx] 26 | K -= coinKinds[minIdx] * (K//coinKinds[minIdx]) 27 | 28 | 29 | print(count) -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_11399_ATM/README.md: -------------------------------------------------------------------------------- 1 | # ATM 2 | 3 | case 4 | ``` 3 1 4 3 2 ``` 5 | 6 | 3 7 | 3 + 1 = 4 8 | 3 + 1 + 4 = 8 9 | 3 + 1 + 4 + 3 = 11 10 | 3 + 1 + 4 + 3 + 2 = 13 11 | 12 | 3 + 4 + 8 + 11 + 13 = 39 13 | 14 | ------- 15 | 16 | case 17 | ``` 1 2 3 3 4 ``` 18 | 19 | 1 20 | 1 + 2 = 3 21 | 1 + 2 + 3 = 6 22 | 1 + 2 + 3 + 3 = 9 23 | 1 + 2 + 3 + 3 + 4 = 13 24 | 25 | 1 + 3 + 6 + 9 + 13 = 32 26 | 27 | sort()한게 제일 좋다! -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_11399_ATM/boj_11399.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | N = int(sys.stdin.readline()) 4 | P = list(map(int, sys.stdin.readline().strip().split())) 5 | 6 | P.sort() 7 | 8 | Psum = 0 9 | offset = 0 10 | 11 | for item in P: 12 | offset += item 13 | Psum += offset 14 | 15 | sys.stdout.write(str(Psum) + '\n') -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_11497_통나무/boj_11497.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | def diff(a, b): 5 | return abs(a-b) 6 | 7 | T = int(sys.stdin.readline()) 8 | 9 | for _ in range(T): 10 | N = int(sys.stdin.readline()) 11 | tongtree = list(map(int, sys.stdin.readline().split())) 12 | newtongtree = deque() 13 | tongtree.sort() 14 | 15 | for item in tongtree: 16 | topIdx = len(newtongtree) 17 | if topIdx <= 1: newtongtree.append(item) 18 | else: 19 | if newtongtree[0] > newtongtree[topIdx-1]: newtongtree.append(item) 20 | else: newtongtree.appendleft(item) 21 | 22 | maxDiff = diff(newtongtree[0], newtongtree[1]) 23 | for idx in range(N-1): 24 | value = diff(newtongtree[idx], newtongtree[idx+1]) 25 | if maxDiff < value: maxDiff = value 26 | 27 | print(maxDiff) -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_17609_회문/boj_17609.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def isPalindrome(S): 4 | mid = int(len(S) / 2) 5 | for i in range(mid): 6 | if (S[i] != S[len(S)-1-i]): return False 7 | return True 8 | 9 | def isPseudoPalindrome(S): 10 | mid = int(len(S) / 2) 11 | for i in range(mid): 12 | if (S[i] != S[len(S)-1-i]): 13 | FrontStr = S[:i] + S[i+1:] 14 | BackStr = S[:len(S)-1-i] + S[len(S)-i:] 15 | if(isPalindrome(FrontStr) or isPalindrome(BackStr)): return True 16 | return False 17 | return True 18 | 19 | def palindrome(S): 20 | if(isPalindrome(S)): return '0' 21 | elif(isPseudoPalindrome(S)): return '1' 22 | return '2' 23 | 24 | if __name__ == '__main__': 25 | T = int(sys.stdin.readline()) 26 | 27 | for _ in range(T): 28 | S = sys.stdin.readline().strip() 29 | sys.stdout.write(palindrome(S) + '\n') -------------------------------------------------------------------------------- /src/Do-ho/greedy/boj_1946_신입사원/boj_1946.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | T = int(sys.stdin.readline()) 4 | 5 | for _ in range(T): 6 | employees = [] 7 | N = int(sys.stdin.readline()) 8 | for _ in range(N): 9 | employees.append(list(map(int, sys.stdin.readline().split()))) 10 | employees.sort() 11 | 12 | testEmployee = employees[0] 13 | count = 1 14 | for employee in employees: 15 | if testEmployee[1] > employee[1]: 16 | count += 1 17 | testEmployee = employee 18 | print(count) -------------------------------------------------------------------------------- /src/Do-ho/implementation/boj_1254_팰린드롬만들기/README.md: -------------------------------------------------------------------------------- 1 | # 팰린드롬 만들기 2 | 3 | 팰린드롬 만들기 4 | 5 | 뒤부터 최대의 팰린드롬을 찾고 그 나머지 length를 더한다. 6 | 7 | === 8 | 9 | 뒤부터 최대의 팰린드롬을 찾고 그 길이를 2배한 거에서 뺀다. -------------------------------------------------------------------------------- /src/Do-ho/implementation/boj_1254_팰린드롬만들기/boj_1254.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def palindrome(S): 4 | return S == S[::-1] 5 | 6 | S = sys.stdin.readline().strip() 7 | S_reverse = S[::-1] 8 | 9 | max_palindrome = 0 10 | for i in range(len(S_reverse)): 11 | checkString = S_reverse[0:i+1] 12 | if palindrome(checkString): max_palindrome = len(checkString) 13 | 14 | print(len(S)*2 - max_palindrome) -------------------------------------------------------------------------------- /src/Do-ho/implementation/boj_12731_열차시간표small/README.md: -------------------------------------------------------------------------------- 1 | # 열차 시간표(Small) 2 | 3 | test case 4 | 5 | ``` 6 | 1 7 | 0 8 | 2 2 9 | 10:30 11:00 10 | 12:00 13:00 11 | 11:00 12:00 12 | 09:00 10:30 13 | ``` 14 | ``` 0, 1 ``` 15 | 16 | A와 B를 시간 순으로 정렬하고 제일 앞 기차를 출발 시켜서 17 | 계속적으로 검사해나감 -------------------------------------------------------------------------------- /src/Do-ho/implementation/boj_12731_열차시간표small/boj_12731.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from datetime import datetime, timedelta 3 | 4 | def trainInput(n, result, alpha): 5 | for _ in range(n): 6 | [inputStartTime, inputEndTime] = list(sys.stdin.readline().strip().split()) 7 | startTime = list(map(int, inputStartTime.split(':'))) 8 | endTime = list(map(int, inputEndTime.split(':'))) 9 | 10 | start = datetime(2020, 11, 14, startTime[0], startTime[1]) 11 | end = datetime(2020, 11, 14, endTime[0], endTime[1]) 12 | 13 | result.append([start, end, alpha, True]) 14 | 15 | def trainsInput(NA, NB): 16 | result = [] 17 | trainInput(NA, result, 'A') 18 | trainInput(NB, result, 'B') 19 | 20 | result.sort() 21 | return result 22 | 23 | def getStartTrains(L, T): 24 | S = {"A": 0, "B": 0} 25 | Ttime = timedelta(minutes=T) 26 | 27 | for i, trainTime in enumerate(L): 28 | if not trainTime[3]: continue 29 | trainTime[3] = False 30 | S[trainTime[2]] += 1 31 | 32 | checkTime = trainTime[1] + Ttime 33 | checkStation = trainTime[2] 34 | 35 | for j in range(i+1, len(L)): 36 | if L[j][3] and checkTime <= L[j][0] and checkStation != L[j][2]: 37 | L[j][3] = False 38 | checkTime = L[j][1] + Ttime 39 | checkStation = L[j][2] 40 | 41 | return [S["A"], S["B"]] 42 | 43 | def case(caseID): 44 | T = int(sys.stdin.readline()) 45 | [NA, NB] = list(map(int, sys.stdin.readline().strip().split())) 46 | L = trainsInput(NA, NB) 47 | [SA, SB] = getStartTrains(L, T) 48 | 49 | sys.stdout.write("Case #" + str(caseID) +": " + str(SA) + " " + str(SB) + "\n") 50 | 51 | 52 | # 테스트 케이스 개수 N 53 | N = int(sys.stdin.readline()) 54 | 55 | for i in range(1, N+1): 56 | case(i) -------------------------------------------------------------------------------- /src/Do-ho/implementation/pgs_가장긴팰린드롬/pgs_palindrome.js: -------------------------------------------------------------------------------- 1 | const getOddPalindromeLength = (s, idx) => { return loopPalindrome(s, idx-1, idx+1, 1); } 2 | const getEvenPalindromeLength = (s, idx) => { 3 | if(s[idx] != s[idx+1]) return 0; 4 | return loopPalindrome(s, idx-1, idx+2, 2); 5 | } 6 | 7 | const loopPalindrome = (s, left, right, palindromeCount) => { 8 | while(left >= 0 && right < s.length) { 9 | if(s[left--] !== s[right++]) break; 10 | palindromeCount += 2 11 | } 12 | return palindromeCount; 13 | } 14 | 15 | const solution = s => { 16 | let answer = 0; 17 | for (let i=0; i { 2 | let [people, order] = [0, 0]; 3 | let prevText = null; 4 | let wordSet = []; 5 | const isNotPrevTextNull = () => prevText !== null; 6 | const isNotMatchWord = (word) => prevText[prevText.length - 1] !== word[0]; 7 | const isContainWordSet = (word) => wordSet.includes(word); 8 | 9 | for (let i=0; i { 25 | for(let i=0; i { 36 | let answer = 0; 37 | let basket = new CraneStack(); 38 | 39 | moves.forEach((item) => { 40 | const doll = pickDoll(board, item-1); 41 | if(doll!==0) answer += basket.pushAndGetResult(doll); 42 | }) 43 | 44 | return answer; 45 | } -------------------------------------------------------------------------------- /src/Do-ho/implementation/pgs_튜플/pgs_tuple.js: -------------------------------------------------------------------------------- 1 | const removeBracket = s => { 2 | const re = /[0-9]+(,[0-9]+)*/g; 3 | return s.match(re); 4 | } 5 | 6 | const compareFunction = (prev, curr) => prev.length - curr.length; 7 | 8 | const parseStr = s => { 9 | const strWithOutBracket = removeBracket(s); 10 | const parsed = strWithOutBracket.reduce((acc, cur) => { 11 | acc.push(cur.split(',')); 12 | return acc; 13 | }, []) 14 | return parsed.sort(compareFunction); 15 | } 16 | 17 | const solution = s => { 18 | const parsedArr = parseStr(s); 19 | const answer = parsedArr.reduce((acc, cur) => { 20 | const filterItem = cur.filter((item) => !acc.includes(item)); 21 | acc.push(filterItem[0]); 22 | return acc; 23 | }, []).map(item => parseInt(item)) 24 | return answer; 25 | } -------------------------------------------------------------------------------- /src/Do-ho/string/boj_1316/README.md: -------------------------------------------------------------------------------- 1 | # 그룹 단어 체커 2 | 3 | - 문제를 잘 보니까 이미 나왔던 문자가 다시 나오면 안됨 4 | - 그래서 맵에 해당 키와 값을 넣고 True/False로 체크 -------------------------------------------------------------------------------- /src/Do-ho/string/boj_1316/boj_1316.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | N = int(sys.stdin.readline()) 4 | 5 | def checkString(string): 6 | check_arr = {} 7 | prev_char = string[0] 8 | 9 | for ch in string: 10 | try: 11 | if not check_arr[ch]: return False 12 | except: 13 | check_arr[ch] = True 14 | check_arr[prev_char] = False 15 | check_arr[ch] = True 16 | prev_char = ch 17 | 18 | return True 19 | 20 | result = 0 21 | 22 | for i in range(N): 23 | string = sys.stdin.readline().replace('\n', '') 24 | if checkString(string): result += 1 25 | 26 | print(result) -------------------------------------------------------------------------------- /src/Do-ho/string/pgs_문자열압축/README.md: -------------------------------------------------------------------------------- 1 | # 문자열 압축 2 | 3 | 1. 아이디어 4 | 5 | ```python 6 | for 1글자부터 전체 길이의 반까지 돌림: 7 | prev_str = 첫 글자 선언 8 | count = 1 9 | lastcount = 0 10 | 11 | for 글자 길이 단위로 움직임: 12 | target_str = 타겟 글자 선언 13 | 14 | if 앞 뒤 글자가 같다면: 15 | count += 1 16 | if 마지막 검사라면: 17 | lastcount = len(str(count)) + 글자 길이 18 | elif count가 1이라면: 19 | lastcount = 글자 길이 20 | else: 21 | # count가 2이상인데 마지막이 아닌 경우 이므로 22 | lastcount = len(str(count)) + 글자 길이 23 | 24 | ``` 25 | 26 | 27 | 28 | - 1차 시도 실패... 29 | 30 | ``` 31 | def solution(s): 32 | answer = 1000 33 | length = int(len(s) / 2) + 1 34 | 35 | for i in range(1, length): 36 | prev_str = s[0:i] 37 | count = 1 38 | lastcount = 0 39 | prev_j = 0 40 | for j in range(i, len(s)-i+1 ,i): 41 | target_str = s[j:(j+i)] 42 | print(j) 43 | print(target_str) 44 | if prev_str == target_str: 45 | count+= 1 46 | if count!=1 and j+i+i>=len(s)-i: 47 | lastcount += len(str(count)) + i 48 | 49 | elif count==1: lastcount += i 50 | else: 51 | lastcount += len(str(count)) + i 52 | count = 1 53 | prev_str = target_str 54 | prev_j = j 55 | # print(lastcount) 56 | # print(prev_j) 57 | if(prev_j != len(s)-i): 58 | print('ggggggg') 59 | lastcount += len(s)-prev_j 60 | # print(prev_j, lastcount) 61 | if lastcount < answer: answer = lastcount 62 | 63 | return answer 64 | ``` 65 | 66 | -------------------------------------------------------------------------------- /src/Do-ho/string/pgs_문자열압축/source.py: -------------------------------------------------------------------------------- 1 | def solution(s): 2 | answer = 1000 3 | length = int(len(s) / 2) + 1 4 | 5 | for i in range(1, length): 6 | arr = [] 7 | for j in range(0, len(s)-i+1 ,i): 8 | arr.append(s[j:(j+i)]) 9 | 10 | # 아이템 중복 검사 11 | prev_item = arr[0] 12 | count = 0 13 | addcount = 0 14 | for idx, item in enumerate(arr): 15 | if prev_item == item: 16 | print(prev_item, item) 17 | count += 1 18 | if(idx==len(arr)-1): 19 | addcount += len(str(count)) + i 20 | elif count==1: 21 | addcount += i 22 | print(prev_item, item) 23 | else: 24 | print(prev_item, item) 25 | addcount += len(str(count)) + i 26 | count = 1 27 | prev_item = item 28 | 29 | print(i, addcount) 30 | # 스트링 끝까지 검사 안했을 때 31 | if(len(arr)*i!=len(s)): 32 | addcount += len(s) - (len(arr)*i) 33 | print(i, addcount) 34 | 35 | if addcount < answer: answer = addcount 36 | return answer -------------------------------------------------------------------------------- /src/Do-ho/week1.md: -------------------------------------------------------------------------------- 1 | # :fire: Week1 2 | 3 | ## :question: 백준 1158번 문제 (요세푸스 순열) 4 | - 처음 풀었던 방식 5 | ```python 6 | a, b = map(int, input().split()) 7 | 8 | linked_list = [] 9 | queue = [] 10 | count = 1 11 | idx = 0 12 | 13 | for i in range(a): 14 | linked_list.append(str(i+1)) 15 | 16 | while(len(linked_list)!=0): 17 | if(count==b): 18 | queue.append(linked_list[idx]) 19 | linked_list.remove(linked_list[idx]) 20 | count = 1 21 | else: 22 | count += 1 23 | idx = (idx + 1)%len(linked_list) 24 | 25 | print('<'+', '.join(queue)+'>') 26 | ``` 27 | 28 | - 시간초과.... 29 | - 따라서 카운트를 하나씩 올리는 것이 아닌 바로 올려서 검사해도 된다고 생각했음 30 | 31 | - 두 번째 풀었던 방식 32 | 33 | ```python 34 | N, K = map(int, input().split()) 35 | 36 | numArr = [] 37 | queue = [] 38 | idx = 0 39 | 40 | for i in range(N): 41 | numArr.append(str(i+1)) 42 | 43 | while(len(numArr)!=0): 44 | idx = (idx + (K-1)) % len(numArr) 45 | popData = numArr.pop(idx) 46 | queue.append(popData) 47 | 48 | print('<'+', '.join(queue)+'>') 49 | ``` 50 | 51 | 52 | 53 | ## :question: 백준 1406번 문제 (에디터) 54 | 55 | - 커맨드에 따라서 함수를 나눠 구현해야 할 것 같다. 56 | - 복잡도에 대한 부분을 개선하면 런타임 에러가 발생하지 않지 않을까... 57 | - 아니면 hidden case가 있을까...? -------------------------------------------------------------------------------- /src/do02reen24/.gitignore: -------------------------------------------------------------------------------- 1 | 코딩테스트 2 | .vscode -------------------------------------------------------------------------------- /src/do02reen24/BFS/baekjoon_1697.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | const int MAX_RANGE = 2000000; 5 | bool visit[MAX_RANGE + 1]; 6 | int cost[MAX_RANGE + 1]; 7 | int main() { 8 | int n, k; 9 | cin >> n >> k; 10 | queue q; 11 | cost[n] = 0; 12 | visit[n] = true; 13 | q.push(n); 14 | while (!q.empty()) { 15 | int index = q.front(); 16 | q.pop(); 17 | if (index - 1 >= 0) { 18 | if (visit[index - 1] == false) { 19 | q.push(index - 1); 20 | visit[index - 1] = true; 21 | cost[index - 1] = cost[index] + 1; 22 | } 23 | } 24 | if (index + 1 < MAX_RANGE) { 25 | if (visit[index + 1] == false) { 26 | q.push(index + 1); 27 | visit[index + 1] = true; 28 | cost[index + 1] = cost[index] + 1; 29 | } 30 | } 31 | if (index * 2 < MAX_RANGE) { 32 | if (visit[index * 2] == false) { 33 | q.push(index * 2); 34 | visit[index * 2] = true; 35 | cost[index * 2] = cost[index] + 1; 36 | } 37 | } 38 | if (visit[k] == true) { 39 | cout << cost[k] << '\n'; 40 | break; 41 | } 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/do02reen24/BFS/baekjoon_2178.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | dx = [0, 0, -1, 1] 4 | dy = [1, -1, 0, 0] 5 | 6 | n, m = map(int, sys.stdin.readline().split()) 7 | board = [] 8 | for _ in range(n): 9 | board.append(sys.stdin.readline().rstrip()) 10 | 11 | visited = [[-1 for _ in range(m)] for _ in range(n)] 12 | visited[0][0] = 1 13 | visit = [(0,0)] 14 | new_visit = [] 15 | while visit: 16 | x, y = visit.pop() 17 | for i in range(4): 18 | mx = x + dx[i] 19 | my = y + dy[i] 20 | if mx >= 0 and mx < n and my >=0 and my < m: 21 | if visited[mx][my] != -1 or board[mx][my] == "0": continue 22 | visited[mx][my] = visited[x][y] + 1 23 | new_visit.append((mx, my)) 24 | if not visit: 25 | visit = new_visit 26 | new_visit = [] 27 | 28 | print(visited[n-1][m-1]) -------------------------------------------------------------------------------- /src/do02reen24/BFS/baekjoon_2606.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | ans = 0 5 | n = int(sys.stdin.readline()) 6 | t = int(sys.stdin.readline()) 7 | network = {} 8 | for _ in range(t): 9 | n1, n2 = map(int, sys.stdin.readline().split()) 10 | if network.get(n1) == None: 11 | network[n1] = [] 12 | network[n1].append(n2) 13 | if network.get(n2) == None: 14 | network[n2] = [] 15 | network[n2].append(n1) 16 | visit = [False] * (n + 1) 17 | queue = [] 18 | queue.append(1) 19 | visit[1] = True 20 | while queue: 21 | index = queue.pop() 22 | check = network[index] 23 | while check: 24 | com = check.pop() 25 | if visit[com] == False: 26 | queue.append(com) 27 | visit[com] = True 28 | ans += 1 29 | print(ans) -------------------------------------------------------------------------------- /src/do02reen24/BFS/baekjoon_2644.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | n = int(sys.stdin.readline()) 4 | p1, p2 = map(lambda data: int(data)-1, sys.stdin.readline().split()) 5 | relation = [[] for _ in range(n)] 6 | m = int(sys.stdin.readline()) 7 | for _ in range(m): 8 | parent, children = map(lambda data: int(data)-1, sys.stdin.readline().split()) 9 | relation[parent].append(children) 10 | relation[children].append(parent) 11 | cost = [-1 for _ in range(n)] 12 | cost[p1] = 0 13 | count = 1 14 | queue = [p1] 15 | new_queue = [] 16 | while queue: 17 | person = queue.pop() 18 | for p in relation[person]: 19 | if cost[p] != -1: continue 20 | cost[p] = count 21 | new_queue.append(p) 22 | if not queue: 23 | queue = new_queue 24 | new_queue = [] 25 | count = count + 1 26 | print(cost[p2]) -------------------------------------------------------------------------------- /src/do02reen24/BFS/baekjoon_7569.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | dh = [-1, 1, 0, 0, 0, 0] 4 | dr = [0, 0, -1, 1, 0, 0] 5 | dc = [0, 0, 0, 0, -1, 1] 6 | 7 | def getDays(): 8 | n, m, k = map(int, sys.stdin.readline().split()) 9 | ans = 0 10 | boxes = [] 11 | remain = 0 12 | tomatoes = [] 13 | for height in range(0, k): 14 | box = [] 15 | for row in range(0, m): 16 | t = list(map(int, sys.stdin.readline().split())) 17 | box.append(t) 18 | for col in range(0, len(t)): 19 | if t[col] == 0: 20 | remain += 1 21 | elif t[col] == 1: 22 | tomatoes.append((height, row, col)) 23 | boxes.append(box) 24 | if remain == 0: 25 | return 0 26 | if not tomatoes: 27 | return -1 28 | newTomatoes = [] 29 | while tomatoes: 30 | h, r, c = tomatoes.pop() 31 | for i in range(0, 6): 32 | mh = h + dh[i] 33 | mr = r + dr[i] 34 | mc = c + dc[i] 35 | if mh >=0 and mh < k and mr >=0 and mr < m and mc >=0 and mc < n: 36 | if boxes[mh][mr][mc] == 0: 37 | boxes[mh][mr][mc] = 1 38 | remain -= 1 39 | newTomatoes.append((mh, mr, mc)) 40 | if not tomatoes and newTomatoes: 41 | tomatoes = newTomatoes 42 | newTomatoes = [] 43 | ans += 1 44 | if remain > 0: 45 | return -1 46 | return ans 47 | if __name__ == '__main__': 48 | print(getDays()) -------------------------------------------------------------------------------- /src/do02reen24/BFS/programmers_43162.js: -------------------------------------------------------------------------------- 1 | const solution = (n, computers) => { 2 | let answer = 0; 3 | const network = Array.from({ length: n }, () => 0); 4 | 5 | for (let i = 0; i < n; i += 1) { 6 | if (network[i] !== 0) continue; 7 | answer += 1; 8 | network[i] = answer; 9 | 10 | const queue = [i]; 11 | while (queue.length > 0) { 12 | const visit = queue.pop(); 13 | computers[visit].forEach((computer, index) => { 14 | if (computer && network[index] === 0) { 15 | queue.push(index); 16 | network[index] = answer; 17 | } 18 | }); 19 | } 20 | } 21 | 22 | return answer; 23 | }; 24 | -------------------------------------------------------------------------------- /src/do02reen24/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boost-algorithm/ProblemSolve/80e3e05653ca7ff63cbd88e23604d0cceab632dd/src/do02reen24/README.md -------------------------------------------------------------------------------- /src/do02reen24/Review/unsolved.md: -------------------------------------------------------------------------------- 1 | # 📚 unsolved problem 2 | 3 | ## 📘 baekjoon 4 | 5 | - 이진 탐색 트리 (플래티넘5) [:link:](https://www.acmicpc.net/problem/2957) 6 | - 스타트 택시 (골드4) [:link:](https://www.acmicpc.net/problem/19238) 7 | - 달이 차오른다, 가자 (골드1) [:link:](https://www.acmicpc.net/problem/1194) 8 | - 평범한 배낭 (골드5) [:link:](https://www.acmicpc.net/problem/12865) 9 | 10 | ## 📗 programmers 11 | 12 | - 3차 자동완성 [:link:](https://programmers.co.kr/learn/courses/30/lessons/17685) 13 | -------------------------------------------------------------------------------- /src/do02reen24/Review/week10.md: -------------------------------------------------------------------------------- 1 | # :fire: week10 2 | 3 | 주제 : Dynamic programming 4 | 5 | ## :ballot_box_with_check: 백준 1010 6 | 7 | - 다리가 겹칠 수 없기 때문에 오른쪽 다리에서 k 개를 선택하고 차례로 이어주면 된다. python의 combination 을 직접 불러 길이를 계산하는 방법도 있었지만, factorial을 쓰는 것이 더 빠를 것 같아 factorial로 구현하였다. 8 | 9 | ## :ballot_box_with_check: 백준 2579 10 | 11 | - 마지막 칸에 도착하는 방법은 두가지가 있다. i-2, i-1, i번째 칸에 대해 oxo, xoo 로 선택하는 것이다. 12 | - 각 경우 중 더 큰 값을 선택하며 다음칸으로 넘어가도록 구현하였다. 13 | 14 | ## :ballot_box_with_check: 백준 1149 15 | 16 | - 문제가 dynamic-programming인 것을 고려하여 각 r, g, b에 대해 최소값을 누적하여 관리하는 리스트를 생성하여 해결하였다. 17 | -------------------------------------------------------------------------------- /src/do02reen24/Review/week11.md: -------------------------------------------------------------------------------- 1 | # :fire: week11 2 | 3 | ## :ballot_box_with_check: 백준 12731 4 | 5 | 첫 제출에서 컴파일 에러가 떴다. 6 | 7 | 알고리즘 스터디원님의 도움으로 백준에서 컴파일 에러시 어디서 에러가 났는지 알려준다는 것을 알게되었다. 8 | 9 | ![image](https://user-images.githubusercontent.com/50297117/99143310-c57ea900-269f-11eb-82f4-8eee2a33289e.png) 10 | 11 | is로 문자열을 비교해도 되는줄 알았는데 안됨을 알게 되었고 `==` 으로 고쳐 성공할 수 있었다. 12 | 13 | ## :ballot_box_with_check: 백준 1932 14 | 15 | - DB를 적용하여 쉽게 풀 수 있었다. 16 | 17 | ## :ballot_box_with_check: 백준 1254 18 | 19 | - 처음 11주차 때는 각 경우별로 고려해주는 코드를 짜다가 꼬여서 풀지 못했었다. 12주차의 회문문제를 풀고 팰린드롬 문제에 다시 도전하였다. 20 | - 회문 문제를 풀 때처럼 팰린드롬인지 체크해주는 함수를 구현하여 조건에 맞지 않으면 정답의 길이를 늘려주며 다시 검사를 진행하는 방식으로 구현하였다. 21 | -------------------------------------------------------------------------------- /src/do02reen24/Review/week12.md: -------------------------------------------------------------------------------- 1 | # :fire: week12 2 | 3 | ## :ballot_box_with_check: 백준 11399 4 | 5 | - 시간순으로 정렬하여 쉽게 풀 수 있었다. 6 | 7 | ## :ballot_box_with_check: 백준 17609 8 | 9 | 1. 우선 펠린드롬인지 확인한다. 10 | - 맞다면 0을 반환한다. 11 | - 아니라면 펠린드롬을 깨지게 만든 index를 반환하고 다음 단계로 넘어간다. 12 | 2. 왼쪽 단어(index)를 하나 삭제하여 펠린드롬인지 확인한다. 13 | - 맞다면 1을 반환한다. 14 | - 아니라면 다음 단계로 넘어간다. 15 | 3. 오른쪽 단어(length-index)를 하나 삭제하여 펠린드롬인지 확인한다. 16 | - 맞다면 1을 반환한다. 17 | - 아니라면 2를 반환한다. 18 | -------------------------------------------------------------------------------- /src/do02reen24/Review/week15.md: -------------------------------------------------------------------------------- 1 | # :fire: week15 2 | 3 | ## :ballot_box_with_check: 프로그래머스 위장(42578) 4 | 5 | - 조합의 개념을 사용하여 풀 수 있었다. 6 | - 해당 옷을 아예 고르지 않는 경우도 있으므로 각 아이템 길이에 + 1 을 해주었다. 7 | - 모든 옷을 안고르는 경우는 제외해야하므로 정답에서 - 1 을 해주었다. 8 | 9 | ## :ballot_box_with_check: 프로그래머스 영어 끝말잇기(12981) 10 | 11 | - 각 경우를 고려하여 처리해주었다. 12 | 13 | ## :ballot_box_with_check: 프로그래머스 네트워크(43162) 14 | 15 | - BFS의 개념을 활용하여 풀었다. 16 | - 백준 2644번 문제와 비슷한 것 같다. 17 | -------------------------------------------------------------------------------- /src/do02reen24/Review/week8.md: -------------------------------------------------------------------------------- 1 | # :fire: week8 2 | 3 | ## :ballot_box_with_check: 백준 1946 4 | 5 | - 문제 이해를 하는데 시간이 좀 오래 걸렸다. 6 | - 정렬을 이용하면 간단하게 풀 수 있다. 7 | 8 | ## :ballot_box_with_check: 백준 11047 9 | 10 | - python의 경우 pop을 하면 뒤부터 반환해주기 때문에 array를 통해 쉽게 풀 수 있었다. 11 | 12 | ## :ballot_box_with_check: 백준 11497 13 | 14 | - 연습하면서 썼던 print문을 안지워서 출력초과가 떴는데 print 출력을 더 유심히 보고 지울 필요가 있을 것 같다. 15 | 16 | ## :ballot_box_with_check: 백준 2504 17 | 18 | - 문제를 풀긴했으나 코드를 좀 더 깔끔하게 짤 수 없는지 다른 로직을 고민해본다면 더 좋을 것 같다. 19 | -------------------------------------------------------------------------------- /src/do02reen24/Review/week9.md: -------------------------------------------------------------------------------- 1 | # :fire: week9 2 | 3 | 주제 : Dynamic programming 4 | 5 | ## :ballot_box_with_check: 백준 9095 6 | 7 | - python으로 쉽게 풀 수 있었다. 이전에 작성했던 c++코드를 보니 아래와 같이 푸는 방법도 있었다. 8 | 9 | ```c++ 10 | #include 11 | int d[11]; 12 | int main() { 13 | d[0] = 1; 14 | for (int i=1; i<=10; i++) { 15 | if (i-1 >= 0) { 16 | d[i] += d[i-1]; 17 | } 18 | if (i-2 >= 0) { 19 | d[i] += d[i-2]; 20 | } 21 | if (i-3 >= 0) { 22 | d[i] += d[i-3]; 23 | } 24 | } 25 | int t; 26 | scanf("%d",&t); 27 | while (t--) { 28 | int n; 29 | scanf("%d",&n); 30 | printf("%d\n",d[n]); 31 | } 32 | } 33 | ``` 34 | 35 | ## :ballot_box_with_check: 백준 11727 36 | 37 | - 이전에 공부했던 내용을 찾아봐서 풀었다. 38 | - 컴퓨터의 나머지 연산: 컴퓨터의 정수는 저장할 수 있는 범위가 지정되어 있기 때문에 답을 M으로 나눈 나머지를 출력하라는 문제가 등장한다. 39 | - (A+B) mod M = ((A mod M) + (B mod M)) mod M 40 | - (AXB) mod M = ((A mod M) X (B mod M)) mod M 41 | - (A-B) mod M = ((A mod M) - (B mod M)) mod M 42 | - 나누기는 성립하지 않는다. 43 | 44 | ## :ballot_box_with_check: 백준 12865 45 | 46 | #### 시간초과 47 | 48 | ```python 49 | import sys 50 | 51 | def pickObject(index, sumW, sumV, isPick): 52 | global backpack, ans 53 | if index >= n: return 54 | if sumW > k: return 55 | if sumW <= k and sumV > ans: ans = sumV 56 | w = 0 57 | v = 0 58 | if isPick: 59 | w, v = backpack[index] 60 | pickObject(index + 1, sumW + w, sumV + v, True) 61 | pickObject(index + 1, sumW + w, sumV + v, False) 62 | 63 | n, k = map(int, sys.stdin.readline().split(' ')) 64 | ans = 0 65 | backpack = [] 66 | for _ in range(n): 67 | w, v = map(int, sys.stdin.readline().split(' ')) 68 | backpack.append((w, v)) 69 | 70 | pickObject(0, 0, 0, True) 71 | pickObject(0, 0, 0, False) 72 | 73 | print(ans) 74 | ``` 75 | 76 | - 재귀로 풀지 않고 논리적인 생각을 통해 앞의 결과 중 더 큰 것을 골라야함을 알았다. 77 | -------------------------------------------------------------------------------- /src/do02reen24/bit-masking/baekjoon_1094.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | x = int(sys.stdin.readline()) 5 | stick = [64] 6 | stick_sum = 64 7 | while not x == stick_sum: 8 | half_stick = int(stick.pop() / 2) 9 | stick.append(half_stick) 10 | stick_sum = sum(stick) 11 | if stick_sum < x: 12 | stick.append(half_stick) 13 | print(len(stick)) 14 | -------------------------------------------------------------------------------- /src/do02reen24/bit-masking/baekjoon_14889.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | const int MAX_INT = 20; 6 | int main() { 7 | int n; 8 | int ans = -1; 9 | vector order; 10 | int team[MAX_INT][MAX_INT]; 11 | cin >> n; 12 | 13 | for (int i = 0; i < n; i++) { 14 | for (int j = 0; j < n; j++) cin >> team[j][i]; 15 | if (i < (n / 2)) order.push_back(0); 16 | else order.push_back(1); 17 | } 18 | 19 | do { 20 | int start = 0; 21 | int link = 0; 22 | for (int i = 0; i < n; i++) { 23 | for (int j = 0; j < n; j++) { 24 | if (i == j) continue; 25 | if (order[i] == 0 && order[j] == 0) start += team[i][j] + team[j][i]; 26 | if(order[i] == 1 && order[j] == 1) link += team[i][j] + team[j][i]; 27 | } 28 | } 29 | int diff = abs(start - link) / 2; 30 | if (ans == -1 || ans > diff) ans = diff; 31 | } while (next_permutation(order.begin(), order.end())); 32 | 33 | cout << ans << endl; 34 | } -------------------------------------------------------------------------------- /src/do02reen24/bit-masking/baekjoon_18233.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, p, e; 8 | cin >> n >> p >> e; 9 | vector> member; 10 | vector isGift(n); 11 | for (int i = 0; i < n; i++) { 12 | int min, max; 13 | cin >> min >> max; 14 | member.push_back(make_pair(min, max)); 15 | if ((n - i) <= p) isGift[i] = 1; 16 | } 17 | do { 18 | int min = 0, max = 0; 19 | int sol[20] = { 0, }; 20 | for (int i = 0; i < n; i++) { 21 | if (isGift[i] == 0) continue; 22 | min += member[i].first; 23 | max += member[i].second; 24 | sol[i] = member[i].first; 25 | } 26 | int remain = e - min; 27 | if (min <= e && max >= e) { 28 | for (int i = 0; i < n; i++) { 29 | if (isGift[i] == 0) continue; 30 | int diff = member[i].second - member[i].first; 31 | if (diff < remain) { 32 | remain -= diff; 33 | sol[i] += diff; 34 | } 35 | else { 36 | sol[i] += remain; 37 | remain = 0; 38 | } 39 | } 40 | for (int i = 0; i < n; i++) cout << sol[i] << " "; 41 | return 0; 42 | } 43 | } while (next_permutation(isGift.begin(), isGift.end())); 44 | cout << -1 << endl; 45 | return 0; 46 | } -------------------------------------------------------------------------------- /src/do02reen24/brute-force/baekjoon_1254.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def isPalindrome(word, start, end): 4 | index = 0 5 | while end - index > start + index: 6 | if word[end-index] == word[start+index]: 7 | index = index + 1 8 | continue 9 | return False 10 | return True 11 | 12 | 13 | word = sys.stdin.readline().rstrip() 14 | ans = len(word) 15 | start, end = 0, len(word) - 1 16 | 17 | while True: 18 | if isPalindrome(word, start, end): break 19 | ans = ans + 1 20 | start = start + 1 21 | 22 | print(ans) 23 | -------------------------------------------------------------------------------- /src/do02reen24/brute-force/baekjoon_18233.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from itertools import combinations 3 | 4 | def rubberDuck(): 5 | n, p, e = map(int, sys.stdin.readline().rstrip().split()) 6 | member = [] 7 | for _ in range(n): 8 | minDuck, maxDuck = map(int, sys.stdin.readline().rstrip().split()) 9 | member.append([minDuck, (maxDuck-minDuck)]) 10 | user = [i for i in range(n)] 11 | combList = list(combinations(user, p)) 12 | 13 | for comb in combList: 14 | sol = [0] * n 15 | remain = e 16 | for i in comb: 17 | sol[i] = member[i][0] 18 | remain -= member[i][0] 19 | if remain < 0: continue 20 | for i in comb: 21 | if remain > member[i][1]: 22 | sol[i] += member[i][1] 23 | remain -= member[i][1] 24 | else: 25 | sol[i] += remain 26 | remain = 0 27 | break 28 | if remain == 0: 29 | return ' '.join(map(str,sol)) 30 | return -1 31 | print(rubberDuck()) 32 | -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_10799.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | brackets = sys.stdin.readline().rstrip() 5 | stack = [] 6 | result = 0 7 | for i in range(0, len(brackets)): 8 | if brackets[i] == '(' and brackets[i+1] == ')': 9 | if stack: 10 | stack[-1] += 1 11 | elif brackets[i] == '(': 12 | stack.append(0) 13 | elif not brackets[i-1] == '(': 14 | laser = stack.pop() 15 | result += laser + 1 16 | if stack: 17 | stack[-1] += laser 18 | print(result) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_11286.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import heapq 3 | 4 | if __name__ == '__main__': 5 | n = int(sys.stdin.readline()) 6 | absHeap = [] 7 | for i in range(n): 8 | command = int(sys.stdin.readline()) 9 | if command == 0: 10 | try: 11 | print(heapq.heappop(absHeap)[1]) 12 | except: 13 | print(0) 14 | else: 15 | heapq.heappush(absHeap, (abs(command), command)) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_1158.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | n, k = map(int, sys.stdin.readline().split()) 5 | permutation = list(range(1, n + 1)) 6 | answer = [] 7 | index = 0 8 | 9 | while len(permutation): 10 | index = (index + k - 1) % len(permutation) 11 | answer.append(permutation.pop(index)) 12 | print("<"+', '.join(map(str, answer))+">") -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_1406.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | stackLeft = list(sys.stdin.readline().rstrip()) 5 | stackRight = list() 6 | 7 | n = int(sys.stdin.readline().rstrip()) 8 | for i in range(0, n): 9 | command = list(sys.stdin.readline().split()) 10 | if command[0] == 'L' and stackLeft: 11 | stackRight.append(stackLeft.pop()) 12 | elif command[0] == 'D' and stackRight: 13 | stackLeft.append(stackRight.pop()) 14 | elif command[0] == 'B' and stackLeft: 15 | stackLeft.pop() 16 | elif command[0] == 'P': 17 | stackLeft.append(command[1]) 18 | 19 | print(''.join(stackLeft) + ''.join(list(reversed(stackRight)))) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_1874.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | t = int(sys.stdin.readline()) 5 | stack = [] 6 | count = 1 7 | result = [] 8 | for _ in range(t): 9 | n = int(sys.stdin.readline()) 10 | check = False 11 | while count <= t: 12 | if stack and stack[-1] == n: 13 | stack.pop() 14 | result.append('-') 15 | check = True 16 | break 17 | stack.append(count) 18 | result.append('+') 19 | count += 1 20 | if not check and stack: 21 | while stack: 22 | result.append('-') 23 | if n == stack.pop(): 24 | check = True 25 | break 26 | if not check: 27 | print('NO') 28 | sys.exit(0) 29 | for r in result: 30 | print(r) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_1991.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | class Node(object): 4 | def __init__(self, depth, left, right): 5 | self.depth = depth 6 | self.left = left 7 | self.right = right 8 | 9 | def preOrder(tree, index): 10 | if index != '.': 11 | node = tree[index] 12 | print(index, end='') 13 | preOrder(tree, node.left) 14 | preOrder(tree, node.right) 15 | return 16 | 17 | def inOrder(tree, index): 18 | if index != '.': 19 | node = tree[index] 20 | inOrder(tree, node.left) 21 | print(index, end='') 22 | inOrder(tree, node.right) 23 | return 24 | 25 | def postOrder(tree, index): 26 | if index != '.': 27 | node = tree[index] 28 | postOrder(tree, node.left) 29 | postOrder(tree, node.right) 30 | print(index, end='') 31 | return 32 | 33 | if __name__ == '__main__': 34 | n = int(sys.stdin.readline()) 35 | tree = None 36 | treeRoot = None 37 | 38 | for i in range(n): 39 | root, left, right = sys.stdin.readline().split() 40 | depth = 0 41 | if tree == None: 42 | tree = dict() 43 | treeRoot = root 44 | tree[root] = Node(depth, left, right) 45 | else: 46 | tree[root].left = left 47 | tree[root].right = right 48 | depth = tree[root].depth 49 | 50 | if not left=='.': 51 | tree[left] = Node(depth+1, '.', '.') 52 | if not right=='.': 53 | tree[right] = Node(depth+1, '.', '.') 54 | 55 | preOrder(tree, treeRoot) 56 | print() 57 | inOrder(tree, treeRoot) 58 | print() 59 | postOrder(tree, treeRoot) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_2346.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | n = int(sys.stdin.readline().rstrip()) 5 | inputs = list(map(int, sys.stdin.readline().split())) 6 | position = list(range(1, n+1)) 7 | balloons = [[inputs[i], position[i]] for i in range(0, n)] 8 | 9 | result = [] 10 | index = 0 11 | while True: 12 | b = balloons.pop(index) 13 | result.append(b[1]) 14 | length = len(balloons) 15 | if length == 0: 16 | break 17 | if b[0] > 0: 18 | index = (index + b[0] - 1) % length 19 | else: 20 | index = (index + b[0] + length) % length 21 | 22 | print(' '.join(map(str,result))) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_2504.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def isValidInput(inputs): 4 | stack = [] 5 | try: 6 | for char in inputs: 7 | if char == '(' or char == '[': 8 | stack.append(char) 9 | continue 10 | pre = stack.pop() 11 | if pre == '(' and char == ')':continue 12 | if pre == '[' and char == ']':continue 13 | return False 14 | except: return False 15 | if stack: return False 16 | return True 17 | if __name__ == "__main__": 18 | inputs = str(sys.stdin.readline().strip()) 19 | result = 0 20 | stack = [] 21 | if not isValidInput(inputs): 22 | print(0) 23 | sys.exit(0) 24 | for char in inputs: 25 | if char == '(' or char == '[': 26 | stack.append(char) 27 | continue 28 | preValue = stack.pop() 29 | if char == ']': 30 | if preValue == '[': 31 | stack.append(3) 32 | continue 33 | elif char == ')': 34 | if preValue == '(': 35 | stack.append(2) 36 | continue 37 | while True: 38 | lastValue = stack.pop() 39 | if lastValue == '(': 40 | stack.append(preValue * 2) 41 | break 42 | elif lastValue == '[': 43 | stack.append(preValue * 3) 44 | break 45 | else: 46 | preValue += lastValue 47 | print(sum(stack)) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/baekjoon_9012.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | n = int(sys.stdin.readline()) 5 | for _ in range(n): 6 | brackets = sys.stdin.readline().rstrip() 7 | result = 'YES' 8 | stack = [] 9 | for bracket in brackets: 10 | if bracket == '(': 11 | stack.append('(') 12 | else: 13 | try: 14 | stack.pop() 15 | except: 16 | result = 'NO' 17 | break 18 | if stack: 19 | result = 'NO' 20 | print(result) -------------------------------------------------------------------------------- /src/do02reen24/data-structure/programmers_42578.py: -------------------------------------------------------------------------------- 1 | def solution(clothes): 2 | answer = 1 3 | clothesMap = dict() 4 | for c in clothes: 5 | if clothesMap.get(c[1]) == None: 6 | clothesMap[c[1]] = [] 7 | clothesMap[c[1]].append(c[0]) 8 | 9 | for value in clothesMap.values(): 10 | answer *= (len(value) + 1) 11 | 12 | answer -= 1 13 | return answer -------------------------------------------------------------------------------- /src/do02reen24/divide-and-conquer/baekjoon_1780.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | board = [] 4 | 5 | minus = 0 6 | zero = 0 7 | plus = 0 8 | 9 | def checkBoard(startRow, endRow, startCol, endCol): 10 | check = board[startRow][startCol] 11 | for r in range(startRow, endRow): 12 | for c in range(startCol, endCol): 13 | if not check == board[r][c]: return False 14 | global minus 15 | global zero 16 | global plus 17 | if check == -1: minus += 1 18 | elif check == 0: zero += 1 19 | elif check == 1: plus += 1 20 | return True 21 | 22 | def makeRange(n): 23 | return[[0,0],[0,n],[0,2*n],[n,0],[n,n],[n,2*n],[2*n,0],[2*n,n],[2*n,2*n]] 24 | 25 | def compress(n, startRow, startCol): 26 | n = int(n / 3) 27 | ranges = makeRange(n) 28 | for r, c in ranges: 29 | if not checkBoard(startRow + r, startRow + r + n, startCol + c, startCol + c + n): compress(n, startRow + r, startCol + c) 30 | 31 | def findSolution(n): 32 | if checkBoard(0, n, 0, n): return 33 | compress(n, 0, 0) 34 | 35 | if __name__ == '__main__': 36 | n = int(sys.stdin.readline()) 37 | for _ in range(0, n): 38 | inputs = list(map(int, sys.stdin.readline().split(' '))) 39 | board.append(inputs) 40 | findSolution(n) 41 | print(minus) 42 | print(zero) 43 | print(plus) -------------------------------------------------------------------------------- /src/do02reen24/divide-and-conquer/baekjoon_1992.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | board = [] 4 | 5 | def checkBoard(startRow, endRow, startCol, endCol): 6 | check = board[startRow][startCol] 7 | for r in range(startRow, endRow): 8 | for c in range(startCol, endCol): 9 | if not check == board[r][c]: return False 10 | return True 11 | 12 | def compress(n, startRow, startCol): 13 | n = int(n / 2) 14 | ans = [] 15 | if checkBoard(startRow, startRow + n, startCol, startCol + n): 16 | ans.append(board[startRow][startCol]) 17 | else: 18 | ans.append(compress(n, startRow, startCol)) 19 | if checkBoard(startRow, startRow + n, startCol + n, startCol + n + n): 20 | ans.append(board[startRow][startCol + n]) 21 | else: 22 | ans.append(compress(n, startRow, startCol + n)) 23 | if checkBoard(startRow + n, startRow + n + n, startCol, startCol + n): 24 | ans.append(board[startRow + n][startCol]) 25 | else: 26 | ans.append(compress(n, startRow + n, startCol)) 27 | if checkBoard(startRow + n, startRow + n + n, startCol + n, startCol + n + n): 28 | ans.append(board[startRow + n][startCol + n]) 29 | else: 30 | ans.append(compress(n, startRow + n, startCol + n)) 31 | return '(' + ''.join(ans) + ')' 32 | 33 | def findSolution(N): 34 | if checkBoard(0, N, 0, N): 35 | return board[0][0] 36 | ans = compress(N, 0, 0) 37 | return ans 38 | 39 | if __name__ == '__main__': 40 | N = int(sys.stdin.readline()) 41 | for i in range(N): 42 | inputs = list(sys.stdin.readline().rstrip()) 43 | board.append(inputs) 44 | print(findSolution(N)) -------------------------------------------------------------------------------- /src/do02reen24/divide-and-conquer/baekjoon_2630.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | board = [] 4 | blue = 0 5 | white = 0 6 | 7 | def checkBoard(startRow, endRow, startCol, endCol): 8 | check = board[startRow][startCol] 9 | for r in range(startRow, endRow): 10 | for c in range(startCol, endCol): 11 | if not check == board[r][c] : return False 12 | global blue 13 | global white 14 | if check == 1: blue = blue + 1 15 | elif check == 0: white = white + 1 16 | return True 17 | 18 | def compress(n, startRow, startCol): 19 | n = int(n / 2) 20 | if not checkBoard(startRow, startRow + n, startCol, startCol + n): 21 | compress(n, startRow, startCol) 22 | if not checkBoard(startRow, startRow + n, startCol + n, startCol + n + n): 23 | compress(n, startRow, startCol + n) 24 | if not checkBoard(startRow + n, startRow + n + n, startCol, startCol + n): 25 | compress(n, startRow + n, startCol) 26 | if not checkBoard(startRow + n, startRow + n + n, startCol + n, startCol + n + n): 27 | compress(n, startRow + n, startCol + n) 28 | 29 | def findSolution(N): 30 | if checkBoard(0, N, 0, N): return 31 | compress(N, 0, 0) 32 | 33 | if __name__ == '__main__': 34 | N = int(sys.stdin.readline().rstrip()) 35 | for _ in range(N): 36 | inputs = list(map(int, sys.stdin.readline().split(' '))) 37 | board.append(inputs) 38 | findSolution(N) 39 | print(white) 40 | print(blue) -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_1010.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from math import factorial 3 | 4 | def combination(n, c): 5 | return int(factorial(n) / (factorial(n-c) * factorial(c))) 6 | 7 | if __name__ == "__main__": 8 | t = int(sys.stdin.readline()) 9 | for _ in range(t): 10 | n, m = map(int, sys.stdin.readline().split(' ')) 11 | ans = combination(m,n) 12 | print(ans) 13 | -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_1149.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | n = int(sys.stdin.readline()) 4 | RGB = [] 5 | for _ in range(n): 6 | r, g, b = map(int, sys.stdin.readline().split()) 7 | RGB.append((r, g, b)) 8 | 9 | r_cost, g_cost, b_cost = [0], [0], [0] 10 | 11 | for i in range(0, n): 12 | r, g, b = RGB[i] 13 | r_cost.append(r + min(g_cost[i], b_cost[i])) 14 | g_cost.append(g + min(r_cost[i], b_cost[i])) 15 | b_cost.append(b + min(r_cost[i], g_cost[i])) 16 | 17 | print(min(r_cost[n],g_cost[n],b_cost[n])) 18 | -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_11727.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == "__main__": 4 | n = int(sys.stdin.readline()) 5 | res = [1 , 1] 6 | for i in range(2, n + 1): 7 | res.append(res[i-1] + res[i-2] + res[i-2]) 8 | res[i] = int(res[i] % 10007) 9 | print(res[n]) -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_1932.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == "__main__": 4 | n = int(sys.stdin.readline()) 5 | triangle = [] 6 | best = [] 7 | for i in range(n): 8 | triangle.append(list(map(int, sys.stdin.readline().rstrip().split(' ')))) 9 | best.append([0] * (i+1)) 10 | best[0][0] = triangle[0][0] 11 | for i in range(1, n): 12 | best[i][0] = triangle[i][0] + best[i-1][0] 13 | for k in range(1, i): 14 | best[i][k] = triangle[i][k] + max(best[i-1][k-1], best[i-1][k]) 15 | best[i][i] = triangle[i][i] + best[i-1][i-1] 16 | print(max(best[n-1])) 17 | -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_2011.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def decodeNum(): 4 | word = sys.stdin.readline().rstrip() 5 | length = len(word) 6 | if word[0] == '0': return 0 7 | sol = [1] * (length + 1) 8 | for i in range(1, length): 9 | prev = int(word[i-1]+word[i]) 10 | now = int(word[i]) 11 | if prev == 10 or prev == 20: 12 | sol[i+1] = sol[i-1] 13 | elif 11 <= prev and prev <= 26: 14 | sol[i+1] = (sol[i] + sol[i-1]) % 1000000 15 | elif 1 <= now and now <= 9: 16 | sol[i+1] = sol[i] 17 | else: return 0 18 | return sol[length] 19 | 20 | print(int(decodeNum())) 21 | -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_2502.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def fibonacci(x): 4 | if x < 2: return 1 5 | if data[x] != 0: return data[x] 6 | else: 7 | data[x] = fibonacci(x-1) + fibonacci(x-2) 8 | return data[x] 9 | 10 | d, k = map(int, sys.stdin.readline().split()) 11 | data = [0] * d 12 | 13 | f1 = fibonacci(d-3) 14 | f2 = fibonacci(d-2) 15 | for a in range(1, int(k/2) + 1): 16 | sub = k - (f1 * a) 17 | b = int(sub/f2) 18 | if (f1 * a) + (f2 * b) == k: 19 | print(a) 20 | print(b) 21 | break -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_2579.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def sol(): 4 | n = int(sys.stdin.readline()) 5 | score = [] 6 | for _ in range(n): 7 | score.append(int(sys.stdin.readline())) 8 | 9 | if n <= 2: return sum(score) 10 | 11 | scoreSum = [score[0], score[0]+score[1], max(score[0],score[1])+score[2]] 12 | for i in range(3, n): 13 | scoreSum.append(score[i]+max(score[i-1]+scoreSum[i-3], scoreSum[i-2])) 14 | return scoreSum.pop() 15 | 16 | print(sol()) -------------------------------------------------------------------------------- /src/do02reen24/dynamic-programming/baekjoon_9059.py: -------------------------------------------------------------------------------- 1 | import sys 2 | sys.setrecursionlimit(300000) 3 | 4 | def findSum(count, n): 5 | ans = 0 6 | for i in range(1, 4): 7 | if count == n: 8 | ans += 1 9 | break 10 | elif count > n: 11 | return 0 12 | ans += findSum(count + i, n) 13 | return ans 14 | 15 | if __name__ == "__main__": 16 | t = int(sys.stdin.readline()) 17 | for _ in range(t): 18 | n = int(sys.stdin.readline()) 19 | print(findSum(0, n)) -------------------------------------------------------------------------------- /src/do02reen24/etc/baekjoon_12731.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def getIntTime(time): 4 | h = int(time[0:2]) * 60 5 | m = int(time[3:5]) 6 | return h + m 7 | 8 | def changeInt(start, end, time): 9 | return [getIntTime(start), getIntTime(end) + time] 10 | 11 | if __name__ == "__main__": 12 | t = int(sys.stdin.readline()) 13 | for i in range(t): 14 | time = int(sys.stdin.readline()) 15 | na, nb = map(int, sys.stdin.readline().split(' ')) 16 | a_list, b_list = [], [] 17 | for _ in range(na): 18 | start , end = map(str, sys.stdin.readline().rstrip().split(' ')) 19 | a_list.append(changeInt(start, end, time)) 20 | for _ in range(nb): 21 | start , end = map(str, sys.stdin.readline().rstrip().split(' ')) 22 | b_list.append(changeInt(start, end, time)) 23 | a_list.sort() 24 | b_list.sort() 25 | 26 | sol_A, sol_B = 0, 0 27 | a_train, b_train = [], [] 28 | 29 | while True: 30 | train_type = None 31 | train = None 32 | if a_list and b_list: 33 | if a_list[0] < b_list[0]: train_type = 'a' 34 | else: train_type = 'b' 35 | elif a_list: train_type = 'a' 36 | elif b_list: train_type = 'b' 37 | else: break 38 | 39 | if train_type == 'a': 40 | start, end = a_list.pop(0) 41 | if a_train and a_train[0] <= start: 42 | a_train.pop(0) 43 | else: sol_A += 1 44 | b_train.append(end) 45 | b_train.sort() 46 | if train_type == 'b': 47 | start, end = b_list.pop(0) 48 | if b_train and b_train[0] <= start: 49 | b_train.pop(0) 50 | else: sol_B += 1 51 | a_train.append(end) 52 | a_train.sort() 53 | 54 | print("Case #"+str(i+1)+":",sol_A,sol_B) -------------------------------------------------------------------------------- /src/do02reen24/etc/programmers_12981.js: -------------------------------------------------------------------------------- 1 | const failUser = (n, index) => { 2 | let person = index % n; 3 | let order = Math.floor(index / n) + 1; 4 | if (person === 0) { 5 | person = n; 6 | order -= 1; 7 | } 8 | return [person, order]; 9 | }; 10 | 11 | const getLastChar = (word) => word.charAt(word.length - 1); 12 | 13 | const solution = (n, words) => { 14 | const dictionary = {}; 15 | let lastChar = words[0][0]; 16 | for (let index = 0; index < words.length; index += 1) { 17 | const word = words[index]; 18 | if (lastChar === word[0] && dictionary[word] === undefined) { 19 | dictionary[word] = true; 20 | lastChar = getLastChar(word); 21 | continue; 22 | } 23 | return failUser(n, index + 1); 24 | } 25 | 26 | return [0, 0]; 27 | }; 28 | -------------------------------------------------------------------------------- /src/do02reen24/etc/programmers_42578.js: -------------------------------------------------------------------------------- 1 | const getCombinationNumber = (object) => { 2 | let combination = 1; 3 | for (const key in object) { 4 | const itemLength = object[key].length + 1; 5 | combination *= itemLength; 6 | } 7 | return combination; 8 | }; 9 | 10 | const solution = (clothes) => { 11 | const closet = {}; 12 | clothes.forEach(([cloth, clothType]) => { 13 | closet[clothType] 14 | ? closet[clothType].push(cloth) 15 | : (closet[clothType] = [cloth]); 16 | }); 17 | 18 | return getCombinationNumber(closet) - 1; 19 | }; 20 | -------------------------------------------------------------------------------- /src/do02reen24/greedy/baekjoon_11047.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == "__main__": 4 | n, k = map(int, sys.stdin.readline().split(' ')) 5 | coin = [] 6 | ans = 0 7 | for _ in range(n): 8 | coin.append(int(sys.stdin.readline())) 9 | while coin: 10 | money = coin.pop() 11 | quotient = int(k / money) 12 | k -= quotient * money 13 | ans += quotient 14 | print(ans) -------------------------------------------------------------------------------- /src/do02reen24/greedy/baekjoon_11399.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | n = int(sys.stdin.readline()) 4 | p = list(map(int, sys.stdin.readline().split())) 5 | p.sort() 6 | 7 | ans = 0 8 | waitSum = 0 9 | 10 | for num in p: 11 | waitSum = waitSum + num 12 | ans = ans + waitSum 13 | print(ans) 14 | -------------------------------------------------------------------------------- /src/do02reen24/greedy/baekjoon_11497.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == "__main__": 4 | T = int(sys.stdin.readline()) 5 | for _ in range(T): 6 | n = int(sys.stdin.readline()) 7 | log = list(map(int, sys.stdin.readline().split(' '))) 8 | log.sort() 9 | level = log[1] - log[0] 10 | lastLevel = log[n-1] - log[n-2] 11 | if lastLevel > level: level = lastLevel 12 | for i in range(0, n - 2): 13 | tempLevel = log[i+2] - log[i] 14 | if tempLevel > level: level = tempLevel 15 | print(level) -------------------------------------------------------------------------------- /src/do02reen24/greedy/baekjoon_17609.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def getPalindrome(word, length): 4 | index = 0 5 | while length - index > index: 6 | if word[index] == word[length - index]: 7 | index = index + 1 8 | continue 9 | return index 10 | return -1 11 | 12 | def isPalindrome(word, length): 13 | index = getPalindrome(word, length) 14 | if index == -1: return 0 15 | 16 | deleteLeft = word[:index] + word[index+1:] 17 | if getPalindrome(deleteLeft, len(deleteLeft) - 1) == -1: return 1 18 | 19 | deleteRight = word[:length - index] + word[length - index+1:] 20 | if getPalindrome(deleteRight, len(deleteRight) - 1) == -1: return 1 21 | 22 | return 2 23 | 24 | n = int(sys.stdin.readline()) 25 | for _ in range(n): 26 | word = sys.stdin.readline().rstrip() 27 | print(isPalindrome(word, len(word) - 1)) 28 | -------------------------------------------------------------------------------- /src/do02reen24/greedy/baekjoon_1946.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == "__main__": 4 | T = int(sys.stdin.readline()) 5 | for _ in range(T): 6 | n = int(sys.stdin.readline()) 7 | applicant = [] 8 | for i in range(n): 9 | rankA, rankB = map(int, sys.stdin.readline().split(' ')) 10 | applicant.append([rankA, rankB]) 11 | applicant.sort(key = lambda rank: rank[0]) 12 | 13 | minB = applicant[0][1] 14 | ans = 0 15 | for rankA, rankB in applicant: 16 | if rankB <= minB: 17 | minB = rankB 18 | ans += 1 19 | print(ans) -------------------------------------------------------------------------------- /src/do02reen24/simulation/programmers_64061.js: -------------------------------------------------------------------------------- 1 | const getTopDollIndex = (board, index) => { 2 | let topIndex = -1; 3 | for (const line of board) { 4 | topIndex = topIndex + 1; 5 | if (line[index] !== 0) { 6 | return topIndex; 7 | } 8 | } 9 | return -1; 10 | }; 11 | 12 | const solution = (board, moves) => { 13 | let answer = 0; 14 | const basket = []; 15 | 16 | for (const move of moves) { 17 | const dollX = move - 1; 18 | const dollY = getTopDollIndex(board, dollX); 19 | if (dollY === -1) continue; 20 | 21 | const doll = board[dollY][dollX]; 22 | board[dollY][dollX] = 0; 23 | 24 | const top = basket.pop(); 25 | if (top === doll) { 26 | answer = answer + 2; 27 | continue; 28 | } else if (top) { 29 | basket.push(top); 30 | } 31 | basket.push(doll); 32 | } 33 | 34 | return answer; 35 | }; 36 | -------------------------------------------------------------------------------- /src/do02reen24/string/baekjoon_1316.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if __name__ == '__main__': 4 | n = int(sys.stdin.readline()) 5 | count = 0 6 | for _ in range(n): 7 | word = sys.stdin.readline().rstrip() 8 | check = {} 9 | before = word[0] 10 | for w in word: 11 | if check.get(w) == None: 12 | check[w] = True 13 | before = w 14 | elif before == w: 15 | continue 16 | else: 17 | count -= 1 18 | break 19 | count += 1 20 | print(count) -------------------------------------------------------------------------------- /src/do02reen24/string/programmers_12904.js: -------------------------------------------------------------------------------- 1 | const isSameWord = (word, pre, next) => { 2 | if (pre < 0 || next >= word.length) { 3 | return false; 4 | } 5 | if (word[pre] !== word[next]) { 6 | return false; 7 | } 8 | return true; 9 | }; 10 | 11 | const oddPalindrome = (word, start) => { 12 | let index = 1; 13 | while (true) { 14 | const pre = start - index; 15 | const next = start + index; 16 | if (isSameWord(word, pre, next)) { 17 | index = index + 1; 18 | continue; 19 | } 20 | index = index - 1; 21 | break; 22 | } 23 | return index * 2 + 1; 24 | }; 25 | 26 | const evenPalindrome = (word, start) => { 27 | let index = 0; 28 | while (true) { 29 | const pre = start - index; 30 | const next = start + 1 + index; 31 | if (isSameWord(word, pre, next)) { 32 | index = index + 1; 33 | continue; 34 | } 35 | break; 36 | } 37 | return index * 2; 38 | }; 39 | 40 | const isPalindrome = (word, start) => { 41 | const oddResult = oddPalindrome(word, start); 42 | const evenResult = evenPalindrome(word, start); 43 | return Math.max(oddResult, evenResult); 44 | }; 45 | 46 | const solution = (s) => { 47 | let maxLength = 0; 48 | for (let index = 0; index < s.length; index++) { 49 | const result = isPalindrome(s, index); 50 | if (maxLength < result) { 51 | maxLength = result; 52 | } 53 | } 54 | 55 | return maxLength; 56 | }; 57 | -------------------------------------------------------------------------------- /src/do02reen24/string/programmers_60057.py: -------------------------------------------------------------------------------- 1 | def combineString(string, word, count): 2 | if not count == 1: 3 | string += str(count) 4 | string += word 5 | return string 6 | 7 | def compression(string, length): 8 | compString = '' 9 | temp = string[:length] 10 | count = 0 11 | index = list(range(0, len(string), length)) 12 | for i in index: 13 | now = string[i:i+length] 14 | if now == temp: 15 | count+=1 16 | else: 17 | compString = combineString(compString, temp, count) 18 | count = 1 19 | temp = now 20 | if i == index[-1]: 21 | compString = combineString(compString, temp, count) 22 | return len(compString) 23 | 24 | def solution(s): 25 | answer = len(s) 26 | for length in range(1, int(len(s) / 2) + 1): 27 | result = compression(s, length) 28 | if answer > result: 29 | answer = result 30 | return answer 31 | 32 | sList = [ 33 | "aabbaccc", 34 | "ababcdcdababcdcd", 35 | "abcabcdede", 36 | "abcabcabcabcdededededede", 37 | "xababcdcdababcdcd" 38 | ] 39 | 40 | for s in sList: 41 | print(solution(s)) -------------------------------------------------------------------------------- /src/do02reen24/string/programmers_64065.js: -------------------------------------------------------------------------------- 1 | const countingNumber = (arr) => { 2 | const counts = {}; 3 | arr.forEach((n) => (counts[n] = (counts[n] || 0) + 1)); 4 | return counts; 5 | }; 6 | 7 | const sortByValue = (dict) => { 8 | const arr = []; 9 | for (const key in dict) { 10 | const value = dict[key]; 11 | arr.push([Number(key), value]); 12 | } 13 | return arr.sort((pre, next) => next[1] - pre[1]); 14 | }; 15 | 16 | const getKeyList = (arr) => { 17 | const keys = []; 18 | for (const pair of arr) { 19 | const key = pair[0]; 20 | keys.push(key); 21 | } 22 | return keys; 23 | }; 24 | 25 | const solution = (s) => { 26 | const deleteBracket = s.replace(/[{}]/gi, ''); 27 | const numberList = deleteBracket.split(','); 28 | const counts = countingNumber(numberList); 29 | const valueList = sortByValue(counts); 30 | const answer = getKeyList(valueList); 31 | return answer; 32 | }; 33 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/1_BinaryGap.js: -------------------------------------------------------------------------------- 1 | const solution = (N) => { 2 | let maxLength = 0; 3 | const bin = N.toString(2).split(''); 4 | 5 | bin.reduce((length, word) => { 6 | if (word === '1') { 7 | if (maxLength < length) maxLength = length; 8 | return 0; 9 | } 10 | return length + 1; 11 | }, 0); 12 | 13 | return maxLength; 14 | }; 15 | 16 | console.log(solution(32)); 17 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/2_CyclicRotation.js: -------------------------------------------------------------------------------- 1 | const solution = (A, K) => { 2 | const length = A.length; 3 | const k = K % length; 4 | const front = A.slice(length - k, length); 5 | const end = A.slice(0, length - k); 6 | return front.concat(end); 7 | }; 8 | 9 | console.log(solution([3, 8, 9, 7, 6], 3)); 10 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/2_OddOccurrencesInArray.js: -------------------------------------------------------------------------------- 1 | const solution = (A) => { 2 | const count = A.reduce((arr, num) => { 3 | if (arr[num] === undefined) arr[num] = 1; 4 | else arr[num] += 1; 5 | return arr; 6 | }, {}); 7 | for (const num in count) { 8 | if (count[num] % 2 !== 0) return num; 9 | } 10 | return -1; 11 | }; 12 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/3_FrogJmp.js: -------------------------------------------------------------------------------- 1 | const solution = (X, Y, D) => { 2 | return Math.ceil((Y - X) / D); 3 | }; 4 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/3_PermMissingElem.js: -------------------------------------------------------------------------------- 1 | const solution = (A) => { 2 | const N = A.length + 1; 3 | const isNum = {}; 4 | A.forEach((a) => { 5 | isNum[a] = true; 6 | }); 7 | for (let n = 1; n < N + 1; n += 1) { 8 | if (isNum[n] === true) continue; 9 | return n; 10 | } 11 | return -1; 12 | }; 13 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/3_TapeEquilibrium.js: -------------------------------------------------------------------------------- 1 | const solution = (A) => { 2 | let answer; 3 | let frontSum = 0; 4 | let backSum = A.reduce((a, b) => a + b, 0); 5 | for (let i = 0; i < A.length - 1; i += 1) { 6 | frontSum += A[i]; 7 | backSum -= A[i]; 8 | const absSub = Math.abs(frontSum - backSum); 9 | if (absSub < answer || answer === undefined) answer = absSub; 10 | } 11 | 12 | return answer; 13 | }; 14 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/7_StoneWall.js: -------------------------------------------------------------------------------- 1 | const solution = (H) => { 2 | const queue = [H]; 3 | let block = 0; 4 | while (queue.length > 0) { 5 | const h = queue.pop(); 6 | if (h.length === 0) continue; 7 | const min = Math.min.apply(null, h); 8 | const remain = h.reduce((arr, cur) => { 9 | if (cur === min) { 10 | queue.push(arr); 11 | return []; 12 | } 13 | arr.push(cur); 14 | return arr; 15 | }, []); 16 | queue.push(remain); 17 | block += 1; 18 | } 19 | return block; 20 | }; 21 | -------------------------------------------------------------------------------- /src/do02reen24/실전연습/codility/score.md: -------------------------------------------------------------------------------- 1 | # 📋 Codility 점수 기록 2 | 3 | | Lesson | 문제 | 점수 | 비고 | 최종 제출 날짜 | 4 | | :-----------------: | :-------------------: | :--: | :-------------------: | :------------: | 5 | | 1-Iterations | BinaryGap | 100 | - | 2021-01-05 | 6 | | 2-Arrays | CyclicRotation | 100 | - | 2021-01-05 | 7 | | 2-Arrays | OddOccurrencesInArray | 100 | - | 2021-01-05 | 8 | | 3-Time Complexity | FrogJmp | 100 | - | 2021-01-06 | 9 | | 3-Time Complexity | PermMissingElem | 100 | - | 2021-01-06 | 10 | | 3-Time Complexity | TapeEquilibrium | 100 | - | 2021-01-06 | 11 | | 7-Stacks and Queues | StoneWall | 85 | 정확도 100%, 성능 77% | 2021-01-05 | 12 | 13 | # 📚 Perfect Lesson 14 | 15 | > 모든 문제를 100%로 끝낸 Lesson 16 | 17 | * Lesson1 - Iterations 18 | 19 | * Lesson2 - Arrays 20 | * Lesson3 - Time Complexity 21 | 22 | -------------------------------------------------------------------------------- /src/grap3fruit/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boost-algorithm/ProblemSolve/80e3e05653ca7ff63cbd88e23604d0cceab632dd/src/grap3fruit/README.md -------------------------------------------------------------------------------- /src/grap3fruit/js/boj/input1_1.js: -------------------------------------------------------------------------------- 1 | const solution = (N, data) => { 2 | console.log(N); 3 | console.log(data); 4 | }; 5 | 6 | let fs = require('fs'); 7 | let input = fs.readFileSync('test').toString().split('\n'); 8 | 9 | const N = +input[0]; 10 | const data = []; 11 | for (let i = 1; i < N + 1; i++) { 12 | // 위에서 N을 받을떄 input[0]이 빠져나갔기 때문에 1~N을 받아야한다. 13 | data.push(input[i].split(' ').map((el) => +el)); 14 | } 15 | 16 | solution(N, data); 17 | -------------------------------------------------------------------------------- /src/grap3fruit/js/boj/input1_2.js: -------------------------------------------------------------------------------- 1 | const solution = (N, info, data) => { 2 | console.log(N); 3 | const [X, Y] = info; 4 | console.log(X, Y); 5 | console.log(data); 6 | }; 7 | 8 | let fs = require('fs'); 9 | let input = fs.readFileSync('test2').toString().split('\n'); 10 | 11 | const N = +input[0]; 12 | const info = input[1].split(' ').map((el) => +el); 13 | const data = []; 14 | for (let i = 2; i < N + 2; i++) { 15 | // 위에서 N을 받을떄 input[0]이 빠져나갔기 때문에 1~N을 받아야한다. 16 | data.push(input[i].split(' ').map((el) => +el)); 17 | } 18 | 19 | solution(N, info, data); 20 | -------------------------------------------------------------------------------- /src/grap3fruit/js/boj/test: -------------------------------------------------------------------------------- 1 | 3 2 | 1 2 3 3 | 2 3 4 4 | 3 4 5 -------------------------------------------------------------------------------- /src/grap3fruit/js/boj/test2: -------------------------------------------------------------------------------- 1 | 3 2 | 2 3 3 | 1 2 3 4 | 2 3 4 5 | 3 4 5 -------------------------------------------------------------------------------- /src/grap3fruit/js/goorm/input1.js: -------------------------------------------------------------------------------- 1 | const solution = (N, data) => { 2 | console.log(N); 3 | console.log(data); 4 | }; 5 | 6 | const readline = require('readline'); 7 | const rl = readline.createInterface({ 8 | input: process.stdin, 9 | output: process.stdout, 10 | }); 11 | 12 | let N = null; 13 | let count = 0; 14 | const data = []; 15 | 16 | rl.on('line', function (line) { 17 | console.log(line); 18 | if (!N) { 19 | N = +line; 20 | } else { 21 | // data.push(line.split(' ').map((el) => +el)); 22 | // data.push(line.split('').map((el) => +el)); 23 | // data.push(line.split('').map((el) => el)); 24 | data.push(line); 25 | } 26 | count += 1; 27 | if (count === N) { 28 | rl.close(); 29 | } 30 | }).on('close', function () { 31 | solution(N, data); 32 | process.exit(); 33 | }); 34 | -------------------------------------------------------------------------------- /src/grap3fruit/js/goorm/input1_1.js: -------------------------------------------------------------------------------- 1 | const solution = (data) => { 2 | console.log(data); 3 | }; 4 | 5 | const readline = require('readline'); 6 | const rl = readline.createInterface({ 7 | input: process.stdin, 8 | output: process.stdout, 9 | }); 10 | 11 | let data = []; 12 | 13 | rl.on('line', function (line) { 14 | data.push(line); 15 | // data = line.split('').map((el) => el); 16 | // data = line.split(' ').map((el) => el); 17 | // data = line.split('').map((el) => +el); 18 | 19 | rl.close(); 20 | }).on('close', function () { 21 | solution(data); 22 | process.exit(); 23 | }); 24 | -------------------------------------------------------------------------------- /src/grap3fruit/js/goorm/input1_2.js: -------------------------------------------------------------------------------- 1 | const solution = (N, info, data) => { 2 | console.log(N); 3 | const [X, Y] = info; 4 | console.log(X, Y); 5 | console.log(data); 6 | }; 7 | 8 | const readline = require('readline'); 9 | const rl = readline.createInterface({ 10 | input: process.stdin, 11 | output: process.stdout, 12 | }); 13 | 14 | let N = null; 15 | let info = null; 16 | let count = 0; 17 | const data = []; 18 | 19 | rl.on('line', function (line) { 20 | if (!N) { 21 | // N이 null이면 22 | N = +line; 23 | } else if (!info) { 24 | // N이 null이 아닌데, info가 null이면 25 | info = line.split(' ').map((el) => +el); 26 | } else { 27 | // N과 info가 null이 아니면 28 | data.push(line); 29 | // data.push(line.split('').map((el) => +el)); 30 | // data.push(line.split('').map((el) => el)); 31 | // data.push(line.split(' ').map((el) => +el)); 32 | count += 1; // data를 입력받으면 count를 증가시켜주고 33 | } 34 | if (count === N) { 35 | // count가 입력받아야하는 N일때 rl.close()를 호출해준다. 36 | rl.close(); 37 | } 38 | }).on('close', function () { 39 | // rl.close()를 호출하면 이 콜백함수로 들어오고 40 | solution(N, info, data); // solution을 실행 한 후 41 | process.exit(); // 프로세스를 종료한다. 42 | }); 43 | -------------------------------------------------------------------------------- /src/grap3fruit/js/goorm/input1_3.js: -------------------------------------------------------------------------------- 1 | const solution = (N, data) => { 2 | console.log(N); 3 | console.log(data); 4 | }; 5 | 6 | const readline = require('readline'); 7 | const rl = readline.createInterface({ 8 | input: process.stdin, 9 | output: process.stdout, 10 | }); 11 | 12 | let T = null; 13 | let N = null; 14 | let info = null; 15 | let countN = 0; 16 | let countT = 0; 17 | let data = []; 18 | 19 | rl.on('line', function (line) { 20 | if (!T) { 21 | T = +line; 22 | } else if (!N) { 23 | N = +line; 24 | } else { 25 | data.push(line); 26 | // data.push(line.split('').map((el) => +el)); 27 | // data.push(line.split('').map((el) => el)); 28 | // data.push(line.split(' ').map((el) => +el)); 29 | countN += 1; // data를 입력받으면 countN을 증가시켜주고 30 | } 31 | if (countN === N) { 32 | // N만큼 data를 잘 입력 받았으면 33 | solution(N, data); // solution을 호출하고 34 | N = null; // T, countT를 제외한 값들을 초기화해준다. 35 | info = null; 36 | countN = 0; 37 | data = []; 38 | 39 | countT += 1; // 그리고 테스트 케이스 하나를 통과했으니 countT를 1 올려준다. 40 | } 41 | if (countT === T) { 42 | // 입력받은 T 만큼 테스트 케이스를 통과하게되면 43 | rl.close(); // rl.close()를 호출하고 44 | } 45 | }).on('close', function () { 46 | process.exit(); // 종료한다. 47 | }); 48 | -------------------------------------------------------------------------------- /src/grap3fruit/js/goorm/input2.js: -------------------------------------------------------------------------------- 1 | const solution = (N, data) => { 2 | console.log(N); 3 | console.log(data); 4 | }; 5 | 6 | const readline = require('readline'); 7 | 8 | (async () => { 9 | let rl = readline.createInterface({ input: process.stdin }); 10 | let N = null; 11 | let count = 0; 12 | const data = []; 13 | 14 | for await (const line of rl) { 15 | if (!N) { 16 | N = +line; 17 | } else { 18 | data.push(line); // 1 2 3 4 5 -> ['1 2 3 4 5'] 19 | // data.push(line.split(' ').map((el) => +el)); // 1 2 3 4 5 -> [1,2,3,4,5] 20 | // data.push(line.split('').map((el) => el)); // 12345 -> ['1','2','3','4','5'] 21 | // data.push(line.split('').map((el) => +el)); // 12345 -> [1,2,3,4,5] 22 | count += 1; 23 | } 24 | if (N === count) { 25 | rl.close(); 26 | } 27 | } 28 | 29 | solution(N, data); 30 | process.exit(); 31 | })(); 32 | -------------------------------------------------------------------------------- /src/grap3fruit/js/input.md: -------------------------------------------------------------------------------- 1 | [구름(goorm), 백준(BOJ) 코딩 테스트 JavaScript로 입력받는 방법 정리](https://velog.io/@grap3fruit/구름goorm-코테-javascript-로-입력값-받는-방법) 블로그 글 작성 2 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/12904.js: -------------------------------------------------------------------------------- 1 | const getMaxOddPalindrome = (word, idx) => { 2 | let max = 0; 3 | for (let i = 0; i < word.length / 2; i++) { 4 | if (word[idx - i] !== word[idx + i]) { 5 | break; 6 | } 7 | max = i * 2 + 1; 8 | } 9 | return max; 10 | }; 11 | 12 | const getMaxEvenPalindrome = (word, idx) => { 13 | let max = 0; 14 | if (idx < word.length - 1 && word[idx] === word[idx + 1]) { 15 | for (let i = 0; i < word.length / 2; i++) { 16 | if (word[idx - i] !== word[idx + i + 1]) { 17 | break; 18 | } 19 | max = i * 2 + 2; 20 | } 21 | } 22 | return max; 23 | }; 24 | 25 | const solution = (s) => { 26 | let sArr = s.split(''); 27 | let answer = 0; 28 | 29 | for (let i = 0; i < sArr.length; i++) { 30 | answer = Math.max(answer, getMaxOddPalindrome(sArr, i), getMaxEvenPalindrome(sArr, i)); 31 | } 32 | 33 | return answer; 34 | }; 35 | 36 | // solution('ccabcbaa'); 37 | console.log(solution('baaba')); 38 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/12904.md: -------------------------------------------------------------------------------- 1 | # 12904 가장 긴 팰린드롬 - 성공 2 | 3 | ## 아이디어 구현 4 | 5 | 첫번째 풀이 6 | 7 | ``` 8 | const checkPD = (word) => { 9 | const wordLength = word.length; 10 | 11 | for (let i = 0; i < wordLength / 2; i++) { 12 | if (word[i] !== word[wordLength - i - 1]) { 13 | return false; 14 | } 15 | } 16 | return true; 17 | }; 18 | 19 | const solution = (s) => { 20 | sArr = s.split(''); 21 | answer = 0; 22 | 23 | sArr.reduce((accumulator, currentValue, currentIndex, array) => { 24 | console.log(accumulator); 25 | console.log(accumulator.join('')); 26 | if (accumulator.length > 0 && checkPD(accumulator.join(''))) { 27 | console.log(`${currentIndex}에서 펠린드롬입니다`); 28 | answer = currentIndex; 29 | } 30 | 31 | return [...accumulator, currentValue]; 32 | }, []); 33 | console.log(sArr); 34 | 35 | if (checkPD(sArr.join(''))) { 36 | // console.log(`${sArr.length}에서 펠린드롬입니다`); 37 | answer = sArr.length; 38 | } 39 | 40 | console.log(answer); 41 | return answer; 42 | }; 43 | 44 | solution('abcabcdcbae'); 45 | ``` 46 | 47 | reduce써서 멋지게 풀어보려고 했지만, 48 | 49 | 팰린드롬이 중간에 오는 경우 못찾는다. 항상 앞에서 붙여나가기 때문 ㅠ 50 | 51 | 테케 `abcabcdcbae` 여기에 걸림 52 | `adcbbbbca` 이것도 안될듯. 53 | 54 | --- 55 | 56 | 한개짜리일때 쫙 찾고, 57 | 58 | 두개짜리일때 쫙 찾고 59 | 60 | 해야겠는걸. 61 | 62 | 근데 이러면 효율성 통과 안될거같은데. 63 | 64 | 위에 느낌으로 하려면, 큰거부터 찾자. 작은건 무조건 큰거까지 가야하지만 큰거는 되면 바로 끝내면 된다. 65 | 66 | --- 67 | 68 | 위에꺼는 아닌것 같아 고민하다가 떠오름. 69 | 70 | 하나씩 가면서 넓혀보기. 최대한 넓힌 max 리턴. << 이 방법. 71 | 72 | 아이디어 싸움이었다. 못떠올렸으면 으으.. 73 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/12981.js: -------------------------------------------------------------------------------- 1 | const getResult = (idx, n) => { 2 | return [(idx % n) + 1, Math.ceil((idx + 1) / n)]; 3 | }; 4 | 5 | const check = (lastWord, n, word, idx, visited) => { 6 | if (visited.get(word)) { 7 | return getResult(idx, n); 8 | } 9 | if (idx > 0) { 10 | if (lastWord[lastWord.length - 1] !== word[0]) { 11 | return getResult(idx, n); 12 | } 13 | } 14 | return null; 15 | }; 16 | 17 | function solution(n, words) { 18 | let answer = null; 19 | const visited = new Map(); 20 | 21 | words.forEach((word, idx) => { 22 | if (!answer) { 23 | answer = check(words[idx - 1], n, word, idx, visited); 24 | visited.set(word, true); 25 | } 26 | }); 27 | if (!answer) { 28 | answer = [0, 0]; 29 | } 30 | return answer; 31 | } 32 | 33 | const n = 2; 34 | const words = ['hello', 'two']; 35 | // const words = ['hello', 'one', 'even', 'never', 'now', 'world', 'draw']; 36 | // const words = ['tank', 'kick', 'know', 'wheel', 'land', 'dream', 'mother', 'robot', 'tank']; 37 | 38 | console.log(solution(n, words)); 39 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/12981.md: -------------------------------------------------------------------------------- 1 | # 12981 영어 끝말잇기 - 성공 2 | 3 | ## 아이디어 구현 4 | 5 | 단순 구현 문제 6 | 7 | words를 돌면서 조건에 맞는것 리턴 해주면 됨. 8 | 9 | [번호, 차례]를 잘 출력하는게 까다로웠음. 10 | 11 | 차례는 항상 올림으로 해주면 맞게 된다. 12 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/42578.js: -------------------------------------------------------------------------------- 1 | function solution(clothes) { 2 | let answer = 1; 3 | const data = {}; 4 | 5 | clothes.forEach((cloth) => { 6 | if (!data[cloth[1]]) { 7 | return (data[cloth[1]] = [cloth[0]]); 8 | } 9 | data[cloth[1]].push(cloth[0]); 10 | }); 11 | 12 | for (const el in data) { 13 | answer *= data[el].length + 1; 14 | } 15 | answer -= 1; 16 | 17 | return answer; 18 | } 19 | 20 | const clothes = [ 21 | ['yellow_hat', 'headgear'], 22 | ['blue_sunglasses', 'eyewear'], 23 | ['green_turban', 'headgear'], 24 | ]; 25 | 26 | console.log(solution(clothes)); 27 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/42578.md: -------------------------------------------------------------------------------- 1 | # 42578 위장 - 성공 2 | 3 | ## 아이디어 구현 4 | 5 | 이 문제가 왜 해시인가? 딕셔너리 아닌가? 했더니 6 | 7 | 해시맵 === 딕셔너리 네요. 같은 자료구조인데 여러가지로 불리는. 8 | 9 | [키기반의 컬렉션](https://developer.mozilla.org/ko/docs/Web/JavaScript/Guide/Keyed_collections#Maps) 참고해서, map 써서도 구현해봤습니다 10 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/42578_2.js: -------------------------------------------------------------------------------- 1 | function solution(clothes) { 2 | let answer = 1; 3 | console.log(clothes); 4 | 5 | const map = new Map(); 6 | 7 | clothes.forEach((cloth) => { 8 | if (!map.get(cloth[1])) { 9 | return map.set(cloth[1], [cloth[0]]); 10 | } 11 | 12 | map.get(cloth[1]).push(cloth[0]); 13 | }); 14 | 15 | for (let key of map.keys()) { 16 | answer *= map.get(key).length + 1; 17 | } 18 | answer -= 1; 19 | 20 | return answer; 21 | } 22 | 23 | const clothes = [ 24 | ['yellow_hat', 'headgear'], 25 | ['blue_sunglasses', 'eyewear'], 26 | ['green_turban', 'headgear'], 27 | ]; 28 | 29 | console.log(solution(clothes)); 30 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/43162.js: -------------------------------------------------------------------------------- 1 | const bfs = (computers, root) => { 2 | const visited = [root]; 3 | let q = [computers[root]]; 4 | 5 | while (q.length > 0) { 6 | let item = q.shift(); 7 | 8 | item.forEach((el, idx) => { 9 | if (el === 1 && !visited.includes(idx)) { 10 | q.push(computers[idx]); 11 | visited.push(idx); 12 | } 13 | }); 14 | } 15 | 16 | return visited; 17 | }; 18 | 19 | function solution(n, computers) { 20 | let answer = 0; 21 | const visited = []; 22 | 23 | computers.forEach((_, idx) => { 24 | const visitFlag = visited.some((el) => el.includes(idx)); 25 | 26 | if (!visitFlag) { 27 | const newVisited = bfs(computers, idx); 28 | visited.push(newVisited); 29 | } 30 | }); 31 | 32 | console.log(visited.length); 33 | answer = visited.length; 34 | return answer; 35 | } 36 | 37 | const n = 3; 38 | const computers = [ 39 | [1, 1, 0], 40 | [1, 1, 0], 41 | [0, 0, 1], 42 | ]; 43 | // const computers = [ 44 | // [1, 1, 0], 45 | // [1, 1, 1], 46 | // [0, 1, 1], 47 | // ]; 48 | 49 | solution(n, computers); 50 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/43162.md: -------------------------------------------------------------------------------- 1 | # 43162 네트워크 - 성공 2 | 3 | ## BFS 4 | 5 | bfs에서 최단거리를 구할 필요는 없고, 지나간 모든 경로를 visited에 담아서 반환하면 이걸 하나의 네트워크라고 생각한다. 6 | 7 | 각각의 컴퓨터가 root일때 네트워크를 구하고 겹치지 않는 네트워크의 개수를 구해주면 된다. 8 | 9 | 겹치지 않도록 하기위해 bfs로 root를 넣기 전, network를 모두 체크해서 겹치는 root가 있으면 같은 네트워크가 이미 있다는 것이므로 pass 했다. 10 | 11 | 위 조건에 따른 모든 network를 구한 후 개수를 세면 끝. 12 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/64061.js: -------------------------------------------------------------------------------- 1 | const board = [ 2 | [0, 0, 0, 0, 0], 3 | [0, 0, 1, 0, 3], 4 | [0, 2, 5, 0, 1], 5 | [4, 2, 4, 4, 2], 6 | [3, 5, 1, 3, 1], 7 | ]; 8 | const moves = [1, 5, 3, 5, 1, 2, 1, 4]; 9 | 10 | function solution(board, moves) { 11 | const result = []; 12 | let answer = 0; 13 | 14 | moves.reduce((acc, move) => { 15 | for (let i = 0; i < board.length; i++) { 16 | if (board[i][move - 1] === 0) { 17 | continue; 18 | } 19 | 20 | if (acc.length > 0) { 21 | const prev = acc.pop(); 22 | 23 | if (prev === board[i][move - 1]) { 24 | board[i][move - 1] = 0; 25 | answer += 2; 26 | return acc; 27 | } 28 | 29 | acc.push(prev); 30 | } 31 | 32 | acc.push(board[i][move - 1]); 33 | board[i][move - 1] = 0; 34 | return acc; 35 | } 36 | return acc; 37 | }, []); 38 | 39 | console.log(board); 40 | console.log(result); 41 | return answer; 42 | } 43 | 44 | console.log(solution(board, moves)); 45 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/64061.md: -------------------------------------------------------------------------------- 1 | # 64061 크레인 인형뽑기 게임 - 성공 2 | 3 | ## 구현 4 | 5 | moves는 board의 x축에 접근하는데, 6 | 7 | 이걸 이제 result stack에 넣고, 8 | 9 | stack에 넣을때 pop을 한번 해줘서 10 | 11 | pop된 요소가 현재 넣는것과 동일하면 pass 하고 answer에 +2 해줌. 12 | 13 | 동일 하지 않으면 pop 했던거 다시 넣고, 현재 요소 넣어줌. 14 | 15 | --- 16 | 17 | move.forEach는 reduce로 accumulator에 answer 넣어서 가능할것 같고. 18 | 19 | borad[i][move] 이거는 고차함수로 될까? 20 | 21 | 외부에 flag 선언해놓고, 한번 0으로 바뀌면 flag 값 바꿔주면 될거같긴한데. 의미가 있나? for문이 더 빠를거같은데. 22 | 23 | 속도 vs 가독성? 24 | 25 | > 구현해 보니 가독성이 좋은것 같지도 않다.. 26 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/64061_2.js: -------------------------------------------------------------------------------- 1 | const board = [ 2 | [0, 0, 0, 0, 0], 3 | [0, 0, 1, 0, 3], 4 | [0, 2, 5, 0, 1], 5 | [4, 2, 4, 4, 2], 6 | [3, 5, 1, 3, 1], 7 | ]; 8 | const moves = [1, 5, 3, 5, 1, 2, 1, 4]; 9 | 10 | const result = []; 11 | let answer = 0; 12 | 13 | moves.forEach((move) => { 14 | let changedFlag = false; 15 | 16 | board.forEach((el) => { 17 | if (el[move - 1] !== 0 && changedFlag === false) { 18 | if (result.length > 0) { 19 | const prev = result.pop(); 20 | 21 | if (prev === el[move - 1]) { 22 | el[move - 1] = 0; 23 | answer += 2; 24 | changedFlag = true; 25 | } else { 26 | result.push(prev); 27 | } 28 | } 29 | if (changedFlag === false) { 30 | result.push(el[move - 1]); 31 | el[move - 1] = 0; 32 | changedFlag = true; 33 | } 34 | } 35 | }); 36 | }); 37 | 38 | console.log(board); 39 | console.log(result); 40 | console.log(answer); 41 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/64065.js: -------------------------------------------------------------------------------- 1 | const getSubtractedArr = (arrA, arrB) => arrB.filter((el) => !arrA.includes(el)); 2 | 3 | const getArrFromStr = (s) => { 4 | const arr = s.split(''); 5 | 6 | let parent_arr = []; 7 | let child_arr = []; 8 | 9 | for (let i = 1; i < arr.length - 1; i++) { 10 | if (arr[i] === '}') { 11 | parent_arr.push(child_arr); 12 | child_arr = []; 13 | } 14 | 15 | if (+arr[i] >= 0) { 16 | if (+arr[i - 1] >= 0) { 17 | const num = child_arr.pop(); 18 | child_arr.push(Number(num + arr[i])); 19 | } else { 20 | child_arr.push(+arr[i]); 21 | } 22 | } 23 | } 24 | return parent_arr; 25 | }; 26 | 27 | function solution(s) { 28 | let answer = []; 29 | const arr = getArrFromStr(s); 30 | 31 | for (let i = 0; i < arr.length; i++) { 32 | for (let j = 0; j < arr.length; j++) { 33 | if (arr[j].length === i + 1) { 34 | const [temp] = getSubtractedArr(answer, arr[j]); 35 | answer.push(temp); 36 | break; 37 | } 38 | } 39 | } 40 | 41 | return answer; 42 | } 43 | 44 | // console.log(solution('{{2},{2,1},{2,1,3},{2,1,3,4}}')); 45 | // console.log(solution('{{1,2,3},{2,1},{1,2,4,3},{2}}')); 46 | // console.log(solution('{{20,111},{111}}')); 47 | // console.log(solution('{{123}}')); 48 | // console.log(solution('{{4,2,3},{3},{2,3,4,1},{2,3}}')); 49 | 50 | const setA = new Set(); 51 | const setB = new Set(); 52 | setA.add(1); 53 | setA.add(2); 54 | setB.add(3); 55 | setB.add(2); 56 | 57 | console.log(setA, setB); 58 | console.log(setA - setB); 59 | -------------------------------------------------------------------------------- /src/grap3fruit/js/programmers/64065.md: -------------------------------------------------------------------------------- 1 | # 64065 2019 카카오 겨울인턴 튜플 - 성공 2 | 3 | ## 구현 4 | 5 | 집합 길이에 따라서 6 | 7 | 가장 작은게 맨 앞이고 8 | 9 | 그 다음 길이에 추가된게 다음꺼 10 | 11 | 이런식으로 result 채우면 됨. 12 | 13 | python에 set 쓰면 엄청 쉬웠을듯 ㅋㅋ 14 | 15 | --- 16 | 17 | 1. {} 문자열을 [] 배열로 바꾼다. 18 | 19 | ``` 20 | 부모 arr, 자식 arr를 둔다. 21 | 이차원 배열의 바깥을 부모 arr. 22 | 내부 el들이 자식 arr. 23 | 24 | 전체 string 길이만큼 loop를 돌면서 25 | 만약 '}' 면 26 | 부모에 현재까지 자식 arr 추가. 27 | 자식 arr = [] 28 | 29 | '}' 가 아닐떄 30 | 앞이 숫자면 합쳐서 자식arr에 넣고 31 | 아니면 그냥 넣음. 32 | 33 | 34 | ``` 35 | 36 | 2. 배열 갯수만큼 이중포문 돈다. 37 | 38 | ``` 39 | for i = 1,2,3 ... 40 | for j = 1,2,3 ... 41 | 만약 현재 배열의 길이가 i이면, 42 | answer에 추가. 43 | 44 | ``` 45 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1010.md: -------------------------------------------------------------------------------- 1 | # 1010 - 성공 2 | 3 | ## DP 4 | 5 | - nCr 써서 풀었음. 6 | - 7C3이면 (7*6*5)/(3*2*1)을 계산. 7 | 8 | ## 보완 9 | 10 | - DP문제인데 DP로 안풀었다. 😂 11 | - 도호님 방법 처럼 DP로 풀어볼 필요도 있을듯.. 12 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1010.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def get_mCn(N, M): 4 | mom = N 5 | mom_index = N 6 | child = M 7 | child_index = M 8 | 9 | for _ in range(M-1): 10 | 11 | mom = mom * (mom_index-1) 12 | mom_index -= 1 13 | 14 | while child_index > 1: 15 | child = child * (child_index-1) 16 | child_index -= 1 17 | 18 | return(int(mom/child)) 19 | 20 | T = int(sys.stdin.readline()) 21 | 22 | for _ in range(T): 23 | N, M = list(map(int,sys.stdin.readline().strip().split())) 24 | print(get_mCn(M, N)) 25 | 26 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1094.md: -------------------------------------------------------------------------------- 1 | # 1094 - 성공 2 | 3 | ## 비트마스크 4 | 5 | - 문제 내용대로 풀면 됨 6 | - 일단 current_min을 지우고, 절반을 통해 계산을 하고, 7 | - 1-2번 조건까지 가게 되면 그때 절반을 추가해준다. 8 | 9 | ## 보완 10 | 11 | - 비트마스크를 활용하지 않았는데, 활용해보면 좋을듯. 12 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1094.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | target = int(sys.stdin.readline()) 4 | 5 | datas = [64] 6 | 7 | def calc(datas): 8 | if sum(datas) > target: 9 | current_min = min(datas) 10 | datas.remove(current_min) 11 | datas.append(current_min/2) 12 | 13 | if sum(datas) == target: 14 | return len(datas) 15 | 16 | if sum(datas) > target: 17 | return calc(datas) 18 | 19 | if sum(datas) < target: 20 | datas.append(current_min/2) 21 | return calc(datas) 22 | 23 | if sum(datas) == target: 24 | return len(datas) 25 | 26 | print(calc(datas)) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11047.md: -------------------------------------------------------------------------------- 1 | # 11047 - 성공 2 | 3 | ## 그리디 알고리즘 4 | 5 | - 동전의 가치를 내림차순으로 다시 정렬 한 후에, 6 | - 큰 동전부터 주어진 K원을 나누어 간다. 7 | - 나누어 떨어지면 그만큼 빼고 진행한다. 8 | - 모든 코인에 대해서 진행 하고 나면 나눠진 횟수 출력. 9 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11047.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | N, K = list(map(int,sys.stdin.readline().strip().split())) 4 | 5 | coins = [] 6 | for i in range(N): 7 | coins.append(int(sys.stdin.readline())) 8 | 9 | coins.sort(reverse=True) 10 | print(coins) 11 | 12 | count = 0 13 | for coin in coins: 14 | value = int(K/coin) 15 | 16 | if value >= 1: 17 | count += value 18 | K = K-(value*coin) 19 | 20 | print(count) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11286.py: -------------------------------------------------------------------------------- 1 | import heapq 2 | import sys 3 | 4 | # n = 18 5 | # x = [1, 6 | # -1, 7 | # 0, 8 | # 0, 9 | # 0, 10 | # 1, 11 | # 1, 12 | # -1, 13 | # -1, 14 | # 2, 15 | # -2, 16 | # 0, 17 | # 0, 18 | # 0, 19 | # 0, 20 | # 0, 21 | # 0, 22 | # 0] 23 | 24 | n = int(sys.stdin.readline().strip()) 25 | heap = [] 26 | x = [] 27 | for i in range(0, n): 28 | x.append(int(sys.stdin.readline().strip())) 29 | 30 | for i in range(0,n): 31 | if x[i] == 0: 32 | if len(heap) == 0: 33 | print(0) 34 | continue 35 | 36 | print(heapq.heappop(heap)[1]) 37 | continue 38 | if x[i] != 0: 39 | heapq.heappush(heap,(abs(x[i]),x[i])) 40 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11399.md: -------------------------------------------------------------------------------- 1 | # 11399 - 성공 2 | 3 | ## 구현 4 | 5 | sort 이후 앞에서부터 더한 누산기의 합을 구해주면 된다. 6 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11399.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | # n = int(sys.stdin.readline()) 4 | # arr = list(map(int,sys.stdin.readline().strip().split())) 5 | 6 | arr = [3,1,4,3,2] 7 | 8 | arr.sort() 9 | print(arr) 10 | 11 | acc = 0 12 | new_arr = [] 13 | for el in arr: 14 | acc += el 15 | new_arr.append(acc) 16 | 17 | print(sum(new_arr)) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11497.md: -------------------------------------------------------------------------------- 1 | # 11497 - 성공 2 | 3 | ## 그리디 알고리즘 4 | 5 | - 가운데 가장 큰 수를 놓고, 그 옆 좌,우로 차례차례 그 다음 큰 수를 놓는다. 6 | - 그러면 모든 경우에서 양옆의 차가 최소가 되는 경우가 완성된다. 7 | - 반대로 해도 동작될 듯 하다. 8 | - deque 활용해서, 좌우로 값을 넣어줬다. 9 | 10 | ## 보완 11 | 12 | - 아이디어 싸움인데, 증명하기도 뭔가 어려웠고. 더 연습과 학습이 필요하다.. 13 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11497.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import collections 3 | 4 | T = int(sys.stdin.readline()) 5 | for i in range(T): 6 | deq = collections.deque([]) 7 | N = int(sys.stdin.readline()) 8 | datas = list(map(int,sys.stdin.readline().strip().split())) 9 | datas.sort(reverse=True) 10 | 11 | count = 0 12 | for data in datas: 13 | if count % 2 == 0: 14 | deq.append(data) 15 | if count % 2 == 1: 16 | deq.appendleft(data) 17 | 18 | count += 1 19 | 20 | print(deq) 21 | max_gap = 0 22 | for j in range(-1, N-1): 23 | gap = abs(deq[j]-deq[j+1]) 24 | if gap > max_gap: 25 | max_gap = gap 26 | 27 | print(max_gap) 28 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11727.md: -------------------------------------------------------------------------------- 1 | # 11727 - 성공 (힌트) 2 | 3 | ## DP 4 | 5 | ![image](https://user-images.githubusercontent.com/13213473/98455510-fbf68880-21b4-11eb-953f-5612eb6bef77.png) 6 | 7 | 위 그림에서 N번째 경우의 수는 8 | 9 | N-1번째에 2x1 추가해준 경우와, N-2번째에 1x2를 두개 추가해준 경우를 합한 것과 같다. 10 | 11 | 따라서 식은 `dp[N] = dp[N-1] + dp[N-2]` 12 | 13 | 11727번 문제는 위 그림에서 N-2번째에 2x2를 추가하는 경우를 하나 더 생각하면 된다. 14 | 15 | 따라서 식은 `dp[N] = dp[N-1] + dp[N-2] + dp[N-2]` 16 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/11727.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | N = int(sys.stdin.readline()) 4 | 5 | dp = [0]*1002 6 | dp[1] = 1 7 | dp[2] = 3 8 | 9 | index = 2 10 | while True: 11 | if N == 1: 12 | print(dp[1]) 13 | break 14 | 15 | if index == N: 16 | print(dp[N]%10007) 17 | break 18 | 19 | index += 1 20 | dp[index] = dp[index-1] + dp[index-2] + dp[index-2] 21 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1254.md: -------------------------------------------------------------------------------- 1 | # 1254 - 성공 2 | 3 | ## 팰린드롬 4 | 5 | abbca 라고 하면, 6 | 7 | 마지막 a를 기준으로 맨 앞에서 부터 넣어서 팰린드롬 체크를 한다. 8 | 9 | ``` 10 | abbca a 11 | 12 | abbca ba 13 | 14 | abbca bba 15 | 16 | abbc a cbba 17 | ``` 18 | 19 | 이렇게 맨 앞 요소부터 차례대로 넣어주면 된다. 20 | 21 | 뒤에서 i번째 자리에 data[i]를 넣게 된다. 22 | 23 | 뒤에서 i번째 자리에 어떻게 넣어줄까? 24 | 25 | deque 사용해서 해결 26 | 27 | add_string에 appendleft를 해서 28 | 29 | 원본 data + add_string 한것을 팰린드롬 체크 해서 돌려준다. 30 | 31 | ``` 32 | data | add_string 33 | 34 | abbca a 35 | 36 | abbca ba 37 | 38 | abbca bba 39 | 40 | abbca cbba → 팰린드롬! 41 | ``` 42 | 43 | ### 이슈 44 | 45 | - deque 안쓰고도 할 수 있을것 같은데,, 좀 더 예쁜 방법으로? 46 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1254.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | data = sys.stdin.readline().strip() 5 | 6 | def checkPD(data): 7 | N = len(data) 8 | 9 | if N % 2 == 0: 10 | if data[int(N/2)] != data[int(N/2)-1] : 11 | return False 12 | 13 | for i in range(0, int(N/2)): 14 | if data[i] != data[N-i-1] : 15 | return False 16 | 17 | return True 18 | 19 | if N % 2 == 1: 20 | for i in range(0, int(N/2)): 21 | if data[i] != data[N-i-1] : 22 | return False 23 | 24 | return True 25 | 26 | # print(checkPD(['a','b','b','c','a'])) 27 | 28 | # deq = deque(['a','b','c','b', 'a']) 29 | # print(checkPD(deq)) 30 | 31 | def calc(data): 32 | N = len(data) 33 | if N == 1: 34 | print(1) 35 | return 36 | 37 | count = N 38 | add_string = deque([]) 39 | for i in range(0, N): 40 | PD = deque(data) 41 | PD.extend(add_string) 42 | 43 | if checkPD(PD): 44 | print(count, PD) 45 | return 46 | 47 | add_string.appendleft(data[i]) 48 | count += 1 49 | 50 | calc(data) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/12731.md: -------------------------------------------------------------------------------- 1 | # 12731 - 성공(힌트) 2 | 3 | ## 시간 계산 문제 4 | 5 | ### 알고리즘 6 | 7 | 일단 시 → 분으로 변경 8 | 9 | 60 \* hour + min 10 | 11 | main 함수에서 분으로 된 2차원 배열 만듬. 12 | 13 | na_arr = [[660, 720], [960, 1080]] 14 | 15 | nb_arr = [[720, 960], [540, 660]] ..이런식 16 | 17 | calc 함수에 (na_arr, nb_arr, T(=회차시간)) 파라미터 넘겨줘서, 18 | 19 | NA를 돌면서 NA_min - T 보다 NB_max 가 작거나 같은게 있으면, 해당 nb를 제거. 20 | 21 | NB도 똑같이 진행. 22 | 23 | 위 if에 들어갈때 count -= 1 해서 na, nb 각각 카운트 리턴. 24 | 25 | ### 테스트 케이스 26 | 27 | ``` 28 | 1 29 | 5 30 | 1 2 31 | 09:00 11:00 32 | 13:00 15:00 33 | 14:00 16:00 34 | 35 | Case #1: 1 1 36 | 37 | 1 38 | 5 39 | 2 1 40 | 13:00 15:00 41 | 14:00 16:00 42 | 09:00 11:00 43 | 44 | Case #1: 1 1 45 | 46 | 1 47 | 0 48 | 1 2 49 | 09:00 11:00 50 | 11:00 12:00 51 | 12:00 16:00 52 | 53 | Case #1: 1 1 54 | 55 | 56 | 1 57 | 0 58 | 0 3 59 | 09:00 11:00 60 | 11:00 12:00 61 | 12:00 16:00 62 | 63 | Case #1: 0 3 64 | 65 | 66 | 1 67 | 0 68 | 0 3 69 | 09:00 11:00 70 | 11:00 12:00 71 | 12:00 16:00 72 | 73 | Case #1: 0 3 74 | 75 | 76 | 1 77 | 1 78 | 1 2 79 | 09:00 11:00 80 | 11:00 12:00 81 | 12:00 16:00 82 | 83 | Case #1: 1 1 84 | 85 | 1 86 | 0 87 | 2 2 88 | 12:00 16:00 89 | 11:00 12:00 90 | 16:00 18:00 91 | 09:00 11:00 92 | 93 | Case #1: 1 1 94 | 95 | 1 96 | 0 97 | 2 2 98 | 11:00 12:00 99 | 16:00 18:00 100 | 12:00 16:00 101 | 09:00 11:00 102 | 103 | Case #1: 0 1 104 | ``` 105 | 106 | ### 이슈 107 | 108 | - 테케 많이 돌렸는데, 통과가 안된다 😭 109 | - 도연님꺼 참고해서, sort넣었더니 통과됨. 110 | - sort 안해주면 늦은 시간껄 먼저 가져가버려서 꼬이는 경우가 생기는듯 하다. 111 | 112 | ### 보완 113 | 114 | - 다시 풀어보자.. 115 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1316.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def check_word(word): 4 | arr = [] 5 | for idx, val in enumerate(word): 6 | if not val in arr: 7 | arr.append(val) 8 | elif val in arr: 9 | if word[idx-1] == val: 10 | continue 11 | return 0 12 | 13 | return 1 14 | 15 | n = int(sys.stdin.readline().strip()) 16 | words = [] 17 | answer = 0 18 | 19 | for i in range(0, n): 20 | answer += check_word((sys.stdin.readline().strip().split())[0]) 21 | 22 | print(answer) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/14889.md: -------------------------------------------------------------------------------- 1 | # 14889 - 성공 2 | 3 | ## 브루트포스 4 | 5 | - 전체 케이스 구하는 함수 6 | - 사람 a,b 능력치 합 구하는 함수 7 | - 팀내 능력치 합 구하는 함수 8 | - 콤비네이션 써서 구현함 9 | 10 | ## pseudocode 11 | 12 | ``` 13 | cases = get_cases를 통해 팀A와 팀B로 나눌 경우의수 14 | 15 | calc 함수 16 | 전체 case를 돌면서 17 | 팀A와 팀B의 능력치 합을 각각 구해서 18 | 둘의 차이를 비교하고 19 | 최소값을 리턴. 20 | ``` 21 | 22 | ## 보완 23 | 24 | - 도연님 사용하신 next_permutation도 유용해 보인다 25 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/14889.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from itertools import combinations 3 | 4 | n = int(sys.stdin.readline()) 5 | arr = [] 6 | 7 | for i in range(0,n): 8 | arr.append(list(map(int,sys.stdin.readline().strip().split()))) 9 | # n = 6 10 | 11 | cases = [] 12 | for i in range(1,n+1): 13 | cases.append(i) 14 | 15 | # 전체 케이스 구하는 함수 16 | def get_cases(n, cases): 17 | combination_cases = list(combinations(cases,int(n/2))) 18 | teamA_cases = [] 19 | 20 | for case in combination_cases: 21 | if case[0] == 1 : 22 | teamA_cases.append(case) 23 | 24 | result = [] 25 | for teamA in teamA_cases: 26 | teamB = (set(cases) - set(teamA)) 27 | result.append([set(teamA), teamB]) 28 | 29 | return result 30 | 31 | cases = get_cases(n, cases) 32 | print(cases) 33 | 34 | # 사람 a,b 능력치 합 35 | def get_sum(a,b,arr): 36 | return arr[a-1][b-1] + arr[b-1][a-1] 37 | 38 | # print(get_sum(4,6,arr)) 39 | 40 | # 팀내 능력치 합 구하는 함수 41 | def get_team_sum(team, arr): 42 | sum = 0 43 | for members in list(combinations(team,2)): 44 | # print(members) 45 | sum += get_sum(members[0], members[1], arr) 46 | 47 | return sum 48 | 49 | # print(get_team_sum({1,2,3}, arr)) 50 | 51 | def calc(cases, arr): 52 | min = 1000 53 | 54 | for case in cases: 55 | teamA_sum = get_team_sum(case[0], arr) 56 | teamB_sum = get_team_sum(case[1], arr) 57 | 58 | current_min = abs(teamA_sum - teamB_sum) 59 | # print(case, current_min) 60 | if current_min < min : 61 | min = current_min 62 | 63 | return min 64 | 65 | print(calc(cases, arr)) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1697.md: -------------------------------------------------------------------------------- 1 | # 1697 - 성공(힌트) 2 | 3 | ## BFS 4 | 5 | - BFS를 활용하는 문제 6 | - 처음에는 접근을 visited를 두고 if not in 을 통해 예외처리를 해주었는데, visited가 커질수록 시간복잡도가 많이 증가하기 때문에 시간초과가 났음. 7 | - visited = [0]\*100001 이렇게 미리 선언해놓고, index에 표시를 남겨놓는 메모리를 많이 사용하는 방식으로 하면 시간복잡도를 줄여 문제를 해결할 수 있다. 8 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1697.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | import sys 3 | 4 | n, k = map(int,sys.stdin.readline().strip().split()) 5 | 6 | def get_possible(data): 7 | return [data-1, data+1, data*2] 8 | 9 | def bfs(q, visited): 10 | new_q = deque() 11 | while q : 12 | current = q.popleft() 13 | visited[current] = 1 14 | for el in get_possible(current): 15 | if k == el : 16 | return True 17 | 18 | if el > 100000 or el < 0: 19 | continue 20 | 21 | if visited[el] == 0 : 22 | new_q.append(el) 23 | visited[el] = 1 24 | 25 | return new_q 26 | 27 | def calc(root): 28 | if root == k: 29 | return print(0) 30 | 31 | q = deque() 32 | q.append(root) 33 | 34 | visited = [0]*100001 35 | count = 0 36 | while q: 37 | q = bfs(q, visited) 38 | count += 1 39 | if q == True: 40 | return print(count) 41 | 42 | calc(n) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/17609.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def checkPD2(data, start_idx, l_r_flag): 4 | N = len(data) 5 | left = 0 6 | right = 0 7 | 8 | if l_r_flag == 'left': 9 | left = 1 10 | if l_r_flag == 'right': 11 | right = 1 12 | 13 | for i in range(start_idx, int(N/2)): 14 | if data[i+left] != data[N-i-1-right] : 15 | return 2 16 | return 1 17 | 18 | def checkPD1(data): 19 | N = len(data) 20 | 21 | for i in range(0, int(N/2)): 22 | if data[i] != data[N-i-1] : 23 | result = checkPD2(data, i, 'left') 24 | if result == 1 : 25 | return 1 26 | result = checkPD2(data, i, 'right') 27 | return result 28 | 29 | return 0 30 | 31 | N = int(sys.stdin.readline()) 32 | 33 | for _ in range(N) : 34 | data = sys.stdin.readline().strip() 35 | print(checkPD1(data)) 36 | 37 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/18233.md: -------------------------------------------------------------------------------- 1 | # 18233 - 시간초과 2 | 3 | ## 비트마스크 4 | 5 | ## pseudocode 6 | 7 | ``` 8 | 입력받을때, 9 | Min이 E초과일때는 넘김. 10 | Max가 E초과일때는 MAX를 E로 함. 11 | 12 | 조합 경우의수는 콤비네이션을 P만큼 해서 구함. 13 | 14 | 위에서 구해진 가능한 조합을 돌면서, 15 | 해당 조합에서 가능한 합들을 모두 구하고, 16 | 그 합들 중에 E가 있으면 정답을 리턴함. 17 | ``` 18 | 19 | ## 보완 20 | 21 | - 도연님, 도호님 하신것 처럼 min max 값 활용하여 해야할듯. 모든 case를 다 펴서 하는건 시간초과 뜰수밖에 읍다.. 22 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/19238.py: -------------------------------------------------------------------------------- 1 | def getDistance(a,b): 2 | return abs(a[0] - b[0]) + abs(a[1] - b[1]) 3 | 4 | def get_next_pos(maze, taxi_pos, man_pos, visited): 5 | min_distance = 1000 6 | min_cur = [] 7 | next_list = [[1,0],[0,1],[-1,0],[0,-1]] 8 | 9 | for next in next_list: 10 | cur_pos = [taxi_pos[0] + next[0],taxi_pos[1] + next[1]] 11 | 12 | if cur_pos in visited : 13 | continue 14 | 15 | if maze[cur_pos[0]][cur_pos[1]] == 1 : 16 | continue 17 | 18 | cur_distance = getDistance(cur_pos, man_pos) 19 | 20 | if cur_distance < min_distance : 21 | min_distance = cur_distance 22 | min_cur = cur_pos 23 | 24 | visited.append(min_cur) 25 | return min_cur 26 | 27 | def get_visited(maze, taxi_input, man_input): 28 | taxi_pos = taxi_input 29 | man_pos = man_input 30 | visited = [] 31 | 32 | while taxi_pos != man_pos: 33 | taxi_pos = get_next_pos(maze, taxi_pos, man_pos, visited) 34 | 35 | print(visited) 36 | 37 | 38 | if __name__ == "__main__": 39 | input_info = list(map(int, input().split())) 40 | maze_len = input_info[0] + 2 41 | maze = [] 42 | 43 | for i in range(0, maze_len): 44 | maze_row = [] 45 | if i == 0 or i == maze_len-1: 46 | for j in range(0, maze_len): 47 | maze_row.append(1) 48 | maze.append(maze_row) 49 | continue 50 | 51 | maze_data = list(map(int, input().split())) 52 | maze_row.append(1) 53 | maze.append(maze_row + maze_data + maze_row) 54 | 55 | for el in maze : 56 | print(el) 57 | 58 | taxi_input = [6,5] 59 | taxi_oil = 15 60 | man_input = [2,2] 61 | 62 | get_visited(maze,taxi_input,man_input) 63 | 64 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1932.md: -------------------------------------------------------------------------------- 1 | # 1932 - 성공 2 | 3 | ## DP 4 | 5 | 삼각형 6 | 7 | ```python 8 | i=0 0 9 | i=1 1 2 10 | i=2 3 4 5 11 | i=3 6 7 8 9 12 | 13 | i 값과, a_index값(위 삼각형의 숫자값이 a_index)을 활용 14 | ``` 15 | 16 | data에 입력을 담고, 17 | 18 | a에 평탄화된 data를 담음. ([1],[2,3]) → ([1,2,3]) 19 | 20 | base dp : dp[0], dp[1], dp[2] 구해놓고. 21 | 22 | dp[n]에서 n이 삼각형 한 row의 맨 앞일 경우 23 | 24 | ```python 25 | dp[a_index] = dp[a_index-i] + a[a_index] 26 | ``` 27 | 28 | dp[n]에서 n이 삼각형 한 row의 맨 뒤일 경우 29 | 30 | ```python 31 | dp[a_index] = dp[a_index-i-1] + a[a_index] 32 | ``` 33 | 34 | dp[n]에서 n이 삼각형 한 row의 맨앞 또는 맨 뒤가 아닌, 중간일 경우 35 | 36 | ```python 37 | dp[a_index] = max(dp[a_index-i-1] + a[a_index], dp[a_index-i] + a[a_index]) 38 | ``` 39 | 40 | 이때 dp의 최대값을 출력해주면 된다. 41 | 42 | ### 이슈 43 | 44 | - 전형적인 DP문제. 근데 계산이 조금 복합해서 오래걸렸음. 45 | 46 | ### 보완 47 | 48 | - 더 많이 풀자 49 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1932.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import itertools 3 | N = int(sys.stdin.readline()) 4 | 5 | data = [] 6 | for _ in range(N): 7 | data.append(list(map(int,sys.stdin.readline().strip().split()))) 8 | 9 | print("data:",data) 10 | 11 | def chain(*iterables): # 참조 : https://winterj.me/list_of_lists_to_flatten/ 12 | # chain('ABC', 'DEF') --> A B C D E F 13 | for it in iterables: 14 | for element in it: 15 | yield element 16 | 17 | a = list(itertools.chain(*data)) 18 | print("a:",a) 19 | 20 | def calc(data, a): 21 | 22 | dp = [0]*501 23 | dp[0] = a[0] 24 | 25 | if N == 1: 26 | return (dp[0]) 27 | 28 | 29 | dp[1] = a[0] + a[1] 30 | dp[2] = a[0] + a[2] 31 | 32 | if N == 2: 33 | return max(dp[1], dp[2]) 34 | 35 | a_index = 0 36 | 37 | for i, row in enumerate(data) : 38 | print(i) 39 | if i == 0: 40 | continue 41 | 42 | for j, el in enumerate(row): 43 | a_index += 1 44 | if j == 0 : 45 | dp[a_index] = dp[a_index-i] + a[a_index] 46 | continue 47 | 48 | if j == len(row)-1: 49 | dp[a_index] = dp[a_index-i-1] + a[a_index] 50 | continue 51 | 52 | dp[a_index] = max(dp[a_index-i-1] + a[a_index], dp[a_index-i]+a[a_index]) 53 | 54 | return(max(dp)) 55 | 56 | print(calc(data ,a)) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1946.md: -------------------------------------------------------------------------------- 1 | # 1946 - 성공 2 | 3 | ## 그리디 알고리즘 4 | 5 | - 먼저 [i][0]을 정렬해줌. 6 | - [i][0]은 [j][0]보다 항상 큰 상태, 여기서 [i][1] 마저 크면, 선발되지 않는다. 7 | - 선발되지 않는 수를 구해서, 전체 수에서 빼서 결과 도출. 8 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1946.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def check_score(score_list): 4 | count = 0 5 | 6 | for i in range(0,len(score_list)-1): 7 | check = False 8 | for j in range(i+1, len(score_list)): 9 | print(i,j, score_list[i][1], score_list[j][1]) 10 | if score_list[i][1] > score_list[j][1]: #[i][0]은 [j][0]보다 항상 큰 상태, 여기서 [1] 마저 크면, 11 | print(i,j) 12 | check = True 13 | count += 1 14 | break 15 | 16 | return count 17 | 18 | 19 | if __name__ == "__main__": 20 | T = int(sys.stdin.readline()) 21 | for i in range(T): 22 | N = int(sys.stdin.readline()) 23 | score_list = [] 24 | for j in range(N): 25 | score_list.append(list(map(int,sys.stdin.readline().strip().split()))) 26 | 27 | score_list.sort(reverse=True) 28 | print(score_list) 29 | print("Score:", N - check_score(score_list)) 30 | 31 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/1991.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | class Node: 4 | def __init__(self, data): 5 | self.data = data 6 | self.left = None 7 | self.right = None 8 | 9 | class Tree: 10 | def __init__(self, root_node): 11 | self.root = root_node 12 | 13 | def insert(self, node, mid, left, right): 14 | if node.data == mid: 15 | node.left = Node(left) 16 | node.right = Node(right) 17 | return 18 | 19 | if node.left == None : 20 | return 21 | if node.right == None : 22 | return 23 | 24 | self.insert(node.left, mid, left, right) 25 | self.insert(node.right, mid, left, right) 26 | 27 | return 28 | 29 | def pre_order(self, node): # root == 'A' 30 | if node.data != '.' : 31 | print(node.data, end=('')) 32 | 33 | if node.left == None : 34 | return 35 | if node.right == None : 36 | return 37 | 38 | self.pre_order(node.left) 39 | self.pre_order(node.right) 40 | return 41 | 42 | def post_order(self, node): 43 | 44 | if node.left == None : 45 | return 46 | if node.right == None : 47 | return 48 | 49 | self.post_order(node.left) 50 | self.post_order(node.right) 51 | 52 | if node.data != '.' : 53 | print(node.data, end=('')) 54 | 55 | return 56 | 57 | def in_order(self, node): 58 | 59 | if node.left == None : 60 | return 61 | if node.right == None : 62 | return 63 | 64 | self.in_order(node.left) 65 | 66 | if node.data != '.' : 67 | print(node.data, end=('')) 68 | 69 | self.in_order(node.right) 70 | 71 | return 72 | 73 | n = int(sys.stdin.readline().strip()) 74 | 75 | root_node = Node('A') 76 | tree = Tree(root_node) 77 | 78 | for i in range(0, n): 79 | cmd = list(sys.stdin.readline().strip().split()) 80 | tree.insert(root_node, cmd[0], cmd[1], cmd[2]) 81 | 82 | tree.pre_order(root_node) 83 | print() 84 | tree.in_order(root_node) 85 | print() 86 | tree.post_order(root_node) 87 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2011.md: -------------------------------------------------------------------------------- 1 | # 2011 - 힌트 2 | 3 | ## DP 4 | 5 | 처음엔 모든 경우의 수를 구해서, 6 | 7 | 2개씩 묶이는게 0 0 and int(input[0]) < 3: 16 | dp[1] = 1 17 | else: 18 | return 0 19 | 20 | if int(input[1]) != 0: # input[1]이 0이 아니고, 21 | if (int(input[1]) < 7 and int(input[0]) == 2) or int(input[0]) == 1: # 10 ~ 26 사이면 22 | dp[1] = 2 23 | else: 24 | dp[1] = 1 25 | 26 | if len(input) == 2: # 입력이 두개면 return 27 | return dp[1] 28 | 29 | n = 2 30 | while n < len(input): # dp[2] 부터 여기서 구함. 31 | if int(input[n]) > 0: # input[n]이 0보다 클 경우는 input[n-1]에 그대로 붙여줄 수 있음. 32 | dp[n] = dp[n-1] 33 | 34 | # n,n-1이 10 ~ 26 사이면, dp[n-2]에 10~26을 붙일 수 있음. 35 | if (int(input[n]) < 7 and int(input[n-1]) == 2) or int(input[n-1]) == 1: 36 | dp[n] = (dp[n-2] + dp[n]) 37 | 38 | n += 1 39 | 40 | return(dp[len(input)-1] % 1000000) 41 | 42 | 43 | print(calc(input, dp)) 44 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2178.md: -------------------------------------------------------------------------------- 1 | # 2178 - 성공(힌트) 2 | 3 | ## BFS 4 | 5 | bfs로 풀어서 성공 6 | 7 | bfs에서 최단경로를 구할때는 q_size를 이용해서 큐에 넣기 전 계층 단위로 count 해주는 방법이 있다. 8 | 9 | 또 다른 방법도 많은것 같은데. 일단 이것 이해하고 품.. 10 | 11 | 테케 12 | 13 | ``` 14 | 2 2 15 | 11 16 | 11 17 | 18 | 3 3 19 | 111 20 | 111 21 | 111 22 | 23 | 4 7 24 | 1110111 25 | 1011101 26 | 1000001 27 | 1111111 28 | 29 | 2 100 30 | 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 31 | 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 32 | 33 | 6 5 34 | 11111 35 | 10001 36 | 10101 37 | 10111 38 | 10000 39 | 11111 40 | 41 | 4 7 42 | 1110110 43 | 0011110 44 | 0001011 45 | 0001111 46 | ``` 47 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2178.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | N, M = map(int, sys.stdin.readline().strip().split()) 5 | data = [[0]*(M+2)] 6 | for _ in range(N): 7 | input_arr = '0' + str(sys.stdin.readline().strip().split()[0]) + '0' 8 | splited_arr = [int(i) for i in input_arr] 9 | data.append(splited_arr) 10 | 11 | data.append([0]*(M+2)) 12 | print(N, M, data) 13 | 14 | 15 | def bfs(init, N, M, data): 16 | global count 17 | global visited 18 | global queue 19 | 20 | queue.append(init) 21 | while queue: 22 | q_size = len(queue) 23 | 24 | for _ in range(q_size): 25 | el = queue.popleft() 26 | Y = el[0] 27 | X = el[1] 28 | if el not in visited and data[Y][X] == 1: 29 | visited.append(el) 30 | print(el) 31 | 32 | if X == M and Y == N: 33 | print("도착") 34 | print(visited) 35 | print(count) 36 | break 37 | 38 | right = [Y, X+1] 39 | down = [Y+1, X] 40 | left = [Y, X-1] 41 | up = [Y-1, X] 42 | 43 | for pos in [right, down, left, up]: 44 | if data[pos[0]][pos[1]] != 0: 45 | queue.append(pos) 46 | count += 1 47 | 48 | 49 | count = 1 50 | visited = [] 51 | queue = deque([]) 52 | 53 | 54 | def calc(N, M, data): 55 | global count 56 | global visited 57 | init = [1, 1] 58 | bfs(init, N, M, data) 59 | 60 | 61 | calc(N, M, data) 62 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2502.md: -------------------------------------------------------------------------------- 1 | # 2502 - 성공 2 | 3 | ## DP 4 | 5 | dp[n] = dp[n-1] + dp[n] 6 | dp[1] = 'a' 7 | dp[2] = 'b' 8 | 9 | 로 주고, dp를 구하면 10 | 11 | dp[K] = 'bababbab' 이런식으로 나온다. 12 | 이걸 13 | 14 | count_a x j + count_b x i == K 식으로 바꿔서 15 | 16 | i, j 이중포문 돌려서 구함 17 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2502.py: -------------------------------------------------------------------------------- 1 | import sys 2 | D, K = list(map(int, input().split())) 3 | dp = [0]*(D+1) 4 | 5 | dp[1] = 'a' 6 | dp[2] = 'b' 7 | 8 | idx = 3 9 | 10 | while True: 11 | dp[idx] = dp[idx-2] + dp[idx-1] 12 | 13 | if idx == D: 14 | print(dp) 15 | break 16 | 17 | idx += 1 18 | 19 | count_A = dp[D].count('a') 20 | count_B = dp[D].count('b') 21 | 22 | def calc(count_A, count_B): 23 | for i in range(1, K): 24 | for j in range(1, K): 25 | if (count_A * j + count_B * i) == K: 26 | print(j) 27 | print(i) 28 | return 29 | 30 | 31 | calc(count_A, count_B) 32 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2579.md: -------------------------------------------------------------------------------- 1 | # 2579 - 성공 (힌트) 2 | 3 | ## DP 4 | 5 | dp[1], dp[2], dp[3] 베이스로 구하고 6 | 7 | ``` 8 | dp[n] = max( 9 | 10 | dp[n-2] + a[n] , 11 | 12 | dp[n-3] + a[n-1] + a[n] 13 | 14 | ) 15 | ``` 16 | 17 | a[n]번째를 밟기 위해선 아래 두가지 케이스가 와야한다. 18 | a[n-2] → 0 → a[n] [n-2]번째를 밟는 경우. 19 | a[n-3] → 0 → a[n-1] → a[n] [n-3]번째를 밟는 경우. 20 | 21 | 이 두 경우중 하나가 a[n]번째의 경우의 수로써 가능하고, 22 | 이때 최소값을 구하면 된다. 23 | 따라서 점화식이 위와 같이 된다. 24 | 25 | ## 보완 26 | 27 | - 힌트보고 풀었다. dp 감이 슬슬 잡히긴 하는데 여전히 쉽지 않다 😥 28 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2579.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | N = int(sys.stdin.readline()) 4 | 5 | score_list = [] 6 | for _ in range(N): 7 | score_list.append(int(sys.stdin.readline())) 8 | 9 | def get_dp_3(a,b,c,d): 10 | max = a+b+d 11 | if a+c+d > max: 12 | max = a+c+d 13 | 14 | if b+c > max: 15 | max = b+c 16 | 17 | return max 18 | 19 | def get_max(a,b): 20 | if a>b: 21 | return a 22 | 23 | return b 24 | 25 | def calc(score_list): 26 | dp = [0]*301 27 | dp[0] = score_list[0] 28 | if N==1 : 29 | print(dp[0]) 30 | return 31 | 32 | dp[1] = score_list[1] + score_list[0] 33 | if N==2 : 34 | print(dp[1]) 35 | return 36 | 37 | dp[2] = get_max(score_list[0],score_list[1]) + score_list[2] 38 | if N==3 : 39 | print(dp[2]) 40 | return 41 | 42 | dp[3] = get_dp_3(score_list[0],score_list[1],score_list[2],score_list[3]) 43 | if N==4 : 44 | print(dp[3]) 45 | return 46 | 47 | print(dp[0],dp[1],dp[2],dp[3]) 48 | for i in range(4, N): 49 | dp[i] = get_max(dp[i-2], dp[i-3]+score_list[i-1])+score_list[i] 50 | print(i, dp[i]) 51 | print(dp[len(score_list)-1]) 52 | return 53 | 54 | calc(score_list) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2606.md: -------------------------------------------------------------------------------- 1 | # 2606 - 성공 2 | 3 | ## 백트래킹 문제 4 | 5 | - 가장 기본적인 백트래킹 문제로써, BFS, DFS (스택, 재귀) 뭘 써도 잘 풀림. 6 | - 그래서 하나씩 구현해서 통과시키면서 연습. 7 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2606.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | 4 | n = int(sys.stdin.readline().strip()) 5 | m = int(sys.stdin.readline().strip()) 6 | 7 | datas = [] 8 | 9 | for i in range(0,m): 10 | datas.append(list(map(int,list(sys.stdin.readline().strip().split())))) 11 | 12 | dic = {} 13 | for value in datas: 14 | try: 15 | if len(dic[value[0]]) != 0 : 16 | dic[value[0]].add(value[1]) 17 | except : 18 | dic[value[0]] = set([value[1]]) 19 | 20 | for value in datas: 21 | try: 22 | if len(dic[value[1]]) != 0 : 23 | dic[value[1]].add(value[0]) 24 | except : 25 | dic[value[1]] = set([value[0]]) 26 | 27 | print(dic) 28 | visited = set() 29 | def dfs_recursive(root, dic): 30 | visited.add(root) 31 | 32 | for key, values in dic.items(): 33 | if key == root : 34 | for value in values : 35 | if value in visited: 36 | continue 37 | visited.add(value) 38 | dfs_recursive(value, dic) 39 | 40 | def dfs_stack(root, dic): 41 | stack = [root] 42 | 43 | while stack : 44 | root = stack.pop() 45 | 46 | for key, values in dic.items(): 47 | if key == root : 48 | for value in values : 49 | if value in visited: 50 | continue 51 | visited.add(value) 52 | stack.append(value) 53 | 54 | def bfs_queue(root, dic): 55 | queue = deque() 56 | queue.append(root) 57 | 58 | while queue : 59 | root = queue.popleft() 60 | 61 | for key, values in dic.items(): 62 | if key == root : 63 | for value in values : 64 | if value in visited: 65 | continue 66 | visited.add(value) 67 | queue.append(value) 68 | 69 | bfs_queue(1,dic) 70 | print(visited) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2644.md: -------------------------------------------------------------------------------- 1 | # 2644 - 성공 2 | 3 | ## DFS 4 | 5 | 그림과 같은 경우에 촌수 비교 방식을 6과 10을 비교한다면 6 | 7 | 1 → 2 → 4 → 8 → 10 8 | 9 | 1 → 2 → 6 10 | 11 | 에서, 공통되는 1 → 2 부분을 제외하고 길이를 더해주면 촌수가 됨. 12 | 13 | 여기서 root가 항상 1이라거나, 부모가 항상 작은 수라거나 하는 조건이 없었기 때문에 14 | 15 | 트리의 root를 누구로 잡아줄까? 가 처음 이슈였다. 16 | 17 | 모든 부모를 다 root로 해서 dfs로 체크해보면 어떨까? 18 | 19 | ```python 20 | for 부모 in 모든부모 : 21 | dps(부모, target_A) 22 | dps(부모, target_B) 23 | ``` 24 | 25 | 모든 부모를 한번씩 다 root로 해주고 26 | 27 | result가 제대로 나오는 경우에만 촌수를 계산해줌. 28 | 29 | result가 제대로 나오는 경우는, root로 부터 target_A와 target_B에 둘다 도달한 경우를 의미. 30 | 31 | dfs를 통해 target에 도달하게 되면 지나온 경로를 result_A, B 에 저장한다. 32 | 33 | result_A, B는 set 자료구조를 사용했으며, intersection을 사용하여 공통되는 부분을 제외해준다. 34 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2644.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | N = int(sys.stdin.readline()) 4 | A, B = map(int,sys.stdin.readline().strip().split()) 5 | M = int(sys.stdin.readline()) 6 | 7 | dic = {} 8 | for _ in range(M): 9 | parent, child = map(int,sys.stdin.readline().strip().split()) 10 | try: 11 | if dic[parent] : 12 | dic[parent].append(child) 13 | except : 14 | dic[parent] = [child] 15 | print(dic) 16 | 17 | def dps(root, target, result): 18 | try: 19 | if dic[root]: 20 | if target in dic[root]: 21 | result.add(root) 22 | result.add(target) 23 | return True 24 | 25 | for el in dic[root]: 26 | target_flag = dps(el, target, result) 27 | if target_flag == True: 28 | result.add(root) 29 | return True 30 | 31 | except: 32 | return False 33 | 34 | 35 | def solution(N, A, B, M, dic): 36 | for parent in dic : 37 | result_A = set([parent]) 38 | result_B = set([parent]) 39 | dps(parent, A, result_A) 40 | dps(parent, B, result_B) 41 | 42 | if (A in result_A) and (B in result_B): 43 | intersec = result_A & result_B 44 | return abs(len(result_A - intersec) + len(result_B - intersec)) 45 | 46 | return -1 47 | 48 | print(solution(N, A, B, M, dic)) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/2957.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | n = int(sys.stdin.readline().strip()) 4 | arr = [] 5 | input = 0 6 | for i in range(0, n): 7 | input = int(sys.stdin.readline().strip()) 8 | 9 | if i == 0 : 10 | arr.append(input) 11 | continue 12 | 13 | if arr 14 | 15 | 16 | print(n,m) -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/7569.md: -------------------------------------------------------------------------------- 1 | # 7569 - 성공(힌트) 2 | 3 | ## BFS 4 | 5 | - 처음에는 모든 값들을 순환하여 값이 1일 경우에 알고리즘을 동작하도록 구현. => 시간초과 6 | - 값이 1인 경우를 맨 처음에 찾아 큐에 담아놓고, 큐에 있는 값을 바로 접근해서 알고리즘을 동작해주는 방식으로 구현하니 해결됨. 7 | 8 | ### 이슈 9 | 10 | - count를 세는 방식이 각자 달랐음. 나는 큐를 한번 수행할때마다 count해주도록 했음. 11 | - try catch를 써서 list의 범위를 넘어가는 경우 pass되도록 구현했는데, arr[-1]과 같은 경우 에러가 걸리지 않고 맨 뒤의 값에서부터 가져오는방식으로 정상동작이 됨. 12 | - 예상치못한 버그가 발생될 수 있으니 기억하도록!! 13 | 14 | ### 보완 15 | 16 | - 이런 문제는 테케를 만드는게 굉장히 빡세다. 질문검색을 찾아보기만 하지 말고 직접 만들어보는것도 연습.. 하면 좋을것같은데 할수있으려나..ㅎㅎ 17 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/9095.md: -------------------------------------------------------------------------------- 1 | # 9095 - 성공 (힌트) 2 | 3 | ## DP 4 | 5 | base dp 를 1,2,3으로 두고 6 | 7 | ``` 8 | 4 = 1+3 9 | = 2+2 10 | = 3+1 11 | 12 | dp[4] = 1 + dp[3] 13 | = 2 + dp[2] 14 | = 3 + dp[1] 15 | 16 | 5 = 1+4 17 | = 2+3 18 | = 3+2 19 | 20 | dp[5] = 1 + dp[4] 21 | = 2 + dp[3] 22 | = 3 + dp[2] 23 | 24 | 6 = 1+5 25 | = 2+4 26 | = 3+3 27 | 28 | dp[n] = 1 + dp[n-1] 29 | = 2 + dp[n-2] 30 | = 3 + dp[n-3] 31 | ``` 32 | 33 | 1,2,3은 값이 아니라, 경우의 수 이다. 34 | 1 + dp[n-1] 이 되는 경우의 수, 35 | 2 + dp[n-2] 이 되는 경우의 수, 36 | 3 + dp[n-3] 이 되는 경우의 수 37 | 이 3 종류 경우의 수가 합해서 dp[n]이 된다. 38 | 39 | 따라서 dp[n] = dp[n-1] + dp[n-2] + dp[n-3]으로 점화식을 만들 수 있다. 40 | 41 | ## 보완 42 | 43 | - DP문제인데 DP로 안풀었다. 😂 44 | - 도호님 방법 처럼 DP로 풀어볼 필요도 있을듯.. 45 | -------------------------------------------------------------------------------- /src/grap3fruit/py/boj/9095.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | T = int(sys.stdin.readline()) 4 | N_list = [] 5 | for _ in range(T): 6 | N_list.append(int(sys.stdin.readline())) 7 | 8 | dp = [0]*11 9 | dp[1] = 1 10 | dp[2] = 2 11 | dp[3] = 4 12 | 13 | for N in N_list: 14 | if N <= 3: 15 | print(dp[N]) 16 | continue 17 | 18 | index = 4 19 | while True: 20 | dp[index] = dp[index-1] + dp[index-2] + dp[index-3] 21 | if index == N: 22 | print(dp[index]) 23 | break 24 | 25 | index += 1 -------------------------------------------------------------------------------- /src/grap3fruit/py/input_test.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from collections import deque 3 | #n, m = map(int,sys.stdin.readline().strip().split()) 4 | #num = list(map(int,sys.stdin.readline().strip().split())) 5 | 6 | # 7 | #datas = list(map(int,sys.stdin.readline().strip().split())) 8 | 9 | #print(num[0]*num[1]) 10 | 11 | 12 | ## case ## 13 | # 5 14 | # 3 2 1 -3 -1 15 | 16 | n = int(sys.stdin.readline()) 17 | arr = list(map(int,sys.stdin.readline().strip().split())) 18 | 19 | 20 | ## case ## 21 | # 1 2 3 4 5 22 | 23 | num_list = list(map(int, input().split())) 24 | 25 | ## case ## 26 | # abcd 27 | # 3 28 | # P x 29 | # L 30 | # P y 31 | 32 | input_data = sys.stdin.readline().strip() 33 | cmd_count = int(sys.stdin.readline().strip()) 34 | cmd = [] 35 | 36 | for i in range(0, cmd_count): 37 | cmd.append(list(sys.stdin.readline().strip().split())) -------------------------------------------------------------------------------- /src/grap3fruit/py/programmers/17685.py: -------------------------------------------------------------------------------- 1 | words = ["go","gone","guild"] 2 | 3 | -------------------------------------------------------------------------------- /src/grap3fruit/py/programmers/42578.py: -------------------------------------------------------------------------------- 1 | import itertools 2 | 3 | clothes = [["yellow_hat", "headgear"], ["blue_sunglasses", "eyewear"], ["green_turban", "headgear"], ["bluen_turban", "headgear"], ["blue_sung1", "eyewear"], ["blue1g1", "shoes"], ["blue_1", "shoes"]] 4 | 5 | answer = 0 6 | bucket = {} 7 | 8 | for cloth in clothes: 9 | cloth_type = cloth[1] 10 | if not cloth_type in bucket : 11 | bucket[cloth_type] = 1 12 | 13 | elif cloth_type in bucket : 14 | bucket[cloth_type] += 1 15 | 16 | arr = list(bucket.values()) 17 | 18 | result = 0 19 | for i in range(1, len(arr)+1): 20 | nCr = itertools.combinations(arr, i) 21 | calc_arr = list(nCr) 22 | print(calc_arr) 23 | for j in range(0, len(calc_arr)): 24 | multi = 1 25 | for el in calc_arr[j] : 26 | multi *= el 27 | 28 | result += multi 29 | 30 | print(result) 31 | -------------------------------------------------------------------------------- /src/kyu9341/11286/Main.java: -------------------------------------------------------------------------------- 1 | package boj11286; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.Comparator; 7 | import java.util.PriorityQueue; 8 | 9 | public class Main { 10 | 11 | static int n; 12 | static PriorityQueue pq = new PriorityQueue<>(new Comparator() { 13 | @Override 14 | public int compare(Integer o1, Integer o2) { 15 | if (Math.abs(o1) == Math.abs(o2)) return o1 > o2 ? 1 : -1; 16 | return Math.abs(o1) > Math.abs(o2) ? 1 : -1; 17 | } 18 | }); 19 | 20 | public static void main(String[] args) throws IOException { 21 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 22 | n = Integer.parseInt(br.readLine()); 23 | StringBuilder sb = new StringBuilder(); 24 | for (int i = 0; i < n; i++) { 25 | int x = Integer.parseInt(br.readLine()); 26 | if (x == 0) { 27 | if (pq.isEmpty()) sb.append("0" + '\n'); 28 | else sb.append(pq.poll().toString() + '\n'); 29 | } 30 | else pq.add(x); 31 | } 32 | System.out.println(sb); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/kyu9341/11286/README.md: -------------------------------------------------------------------------------- 1 | # Problem 11286 2 | 3 | ## 절대값 힙 4 | 5 | ### 문제 링크 6 | 7 | 8 | 9 | ### solve 10 | 11 | - 우선순위 큐를 활용하여 절대값이 작은 수에 가장 높은 우선순위를 주어 구현했다. 12 | - 이 때, 절대값이 같은 경우 더 작은 수가 우선이 되는 것을 고려한다. 13 | 14 | ### 코드 15 | ```java 16 | import java.io.BufferedReader; 17 | import java.io.IOException; 18 | import java.io.InputStreamReader; 19 | import java.util.Comparator; 20 | import java.util.PriorityQueue; 21 | 22 | public class Main { 23 | 24 | static int n; 25 | static PriorityQueue pq = new PriorityQueue<>(new Comparator() { 26 | @Override 27 | public int compare(Integer o1, Integer o2) { 28 | if (Math.abs(o1) == Math.abs(o2)) return o1 > o2 ? 1 : -1; 29 | return Math.abs(o1) > Math.abs(o2) ? 1 : -1; 30 | } 31 | }); 32 | 33 | public static void main(String[] args) throws IOException { 34 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 35 | n = Integer.parseInt(br.readLine()); 36 | StringBuilder sb = new StringBuilder(); 37 | for (int i = 0; i < n; i++) { 38 | int x = Integer.parseInt(br.readLine()); 39 | if (x == 0) { 40 | if (pq.isEmpty()) sb.append("0" + '\n'); 41 | else sb.append(pq.poll().toString() + '\n'); 42 | } 43 | else pq.add(x); 44 | } 45 | System.out.println(sb); 46 | } 47 | } 48 | ``` 49 | -------------------------------------------------------------------------------- /src/kyu9341/1158/Main.java: -------------------------------------------------------------------------------- 1 | package boj1158; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.ArrayList; 7 | import java.util.LinkedList; 8 | import java.util.Queue; 9 | import java.util.StringTokenizer; 10 | 11 | public class Main { 12 | static int n, k; 13 | static Queue queue = new LinkedList<>(); 14 | static ArrayList res = new ArrayList<>(); 15 | public static void main(String[] args) throws IOException { 16 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 17 | StringTokenizer st = new StringTokenizer(br.readLine()); 18 | n = Integer.parseInt(st.nextToken()); 19 | k = Integer.parseInt(st.nextToken()); 20 | 21 | for (int i = 1; i <= n; i++) queue.add(i); 22 | 23 | while (!queue.isEmpty()) { 24 | for (int i = 0; i < k - 1; i++) queue.add(queue.poll()); 25 | res.add(queue.poll()); 26 | } 27 | 28 | StringBuilder sb = new StringBuilder(); 29 | sb.append("<"); 30 | for (int i = 0; i < res.size(); i++) { 31 | sb.append(res.get(i)); 32 | if (i != res.size() - 1) sb.append(", "); 33 | else sb.append(">"); 34 | } 35 | System.out.println(sb); 36 | } 37 | } 38 | 39 | -------------------------------------------------------------------------------- /src/kyu9341/1406/Main.java: -------------------------------------------------------------------------------- 1 | package boj1406; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.Stack; 7 | import java.util.StringTokenizer; 8 | 9 | public class Main { 10 | static String str; 11 | static int m; 12 | static Stack left = new Stack<>(); 13 | static Stack right = new Stack<>(); 14 | 15 | public static void main(String[] args) throws IOException { 16 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 17 | StringTokenizer st; 18 | str = br.readLine(); 19 | for (int i = 0; i < str.length(); i++) left.push(str.charAt(i)); 20 | 21 | m = Integer.parseInt(br.readLine()); 22 | for (int i = 0; i < m; i++) { 23 | String command = br.readLine(); 24 | if (command.charAt(0) == 'L' && !left.isEmpty()) right.push(left.pop()); 25 | else if (command.charAt(0) == 'D' && !right.isEmpty()) left.push(right.pop()); 26 | else if (command.charAt(0) == 'B' && !left.isEmpty()) left.pop(); 27 | else if (command.charAt(0) == 'P') left.push(command.charAt(2)); 28 | } 29 | 30 | while(!left.isEmpty()) right.push(left.pop()); 31 | StringBuilder sb = new StringBuilder(); 32 | while(!right.isEmpty()) sb.append(right.pop()); 33 | System.out.println(sb); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/kyu9341/1697/Main.java: -------------------------------------------------------------------------------- 1 | package boj1697; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.LinkedList; 7 | import java.util.Queue; 8 | import java.util.StringTokenizer; 9 | 10 | public class Main { 11 | 12 | static final int MAX = 100000; 13 | static int n, k; 14 | static boolean check[] = new boolean[MAX + 1]; 15 | static int sec[] = new int[MAX + 1]; 16 | 17 | public static void main(String[] args) throws IOException { 18 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 19 | StringTokenizer st = new StringTokenizer(br.readLine()); 20 | 21 | n = Integer.parseInt(st.nextToken()); 22 | k = Integer.parseInt(st.nextToken()); 23 | 24 | Queue q = new LinkedList<>(); 25 | 26 | q.add(n); 27 | check[n] = true; 28 | sec[n] = 0; 29 | 30 | while(!q.isEmpty()) { 31 | int cur = q.poll(); 32 | 33 | if (check[k]) break; 34 | 35 | if (cur * 2 <= MAX && !check[cur * 2]) { 36 | check[cur * 2] = true; 37 | sec[cur * 2] = sec[cur] + 1; 38 | q.add(cur * 2); 39 | } 40 | 41 | if (cur + 1 <= MAX && !check[cur + 1]) { 42 | check[cur + 1] = true; 43 | sec[cur + 1] = sec[cur] + 1; 44 | q.add(cur + 1); 45 | } 46 | 47 | if (cur - 1 >= 0 && !check[cur - 1]) { 48 | check[cur - 1] = true; 49 | sec[cur - 1] = sec[cur] + 1; 50 | q.add(cur - 1); 51 | } 52 | } 53 | 54 | System.out.println(sec[k]); 55 | 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/kyu9341/1697/README.md: -------------------------------------------------------------------------------- 1 | # Problem 1697 2 | 3 | ## 숨바꼭질 4 | 5 | ### 문제 링크 6 | 7 | 8 | 9 | ### solve 10 | - x + 1, x - 1, x * 2 로 bfs 11 | 12 | ### 코드 설명 13 | ```java 14 | import java.io.BufferedReader; 15 | import java.io.IOException; 16 | import java.io.InputStreamReader; 17 | import java.util.LinkedList; 18 | import java.util.Queue; 19 | import java.util.StringTokenizer; 20 | 21 | public class Main { 22 | 23 | static final int MAX = 100000; 24 | static int n, k; 25 | static boolean check[] = new boolean[MAX + 1]; 26 | static int sec[] = new int[MAX + 1]; 27 | 28 | public static void main(String[] args) throws IOException { 29 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 30 | StringTokenizer st = new StringTokenizer(br.readLine()); 31 | 32 | n = Integer.parseInt(st.nextToken()); 33 | k = Integer.parseInt(st.nextToken()); 34 | 35 | Queue q = new LinkedList<>(); 36 | 37 | q.add(n); 38 | check[n] = true; 39 | sec[n] = 0; 40 | 41 | while(!q.isEmpty()) { 42 | int cur = q.poll(); 43 | 44 | if (check[k]) break; 45 | 46 | if (cur * 2 <= MAX && !check[cur * 2]) { 47 | check[cur * 2] = true; 48 | sec[cur * 2] = sec[cur] + 1; 49 | q.add(cur * 2); 50 | } 51 | 52 | if (cur + 1 <= MAX && !check[cur + 1]) { 53 | check[cur + 1] = true; 54 | sec[cur + 1] = sec[cur] + 1; 55 | q.add(cur + 1); 56 | } 57 | 58 | if (cur - 1 >= 0 && !check[cur - 1]) { 59 | check[cur - 1] = true; 60 | sec[cur - 1] = sec[cur] + 1; 61 | q.add(cur - 1); 62 | } 63 | } 64 | 65 | System.out.println(sec[k]); 66 | 67 | } 68 | 69 | } 70 | 71 | ``` 72 | -------------------------------------------------------------------------------- /src/kyu9341/1991/Main.java: -------------------------------------------------------------------------------- 1 | package boj1991; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.StringTokenizer; 7 | 8 | public class Main { 9 | static int n; 10 | static Node[] tree = new Node[26]; 11 | 12 | public static void main(String[] args) throws IOException { 13 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 14 | StringTokenizer st; 15 | n = Integer.parseInt(br.readLine()); 16 | 17 | for (int i = 0; i < n; i++) { 18 | st = new StringTokenizer(br.readLine()); 19 | char root = st.nextToken().charAt(0); 20 | char left = st.nextToken().charAt(0); 21 | char right = st.nextToken().charAt(0); 22 | tree[root - 'A'] = new Node(left == '.' ? -1 : left, right == '.' ? -1 : right); 23 | } 24 | preorder('A'); 25 | System.out.println(); 26 | inorder('A'); 27 | System.out.println(); 28 | postorder('A'); 29 | 30 | } 31 | static void preorder(int root) { 32 | if (root == -1) return; 33 | System.out.print((char)root); 34 | preorder(tree[root - 'A'].left); 35 | preorder(tree[root - 'A'].right); 36 | } 37 | 38 | static void inorder(int root) { 39 | if (root == -1) return; 40 | inorder(tree[root - 'A'].left); 41 | System.out.print((char)root); 42 | inorder(tree[root - 'A'].right); 43 | } 44 | 45 | static void postorder(int root) { 46 | if (root == -1) return; 47 | postorder(tree[root - 'A'].left); 48 | postorder(tree[root - 'A'].right); 49 | System.out.print((char)root); 50 | } 51 | 52 | static class Node { 53 | int left; 54 | int right; 55 | Node (int left, int right){ 56 | this.left = left; 57 | this.right = right; 58 | } 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/kyu9341/2346/Main.java: -------------------------------------------------------------------------------- 1 | package boj2346; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.ArrayDeque; 7 | import java.util.Deque; 8 | import java.util.StringTokenizer; 9 | 10 | public class Main { 11 | 12 | static Deque dq = new ArrayDeque<>(); 13 | static int n; 14 | static Balloon[] balloon; 15 | 16 | public static void main(String[] args) throws IOException { 17 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 18 | n = Integer.parseInt(br.readLine()); 19 | balloon = new Balloon[n]; 20 | StringTokenizer st = new StringTokenizer(br.readLine()); 21 | for (int i = 1; i <= n; i++) { 22 | dq.add(new Balloon(i, Integer.parseInt(st.nextToken()))); 23 | } 24 | 25 | StringBuilder sb = new StringBuilder(); 26 | for (int i = 0; i < n; i++) { 27 | Balloon cur = dq.pollFirst(); 28 | sb.append(cur.num); 29 | if (i != n - 1) sb.append(" "); 30 | if (cur.count < 0) moveLeft(-cur.count); 31 | else moveRight(cur.count); 32 | } 33 | System.out.println(sb); 34 | } 35 | 36 | static void moveLeft(int num) { 37 | for (int i = 0; i < num; i++) { 38 | if (!dq.isEmpty()) dq.addFirst(dq.pollLast()); 39 | } 40 | } 41 | 42 | static void moveRight(int num) { // 우측으로 이동하는 경우는 한번 덜 이동 - 터트린 풍선은 개수 count 43 | for (int i = 0; i < num - 1; i++) { 44 | if (!dq.isEmpty()) dq.addLast(dq.pollFirst()); 45 | } 46 | } 47 | 48 | static class Balloon { 49 | int num; 50 | int count; 51 | public Balloon(int num, int count) { 52 | this.num = num; 53 | this.count = count; 54 | } 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /src/kyu9341/2606/Main.java: -------------------------------------------------------------------------------- 1 | package boj2606; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.ArrayList; 7 | import java.util.StringTokenizer; 8 | 9 | public class Main { 10 | 11 | static int n, m; 12 | static ArrayList> net = new ArrayList<>(); 13 | static boolean check[]; 14 | 15 | public static void main(String[] args) throws IOException { 16 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 17 | n = Integer.parseInt(br.readLine()); 18 | m = Integer.parseInt(br.readLine()); 19 | 20 | check = new boolean[n + 1]; 21 | 22 | for (int i = 0; i <= n; i++) { 23 | net.add(new ArrayList<>()); 24 | } 25 | 26 | for (int i = 0; i < m; i++) { 27 | StringTokenizer st = new StringTokenizer(br.readLine()); 28 | int u = Integer.parseInt(st.nextToken()); 29 | int v = Integer.parseInt(st.nextToken()); 30 | 31 | net.get(u).add(v); 32 | net.get(v).add(u); 33 | } 34 | 35 | dfs(1); 36 | 37 | int cnt = 0; 38 | for (int i = 1; i <= n; i++) { 39 | if (check[i]) cnt++; 40 | } 41 | 42 | System.out.println(cnt - 1); 43 | } 44 | 45 | static void dfs(int node) { 46 | if (check[node]) return; 47 | check[node] = true; 48 | 49 | for (int i = 0; i < net.get(node).size(); i++) { 50 | int next = net.get(node).get(i); 51 | if (!check[next]) { 52 | dfs(next); 53 | } 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/kyu9341/2606/README.md: -------------------------------------------------------------------------------- 1 | # Problem 2606 2 | 3 | ## 바이러스 4 | 5 | ### 문제 링크 6 | 7 | 8 | ### solve 9 | - 먼저 컴퓨터를 모두 연결시킨 후 dfs로 1번 컴퓨터와 연결된 컴퓨터를 모두 구한다. 10 | 11 | ### 코드 설명 12 | ```java 13 | import java.io.BufferedReader; 14 | import java.io.IOException; 15 | import java.io.InputStreamReader; 16 | import java.util.ArrayList; 17 | import java.util.StringTokenizer; 18 | 19 | public class Main { 20 | 21 | static int n, m; 22 | static ArrayList> net = new ArrayList<>(); 23 | static boolean check[]; 24 | 25 | public static void main(String[] args) throws IOException { 26 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 27 | n = Integer.parseInt(br.readLine()); 28 | m = Integer.parseInt(br.readLine()); 29 | 30 | check = new boolean[n + 1]; 31 | 32 | for (int i = 0; i <= n; i++) { 33 | net.add(new ArrayList<>()); 34 | } 35 | 36 | for (int i = 0; i < m; i++) { 37 | StringTokenizer st = new StringTokenizer(br.readLine()); 38 | int u = Integer.parseInt(st.nextToken()); 39 | int v = Integer.parseInt(st.nextToken()); 40 | 41 | net.get(u).add(v); 42 | net.get(v).add(u); 43 | } 44 | 45 | dfs(1); 46 | 47 | int cnt = 0; 48 | for (int i = 1; i <= n; i++) { 49 | if (check[i]) cnt++; 50 | } 51 | 52 | System.out.println(cnt - 1); 53 | } 54 | 55 | static void dfs(int node) { 56 | if (check[node]) return; 57 | check[node] = true; 58 | 59 | for (int i = 0; i < net.get(node).size(); i++) { 60 | int next = net.get(node).get(i); 61 | if (!check[next]) { 62 | dfs(next); 63 | } 64 | } 65 | } 66 | } 67 | 68 | ``` 69 | -------------------------------------------------------------------------------- /src/kyu9341/2957/Main.java: -------------------------------------------------------------------------------- 1 | package boj2957; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | 7 | public class Main { 8 | static int n; 9 | static int c = 0; 10 | 11 | public static void main(String[] args) throws IOException { 12 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 13 | n = Integer.parseInt(br.readLine()); 14 | Node root = new Node(Integer.parseInt(br.readLine())); 15 | for (int i = 0; i < n - 1; i++) { 16 | int x = Integer.parseInt(br.readLine()); 17 | insert(x, root); 18 | System.out.println(c); 19 | } 20 | } 21 | 22 | static void insert(int x, Node node) { 23 | c++; 24 | if (x < node.data) { 25 | if (node.left == null) node.left = new Node(x); 26 | else insert(x, node.left); 27 | } 28 | else { 29 | if (node.right == null) node.right = new Node(x); 30 | else insert(x, node.right); 31 | } 32 | } 33 | 34 | static class Node { 35 | int data; 36 | Node left; 37 | Node right; 38 | 39 | public Node(int data) { 40 | this.data = data; 41 | this.left = null; 42 | this.right = null; 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/kyu9341/2957/README.md: -------------------------------------------------------------------------------- 1 | # Problem 2957 2 | 3 | ## 이진 탐색 트리 4 | 5 | ### 문제 링크 6 | 7 | 8 | 9 | ### solve 10 | - 단순히 노드 클래스를 만들고 문제에서 주어진 대로 삽입 연산을 구현하니까 시간초과가 난다. 11 | - 졸리니까 일단 잔다..ㅜ 12 | 13 | 14 | ### 코드 설명 15 | ```java 16 | import java.io.BufferedReader; 17 | import java.io.IOException; 18 | import java.io.InputStreamReader; 19 | 20 | public class Main { 21 | static int n; 22 | static int c = 0; 23 | 24 | public static void main(String[] args) throws IOException { 25 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 26 | n = Integer.parseInt(br.readLine()); 27 | Node root = new Node(Integer.parseInt(br.readLine())); 28 | for (int i = 0; i < n - 1; i++) { 29 | int x = Integer.parseInt(br.readLine()); 30 | insert(x, root); 31 | System.out.println(c); 32 | } 33 | } 34 | 35 | static void insert(int x, Node node) { 36 | c++; 37 | if (x < node.data) { 38 | if (node.left == null) node.left = new Node(x); 39 | else insert(x, node.left); 40 | } 41 | else { 42 | if (node.right == null) node.right = new Node(x); 43 | else insert(x, node.right); 44 | } 45 | } 46 | 47 | static class Node { 48 | int data; 49 | Node left; 50 | Node right; 51 | 52 | public Node(int data) { 53 | this.data = data; 54 | this.left = null; 55 | this.right = null; 56 | } 57 | } 58 | } 59 | 60 | ``` 61 | -------------------------------------------------------------------------------- /src/kyu9341/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boost-algorithm/ProblemSolve/80e3e05653ca7ff63cbd88e23604d0cceab632dd/src/kyu9341/README.md -------------------------------------------------------------------------------- /src/kyu9341/boj1010_다리놓기/Main.java: -------------------------------------------------------------------------------- 1 | package boj1010_다리놓기; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.StringTokenizer; 7 | 8 | public class Main { 9 | 10 | static int t; 11 | static int n, m; 12 | 13 | public static void main(String[] args) throws IOException { 14 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 15 | StringTokenizer st; 16 | t = Integer.parseInt(br.readLine()); 17 | 18 | while (t-- > 0) { 19 | st = new StringTokenizer(br.readLine()); 20 | n = Integer.parseInt(st.nextToken()); 21 | m = Integer.parseInt(st.nextToken()); 22 | int max = Math.max(n, m - n); 23 | int min = Math.min(n, m - n); 24 | 25 | long tmp = 1; 26 | for (int i = m; i >= max + 1; i--) { 27 | tmp *= i; 28 | } 29 | 30 | long res = tmp / getFactorial(min); 31 | System.out.println(res); 32 | } 33 | 34 | } 35 | 36 | static long getFactorial(int n) { 37 | long res = 1; 38 | while (n > 0) { 39 | res *= n--; 40 | } 41 | return res; 42 | } 43 | 44 | 45 | } 46 | -------------------------------------------------------------------------------- /src/kyu9341/boj11047_동전0/Main.java: -------------------------------------------------------------------------------- 1 | package boj11047_동전0; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.ArrayList; 7 | import java.util.Stack; 8 | import java.util.StringTokenizer; 9 | 10 | public class Main { 11 | 12 | static int n; 13 | static int k; 14 | static Stack stack = new Stack<>(); 15 | 16 | public static void main(String[] args) throws IOException { 17 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 18 | StringTokenizer st = new StringTokenizer(br.readLine()); 19 | 20 | n = Integer.parseInt(st.nextToken()); 21 | k = Integer.parseInt(st.nextToken()); 22 | 23 | for (int i = 0; i < n; i++) { 24 | stack.push(Integer.parseInt(br.readLine())); 25 | } 26 | 27 | int cnt = 0; 28 | 29 | while (!stack.isEmpty()) { 30 | int cur = stack.pop(); 31 | if (k >= cur) { 32 | int q = k / cur; 33 | k -= q * cur; 34 | cnt += q; 35 | } 36 | } 37 | System.out.println(cnt); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/kyu9341/boj11399_ATM/11399_ATM.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int n; 8 | 9 | int main() { 10 | cin >> n; 11 | vector v(n); 12 | int sum = 0; 13 | 14 | for (int i = 0; i < n; i++) cin >> v[i]; 15 | 16 | sort(v.begin(), v.end()); 17 | 18 | int now = 0; 19 | for (int i = 0; i < n; i++) { 20 | now = now + v[i]; 21 | sum += now; 22 | } 23 | 24 | cout << sum << '\n'; 25 | } 26 | -------------------------------------------------------------------------------- /src/kyu9341/boj11497_통나무건너뛰기/Main.java: -------------------------------------------------------------------------------- 1 | package boj11497_통나무건너뛰기; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.*; 7 | 8 | public class Main { 9 | 10 | static int t; 11 | static int n; 12 | static Deque dq = new ArrayDeque<>(); 13 | 14 | public static void main(String[] args) throws IOException { 15 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 16 | n = Integer.parseInt(br.readLine()); 17 | 18 | while (n-- > 0) { 19 | t = Integer.parseInt(br.readLine()); 20 | ArrayList list = new ArrayList<>(t); 21 | StringTokenizer st = new StringTokenizer(br.readLine()); 22 | for (int i = 0; i < t; i++) { 23 | int cur = Integer.parseInt(st.nextToken()); 24 | list.add(cur); 25 | } 26 | 27 | list.sort(null); 28 | 29 | while (list.size() > 0) { 30 | dq.addLast(list.remove(list.size() - 1)); 31 | if (list.size() == 0) break; 32 | dq.addFirst(list.remove(list.size() - 1)); 33 | } 34 | 35 | int max = 0; 36 | int prev = dq.getLast(); 37 | 38 | while (!dq.isEmpty()) { 39 | int cur = dq.pollFirst(); 40 | int diff = Math.abs(prev - cur); 41 | if (max < diff) max = diff; 42 | prev = cur; 43 | } 44 | 45 | System.out.println(max); 46 | 47 | } 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/kyu9341/boj1149_RGB거리/Main.java: -------------------------------------------------------------------------------- 1 | package boj1149_RGB거리; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.StringTokenizer; 7 | 8 | public class Main { 9 | final static int MAX = 1000; 10 | final static int RED = 0; 11 | final static int GREEN = 1; 12 | final static int BLUE = 2; 13 | 14 | static int n; 15 | static int d[][] = new int[MAX + 1][3]; 16 | static int cost[][] = new int[MAX + 1][3]; 17 | 18 | public static void main(String[] args) throws IOException { 19 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 20 | StringTokenizer st; 21 | n = Integer.parseInt(br.readLine()); 22 | 23 | for (int i = 1; i <= n; i++) { 24 | st = new StringTokenizer(br.readLine()); 25 | cost[i][RED] = Integer.parseInt(st.nextToken()); 26 | cost[i][GREEN] = Integer.parseInt(st.nextToken()); 27 | cost[i][BLUE] = Integer.parseInt(st.nextToken()); 28 | } 29 | 30 | d[1][RED] = cost[1][RED]; 31 | d[1][GREEN] = cost[1][GREEN]; 32 | d[1][BLUE] = cost[1][BLUE]; 33 | 34 | for (int i = 1; i <= n; i++) { 35 | d[i][RED] = Math.min(d[i - 1][GREEN], d[i - 1][BLUE]) + cost[i][RED]; 36 | d[i][GREEN] = Math.min(d[i - 1][RED], d[i - 1][BLUE]) + cost[i][GREEN]; 37 | d[i][BLUE] = Math.min(d[i - 1][GREEN], d[i - 1][RED]) + cost[i][BLUE]; 38 | } 39 | 40 | int min = Math.min(d[n][RED], Math.min(d[n][GREEN], d[n][BLUE])); 41 | System.out.println(min); 42 | 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/kyu9341/boj1254_팰린드롬/Main.java: -------------------------------------------------------------------------------- 1 | package boj1254_팰린드롬; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | 7 | public class Main { 8 | 9 | static String S; 10 | 11 | public static void main(String[] args) throws IOException { 12 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 13 | S = br.readLine(); 14 | int ans = 0; 15 | 16 | for (int i = 0; i < S.length(); i++) { 17 | if (checkPalindrome(S, i)) { 18 | ans = S.length() + i; 19 | break; 20 | } 21 | } 22 | System.out.println(ans); 23 | 24 | } 25 | 26 | static boolean checkPalindrome(String s, int start) { 27 | int end = s.length() - 1; 28 | for (int i = start; i <= end; i++) { 29 | if (s.charAt(i) != s.charAt(end + start - i)) return false; 30 | } 31 | return true; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/kyu9341/boj17609_회문/17609_회문.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int t; 6 | 7 | int checkPalindrome(string str) { 8 | int len = str.size(); 9 | int left = 0; 10 | int right = len - 1; 11 | 12 | int leftPoint; 13 | int rightPoint; 14 | 15 | bool leftCheck = false; 16 | bool rightCheck = false; 17 | 18 | while (left < right) { 19 | if (str[left] != str[right]) { 20 | if (rightCheck && leftCheck) return 2; 21 | 22 | if (!rightCheck && !leftCheck) { 23 | leftPoint = left; 24 | rightPoint = right; 25 | if (left < right - 1) right--; 26 | rightCheck = true; 27 | continue; 28 | } 29 | 30 | if (rightCheck) { 31 | left = leftPoint; 32 | right = rightPoint; 33 | if (left + 1 < right) left++; 34 | leftCheck = true; 35 | continue; 36 | } 37 | 38 | } 39 | left++; 40 | right--; 41 | } 42 | if (leftCheck || rightCheck) return 1; 43 | return 0; 44 | } 45 | 46 | int main() { 47 | ios_base::sync_with_stdio(false); 48 | cin.tie(nullptr); 49 | cout.tie(nullptr); 50 | 51 | string str; 52 | 53 | cin >> t; 54 | cin.ignore(); 55 | 56 | while(t--) { 57 | cin >> str; 58 | cout << checkPalindrome(str) << '\n'; 59 | } 60 | } 61 | 62 | /* 63 | 풀이 64 | 좌측 끝과 우측 끝에서 한칸씩 중앙으로 이동하며 회문인지 판별 65 | -> 좌측 포인터와 우측 포인터 값이 같지 않다면 먼저 우측 포인터를 한칸 더 이동시킨다. 66 | -> 이후에 계속 진행하였을 때, 회문이라면 유사회문으로 판단 67 | -> 이후에 다시 값이 다른다면, 처음 값이 달랐던 지점으로 이동하여 왼쪽 포인터만 한칸 더 이동시킨다. 68 | -> 이번에도 다시 값이 다르다면, 이 문자열은 회문도, 유사회문도 아님 69 | -> 계속 진행하였을 때, 회문이라면 유사회문으로 판단 70 | */ 71 | -------------------------------------------------------------------------------- /src/kyu9341/boj1932_정수삼각형/Main.java: -------------------------------------------------------------------------------- 1 | package boj1932_정수삼각형; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.StringTokenizer; 7 | 8 | public class Main { 9 | final static int MAX = 500; 10 | static int n; 11 | static int tri[][] = new int[MAX + 1][MAX + 1]; 12 | static int d[][] = new int[MAX + 1][MAX + 1]; 13 | 14 | public static void main(String[] args) throws IOException { 15 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 16 | StringTokenizer st; 17 | 18 | n = Integer.parseInt(br.readLine()); 19 | for (int i = 1; i <= n; i++) { 20 | st = new StringTokenizer(br.readLine()); 21 | for (int j = 1; j <= i; j++) { 22 | tri[i][j] = Integer.parseInt(st.nextToken()); 23 | } 24 | } 25 | 26 | d[1][1] = tri[1][1]; 27 | 28 | for (int i = 2; i <= n; i++) { 29 | for (int j = 1; j <= n; j++) { 30 | d[i][j] = Math.max(d[i - 1][j - 1], d[i - 1][j]) + tri[i][j]; 31 | } 32 | } 33 | 34 | int ans = 0; 35 | 36 | for (int i = 1; i <= n; i++) { 37 | ans = Math.max(ans, d[n][i]); 38 | } 39 | 40 | System.out.println(ans); 41 | } 42 | 43 | } 44 | -------------------------------------------------------------------------------- /src/kyu9341/boj1946_신입사원/Main.java: -------------------------------------------------------------------------------- 1 | package boj1946_신입사원; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | import java.util.ArrayList; 7 | import java.util.Collections; 8 | import java.util.StringTokenizer; 9 | 10 | public class Main { 11 | 12 | static int t; 13 | static int n; 14 | 15 | 16 | public static void main(String[] args) throws IOException { 17 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 18 | StringTokenizer st; 19 | t = Integer.parseInt(br.readLine()); 20 | 21 | while (t-- > 0) { 22 | n = Integer.parseInt(br.readLine()); 23 | ArrayList people = new ArrayList<>(); 24 | 25 | for (int i = 0; i < n; i++) { 26 | st = new StringTokenizer(br.readLine()); 27 | int document = Integer.parseInt(st.nextToken()); 28 | int interview = Integer.parseInt(st.nextToken()); 29 | people.add(new Person(document, interview)); 30 | } 31 | 32 | Collections.sort(people); 33 | 34 | int cnt = 0; 35 | int target = people.get(0).interview; 36 | for (int i = 1; i < n; i++) { 37 | if (target < people.get(i).interview) cnt++; 38 | else target = people.get(i).interview; 39 | } 40 | 41 | System.out.println(n - cnt); 42 | } 43 | } 44 | 45 | static class Person implements Comparable{ 46 | int document; 47 | int interview; 48 | 49 | public Person(int document, int interview) { 50 | this.document = document; 51 | this.interview = interview; 52 | } 53 | 54 | @Override 55 | public int compareTo(Person o) { 56 | if (this.document == o.document) return this.interview - o.interview; 57 | return this.document - o.document; 58 | } 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/kyu9341/boj2178_미로탐색/2178_미로탐색.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | const int MAX = 100; 10 | int n, m; 11 | int dx[] = { 0, 0, 1, -1 }; 12 | int dy[] = { 1, -1, 0, 0 }; 13 | int map[MAX + 1][MAX + 1]; 14 | int dist[MAX + 1][MAX + 1]; 15 | queue< pair > q; 16 | 17 | void bfs(int sx, int sy) { 18 | q.push(make_pair(sx, sy)); 19 | dist[sx][sy] = 1; 20 | 21 | while(!q.empty()) { 22 | int x = q.front().first; 23 | int y = q.front().second; 24 | q.pop(); 25 | 26 | for (int i = 0; i < 4; i++) { 27 | int nx = x + dx[i]; 28 | int ny = y + dy[i]; 29 | 30 | if (!(nx >= 0 && ny >= 0 && nx < n && ny < m)) continue; 31 | if (dist[nx][ny] != -1 || map[nx][ny] != 1) continue; 32 | q.push(make_pair(nx, ny)); 33 | dist[nx][ny] = dist[x][y] + 1; 34 | } 35 | 36 | if (dist[n - 1][m - 1] != -1) break; 37 | } 38 | } 39 | 40 | int main() { 41 | 42 | cin >> n >> m; 43 | 44 | memset(dist, -1, sizeof(dist)); 45 | 46 | for (int i = 0; i < n; i++) 47 | for (int j = 0; j < m; j++) 48 | scanf("%1d", &map[i][j]); 49 | 50 | bfs(0, 0); 51 | 52 | cout << dist[n - 1][m - 1] << '\n'; 53 | } 54 | 55 | // C++ 사용자들 중에 숫자 하나씩을 떼어서 입력받고 싶어서 cin을 쓰다가 미로만 scanf로 입력받는 경우가 있습니다. 이 때에는 절대로 sync_with_stdio(false); 를 해서는 안 됩니다. 56 | -------------------------------------------------------------------------------- /src/kyu9341/boj2502_떡먹는호랑이/2502_떡먹는호랑이.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int day, cake; 7 | 8 | int main() { 9 | int A, B; 10 | 11 | cin >> day >> cake; 12 | vector< pair > d(day + 1); 13 | 14 | d[1] = make_pair(1, 0); 15 | d[2] = make_pair(0, 1); 16 | 17 | for (int i = 3; i <= day; i++) { 18 | d[i].first = d[i - 1].first + d[i - 2].first; 19 | d[i].second = d[i - 1].second + d[i - 2].second; 20 | } 21 | 22 | for (int i = 1; i <= cake; i++) { 23 | int cntA = d[day].first; 24 | int cntB = d[day].second; 25 | 26 | if ((cake - cntA * i) % cntB == 0) { 27 | A = i; 28 | B = (cake - cntA * A) / cntB; 29 | break; 30 | } 31 | } 32 | 33 | cout << A << '\n' << B << '\n'; 34 | } 35 | 36 | 37 | -------------------------------------------------------------------------------- /src/kyu9341/boj2579_계단오르기/Main.java: -------------------------------------------------------------------------------- 1 | package boj2579_계단오르기; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | 7 | public class Main { 8 | 9 | static final int MAX = 300; 10 | static int d[][] = new int[MAX + 1][3]; 11 | static int score[] = new int[MAX + 1]; 12 | static int n; 13 | 14 | public static void main(String[] args) throws IOException { 15 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 16 | n = Integer.parseInt(br.readLine()); 17 | 18 | for (int i = 1; i <= n; i++) score[i] = Integer.parseInt(br.readLine()); 19 | 20 | d[1][1] = score[1]; 21 | d[1][2] = score[1]; 22 | 23 | for (int i = 2 ; i<= n; i++) { 24 | d[i][1] = d[i - 1][2] + score[i]; 25 | d[i][2] = Math.max(d[i - 2][1] + score[i], d[i - 2][2] + score[i]); 26 | } 27 | 28 | System.out.println(Math.max(d[n][1], d[n][2])); 29 | 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/kyu9341/boj2644_촌수계산/2644_촌수계산.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | const int MAX = 100; 10 | int n, m; 11 | vector v[MAX + 1]; 12 | int dist[MAX + 1]; 13 | 14 | int main() { 15 | ios_base::sync_with_stdio(false); 16 | cin.tie(nullptr); 17 | cout.tie(nullptr); 18 | 19 | int x, y; 20 | 21 | cin >> n >> x >> y >> m; 22 | 23 | memset(dist, -1, sizeof(dist)); 24 | int parent, child; 25 | 26 | while (m--) { 27 | cin >> parent >> child; 28 | v[parent].push_back(child); 29 | v[child].push_back(parent); 30 | } 31 | 32 | queue q; 33 | dist[x] = 0; 34 | q.push(x); 35 | 36 | while(!q.empty()) { 37 | int cur = q.front(); 38 | q.pop(); 39 | 40 | for (int i = 0; i < v[cur].size(); i++) { 41 | int next = v[cur][i]; 42 | if (dist[next] != -1) continue; 43 | dist[next] = dist[cur] + 1; 44 | q.push(next); 45 | } 46 | 47 | if (dist[y] != -1) break; 48 | } 49 | 50 | cout << dist[y] << '\n'; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_가장긴팰린드롬/index.js: -------------------------------------------------------------------------------- 1 | const getLongestPalindrome = (left, right, arrFromStr) => { 2 | let maxLength = 0; 3 | const isInRange = (left, right) => left >= 0 && right < arrFromStr.length; 4 | 5 | while (isInRange(left, right)) { 6 | if (arrFromStr[left] !== arrFromStr[right]) return maxLength; 7 | 8 | maxLength = right - left + 1; 9 | left -= 1; 10 | right += 1; 11 | } 12 | 13 | return maxLength; 14 | }; 15 | 16 | const solution = s => { 17 | let maxLength = 0; 18 | const arrFromStr = [...s]; 19 | 20 | const checkLength = (_, index) => { 21 | const odd = getLongestPalindrome(index, index, arrFromStr); 22 | const even = getLongestPalindrome(index, index + 1, arrFromStr); 23 | maxLength = Math.max(maxLength, Math.max(odd, even)); 24 | }; 25 | 26 | arrFromStr.forEach(checkLength); 27 | 28 | return maxLength; 29 | }; 30 | 31 | (() => { 32 | const inputs = ['abcdcba', 'abacde']; 33 | 34 | inputs.forEach(input => console.log(solution(input))); 35 | })(); 36 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_네트워크/index.js: -------------------------------------------------------------------------------- 1 | const initArray = (size, val = null) => Array.from({ length: size }, () => val); 2 | const initArrayInArray = size => 3 | Array.from({ length: size }, () => new Array()); 4 | 5 | const solution = (n, computers) => { 6 | const network = initArrayInArray(n); 7 | const check = initArray(n, false); 8 | 9 | computers.forEach((row, rowIdx) => { 10 | row.forEach((computer, colIdx) => { 11 | if (rowIdx !== colIdx && computer) network[rowIdx].push(colIdx); 12 | }); 13 | }); 14 | 15 | const dfs = (node, network) => { 16 | check[node] = true; 17 | 18 | network[node].forEach((_, computer) => { 19 | const next = network[node][computer]; 20 | if (!check[next]) dfs(next, network); 21 | }); 22 | }; 23 | 24 | const answer = network.reduce((acc, _, computer) => { 25 | if (!check[computer]) { 26 | dfs(computer, network); 27 | return acc + 1; 28 | } 29 | return acc; 30 | }, 0); 31 | 32 | return answer; 33 | }; 34 | 35 | (() => { 36 | const inputs = [ 37 | [ 38 | [1, 1, 0], 39 | [1, 1, 0], 40 | [0, 0, 1], 41 | ], 42 | [ 43 | [1, 1, 0], 44 | [1, 1, 1], 45 | [0, 1, 1], 46 | ], 47 | ]; 48 | 49 | inputs.forEach(input => console.log(solution(input.length, input))); 50 | })(); 51 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_영어끝말잇기/index.js: -------------------------------------------------------------------------------- 1 | const solution = (n, words) => { 2 | const set = new Set(); 3 | let prevWrod = ''; 4 | 5 | for (const [idx, word] of words.entries()) { 6 | const beNotEqual = 7 | idx && prevWrod.charAt(prevWrod.length - 1) !== word.charAt(0); 8 | 9 | if (set.has(word) || beNotEqual) { 10 | const num = (idx + 1) % n || n; 11 | const count = Math.floor((idx + 1) / n) + Number(num !== n); 12 | 13 | return [num, count]; 14 | } 15 | 16 | set.add(word); 17 | prevWrod = word; 18 | } 19 | 20 | return [0, 0]; 21 | }; 22 | 23 | (() => { 24 | const inputs = [ 25 | { 26 | n: 3, 27 | words: [ 28 | 'tank', 29 | 'kick', 30 | 'know', 31 | 'wheel', 32 | 'land', 33 | 'dream', 34 | 'mother', 35 | 'robot', 36 | 'tank', 37 | ], 38 | }, 39 | { 40 | n: 5, 41 | words: [ 42 | 'hello', 43 | 'observe', 44 | 'effect', 45 | 'take', 46 | 'either', 47 | 'recognize', 48 | 'encourage', 49 | 'ensure', 50 | 'establish', 51 | 'hang', 52 | 'gather', 53 | 'refer', 54 | 'reference', 55 | 'estimate', 56 | 'executive', 57 | ], 58 | }, 59 | { n: 2, words: ['hello', 'one', 'even', 'never', 'now', 'world', 'draw'] }, 60 | ]; 61 | 62 | inputs.forEach(input => console.log(solution(input.n, input.words))); 63 | })(); 64 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_위장/Main.java: -------------------------------------------------------------------------------- 1 | package programmers42578; 2 | 3 | import java.util.HashMap; 4 | 5 | public class Solution { 6 | 7 | static HashMap map = new HashMap<>(); 8 | 9 | public int solution(String[][] clothes) { 10 | int answer = 1; 11 | for (int i = 0; i < clothes.length; i++) { 12 | if (map.get(clothes[i][1]) == null) map.put(clothes[i][1], 1); 13 | else map.put(clothes[i][1], map.get(clothes[i][1]) + 1); 14 | } 15 | for (String key : map.keySet()) answer *= map.get(key) + 1; 16 | answer--; 17 | return answer; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_위장/README.md: -------------------------------------------------------------------------------- 1 | # 프로그래머스 - 위장 2 | 3 | ### 문제 링크 4 | 5 | 6 | 7 | ### solve 8 | - 해시 맵을 이용하여 각각 종류별로 몇 개의 의상이 있는지 기록한다. 9 | - 의상의 종류별로 입을 수도 있고 입지 않는 경우도 있으므로 (각 의상의 종류 + 1)을 모두 곱한다. 10 | - 의상을 하나도 입지 않은 경우는 없으므로 마지막에 -1을 해주어야 한다. 11 | 12 | ### 코드 13 | ```java 14 | package programmers42578; 15 | 16 | import java.util.HashMap; 17 | 18 | public class Solution { 19 | 20 | static HashMap map = new HashMap<>(); 21 | 22 | public int solution(String[][] clothes) { 23 | int answer = 1; 24 | for (int i = 0; i < clothes.length; i++) { 25 | if (map.get(clothes[i][1]) == null) map.put(clothes[i][1], 1); 26 | else map.put(clothes[i][1], map.get(clothes[i][1]) + 1); 27 | } 28 | for (String key : map.keySet()) answer *= map.get(key) + 1; 29 | answer--; 30 | return answer; 31 | } 32 | 33 | } 34 | ``` 35 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_위장/index.js: -------------------------------------------------------------------------------- 1 | const solution = clothes => { 2 | const clothesMap = clothes.reduce((map, cur) => { 3 | const countOfCurrentType = map.get(cur[1]); 4 | 5 | return map.set(cur[1], countOfCurrentType ? countOfCurrentType + 1 : 1); 6 | }, new Map()); 7 | 8 | const count = 9 | [...clothesMap.values()].reduce((acc, cur) => acc * (cur + 1), 1) - 1; 10 | return count; 11 | }; 12 | 13 | (() => { 14 | const inputs = [ 15 | [ 16 | ['yellow_hat', 'headgear'], 17 | ['blue_sunglasses', 'eyewear'], 18 | ['green_turban', 'headgear'], 19 | ], 20 | ]; 21 | 22 | inputs.forEach(input => console.log(solution(input))); 23 | })(); 24 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_크레인인형뽑기게임/index.js: -------------------------------------------------------------------------------- 1 | const range = (start, end) => 2 | start < end ? Array.from({ length: end - start + 1 }, (_, idx) => idx + start) : []; 3 | 4 | const solution = (board, moves) => { 5 | let count = 0; 6 | const stack = []; 7 | 8 | const pickDoll = col => { 9 | for (const row of range(0, board.length - 1)) { 10 | const currentDoll = board[row][col - 1]; 11 | board[row][col - 1] = 0; 12 | 13 | const isExist = currentDoll !== 0; 14 | const isEqualToPrevDoll = stack[stack.length - 1] === currentDoll; 15 | 16 | if (isExist) { 17 | if (isEqualToPrevDoll) { 18 | stack.pop(); 19 | count += 2; 20 | break; 21 | } 22 | stack.push(currentDoll); 23 | break; 24 | } 25 | } 26 | }; 27 | 28 | moves.forEach(pickDoll); 29 | return count; 30 | } 31 | 32 | (() => { 33 | const board = [[0,0,0,0,0],[0,0,1,0,3],[0,2,5,0,1],[4,2,4,4,2],[3,5,1,3,1]]; 34 | const moves = [1,5,3,5,1,2,1,4]; 35 | 36 | console.log(solution(board, moves)); 37 | })(); 38 | 39 | -------------------------------------------------------------------------------- /src/kyu9341/programmers_튜플/index.js: -------------------------------------------------------------------------------- 1 | const parseStringToArray = str => str.substring(2, str.length - 2) 2 | .split("},{") 3 | .map(el => el.split(',').map(str => Number(str))); 4 | 5 | const solution = s => { 6 | const set = new Set(); 7 | const arr = parseStringToArray(s); 8 | 9 | const compareLength = (prev, cur) => prev.length - cur.length; 10 | arr.sort(compareLength).flat().forEach(el => set.add(el));; 11 | 12 | return [...set]; 13 | } 14 | 15 | (() => { 16 | const inputs = [ 17 | "{{2},{2,1},{2,1,3},{2,1,3,4}}", 18 | "{{1,2,3},{2,1},{1,2,4,3},{2}}", 19 | "{{20,111},{111}}", 20 | "{{123}}", 21 | "{{4,2,3},{3},{2,3,4,1},{2,3}}", 22 | ]; 23 | 24 | inputs.forEach(input => console.log(solution(input))); 25 | })(); 26 | 27 | -------------------------------------------------------------------------------- /src/kyu9341/queue/queue.js: -------------------------------------------------------------------------------- 1 | class Node { 2 | constructor(data) { 3 | this.data = data; 4 | this.next = null; 5 | } 6 | } 7 | 8 | class Queue { 9 | constructor() { 10 | this.head = null; 11 | this.tail = null; 12 | this.size = 0; 13 | } 14 | 15 | push(data) { 16 | const node = new Node(data); 17 | if (this.isEmpty()) { 18 | this.head = node; 19 | this.head.next = this.tail; 20 | } else this.tail.next = node; 21 | 22 | this.tail = node; 23 | this.size += 1; 24 | } 25 | 26 | pop() { 27 | if (this.isEmpty()) return null; 28 | if (this.head === this.tail) this.tail = null; 29 | 30 | const headData = this.head.data; 31 | this.head = this.head.next; 32 | this.size -= 1; 33 | 34 | return headData; 35 | } 36 | 37 | isEmpty() { 38 | return this.size === 0; 39 | } 40 | 41 | getArray() { 42 | const array = []; 43 | if (this.isEmpty()) return array; 44 | 45 | let currentNode = this.head; 46 | while (currentNode) { 47 | array.push(currentNode.data); 48 | currentNode = currentNode.next; 49 | } 50 | 51 | return array; 52 | } 53 | } 54 | --------------------------------------------------------------------------------