423p의 두 번째 예제 ( nxm 크기의 2차원 리스트를 리스트 컴프리헨션을 이용하여 초기화) 에 대해 질문이 있습니다.

n = 3
m = 3
array = [[0] * m for _ in range(n)]
print(array)

1. 3번째 줄에서 _ (언더바)의 의미가 궁금합니다.
2. 이 코드를 실행하면 [[0, 0, 0], [0, 0, 0], [0, 0, 0]] (3x3) 으로 출력되는데, 책에서는 [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] (3x4) 으로 나와있습니다. 오탈자인가요!? (세 번째 예제도 그런 거 같습니다....!)

n, k = map(int,input().split())

count = 0
while True:

n 이 나누어 떨어질때

if n % k == 0:
if n == 1:
break
n = n / k
count += 1

n 이 나누어 떨어지지 않을때

else:
if n == 1:
break
n = n - 1
count += 1

print(count)

저는 이런식으로 작성했는데 test case가 많지 않아서 걱정됩니다..

1. 해당 문제의 풀이인 p511의 step3에서 화폐 단위 3인 동전으로 target을 4에서 7로 업데이트 하는 부분이 이해되지 않습니다. 어떤 부분 때문에 1부터 6까지의 모든 금액을 만들 수 있다는 정당성을 얻을 수 있나요?

2. 또한 그리디 알고리즘이 현재 상태에서 매번 가장 좋아 보이는 것만을 선택하는 알고리즘이라고 배웠는데 해당 문제에서 매 상황에 어떠한 것을 선택하여 그리디 알고리즘으로 분류 되는 건가요??

제가 독해력이 부족하여 해당 문제 해설을 여러번 보았는데도 아이디어를 이해하지 못해 질문드립니다. 감사합니다.

안녕하세요 책 잘 보고 있습니다!! 여쭤볼 게 하나 있는데요.

dfs 탐색을 할때 deepcopy 를 사용해서 깊은 복사를 진행하였는데

보통 재귀를 사용할 때 관례적으로 깊은 복사를 사용하나요?

상어가 각각 다르게 먹는 경우의 수 중 최댓값을 구하는 문제여서 array에 영향이 없도록 매번 깊은 복사를 한다!

이렇게 이해하였는데 전 아직 dfs를 사용할 때 깊은 복사를 사용한 경험이 없어서 질문 드립니다.

깊은 복사를 사용하는 경우를 알려주실수 있나요?

안녕하세요~.
커리큘럼 문제 예시에서,
1번 강의를 수하기까지의 최소시간은 30시간,
2번 강의를 수강하기까지늬 최소시간은 20시간,
3번 강의를 수강하기까지의 최소시간은 70시간이라고 하셨는데,
3번 강의의 경우 왜 최소시간이 70시간이 되는지 잘 모르겠습니다.

3번 과목의 경우 선수과목의 2가지인데, 둘 중 한개만 들어도 되면
최소시간은 2번 강의 20시간 + 3번 강의 40시간 해서 최소시간은 60시간이 되는 거 아닌가요?
이 부분이 잘 이해가 가지 않아서 질문 드립니다.

무지의 먹방라이브 문제를 보고 있었습니다.

그런데 문자 자체가 이해가 안가더라고요 .

Step1에서 전체 남은 시간이 15초 그리고 , 3번음식 먹는시간 : 4초 , 3번음식 남은 개수 3개 => 3*4=12

그럼 3초가 남는거까지는 이해가 갑니다.

그럼 그 다음 음식들이 1,2 번음식들은 먹는데 8, 6초가 소모가 되는데 다음으로 먹을 수 있는게 없는 것 아닐까 생각을 했습니다.

그런데 뒤 step2을 보니 1번, 2번 음식이 각각 남은 개수가 2개씩 있고 ,
2번의 음식을 출력되야 한다. 라는 결론이 나와 있더라고요.

step2부분이 어떻게 가능한지 설명해주시면 감사드리겠습니다. ㅠㅠ

동빈님 안녕하세요.
출간 하신 책 보면서 재미있게 공부하고 있습니다😊
파이썬 코드 중 들여쓰기 부분에 대해 궁금한 점이 있어 문의드립니다.

[Chapter4 구현 - 상하좌우 문제] - p.112 4-1py 답안 예시 부분인데요
# 공간을 벗어나는 경우 무시, # 이동 수행 이 부분이 # 이동 후 좌표 구하기 for 문 밖에 있는 이유가 궁금합니다.

• nx, ny 가 # 이동 후 좌표 구하기 for 문 안에 선언되어 있어서 해당 for문 바깥에서는 참조가 안 될 것 같은데 코드는 정상적으로 동작하더라구요.
• 파이참 IDE에서는 아래와 같은 경고문구가 뜨네요
  

# N 입력받기
n = int(input())
x, y = 1, 1
plans = input().split()

# L, R, U, D에 따른 이동 방향
dx = [0, 0, -1, 1]
dy = [-1, 1, 0, 0]
move_types = ['L', 'R', 'U', 'D']

# 이동 계획을 하나씩 확인
for plan in plans:
    # 이동 후 좌표 구하기
    for i in range(len(move_types)):
        if plan == move_types[i]:
            nx = x + dx[i]
            ny = y + dy[i]
    # 공간을 벗어나는 경우 무시
    if nx < 1 or ny < 1 or nx > n or ny > n:
        continue
    # 이동 수행
    x, y = nx, ny

print(x, y)

위 코드가 정상 동작하더라도 제 생각에는 아래와 같이 # 공간을 벗어나는 경우 무시, # 이동 수행 이 부분이 # 이동 후 좌표 구하기 for 문 안에 있어야 참조 문제가 발생하지 않을 것 같아서요. 두 코드 모두 정상적으로 동작하는 것 같은데 제가 잘못 이해하고 있는 부분이 있을까요?

# N 입력 받기
N = int(input())
x, y = 1, 1
plans = input().split()

# L, R, U, D에 따른 이동 방향
dx = [0, 0, -1, 1]
dy = [-1, 1, 0, 0]
move_types = ['L', 'R', 'U', 'D']

# 이동 계획 하나씩 확인
for plan in plans:
    # 이동 후 좌표 구하기
    for i in range(len(move_types)):
        if plan == move_types[i]:
            nx = x + dx[i]
            ny = y + dy[i]

            # 공간을 벗어나는 경우 무시
            if nx < 1 or ny < 1 or nx > N or ny > N:
                continue

            # 이동
            x, y = nx, ny

print(x, y)

질문 정리

1. nx,ny에 대한 참조 에러가 왜 발생하지 않는 건가요?
2. 문제 풀이 로직에서 # 공간을 벗어나는 경우 무시, # 이동 수행 이 부분이 # 이동 후 좌표 구하기 for 문 안에 있는 것과 바깥 쪽에 있는 것의 차이는 무엇인가요?

정렬 - 안테나 문제 java 소스가 잘못 되었어요.

Collections.sort(students); => Collections.sort(arrayList);

// 중간값(median)을 출력
System.out.println(v[(n - 1) / 2]); => System.out.println(arrayList[(n - 1) / 2]);

안녕하세요 형 항상 고생많으십니다
저는 제가 먼저 짜보고 형 풀이를 보는데요
코드 방향성을 다르게 잡으면 아예 다른 코드형식이 되서
채점 받아보고 싶은데 문제들 올라가있는 온라인 저지있을까요?
1로만들기 문제는 백준온라인저지에서 본 것같은데
출처가 프로그래머스, 백준인가요?????

def solution(food_times, k):
if sum(food_times) <= k:
return - 1
q = []

for i in range(len(food_times)):
    heapq.heappush(q, (food_times[i], i + 1))
    
sum_value = 0
previous = 0
    
length = len(food_times)

while sum_value + ((q[0][0] - previous) * length) <= k:
    now = heapq.heappop(q)[0]
    sum_value += (now - previous) * length
    length -= 1
    previous = now

result = sorted(q, key = lambda x : x[1])
return result[(k - sum_value) % length][1]

이 문제의 알고리즘의 경우 전체 남은 시간(k) 를 (남은 음식의 수 * 가장 적게 걸리는 음식)으로 뺴는
즉 k = k - (남은 음식 * 가장 적게 걸리는 음식) 을 반복문으로 둬서 k가 더 이상 뺼 수 없을 때
남은 음식을 재정렬 한 뒤(번호순으로) 답을 도출 하는 걸로 알고 있습니다.
하지만 소스코드를 보면 그런 방식이 아닌거 같아서 코드를 이해하는데에 혼동을 겪고 있습니다.
while 문의 조건에 대해서 설명해주시면 감사하겠습니다!

221p 개미 전사 문제 해설에서
(b)를 보시면, 식량창고를 털 수 있는 경우입니다.

하지만, <-털수 없음으로 표기되어있습니다.

D12 + D13 = 11과 비교해서 11로 갱신된다.
수정 아래
D12 + D23 = 11과 비교해서 11로 갱신된다.

연구소 문제를 백준 온라인저지에서 파이썬으로 풀어 코드를 제출했더니 시간초과가 뜹니다..
그래서 혹시나 틀린게 있나하고 제공하시는 소스코드를 복사하여 붙여도 결과는 시간초과로 뜨는데
시간을 줄일 방법이 혹시 있을까요..?

문제 예시를 보니까 최소 시간이 70시간으로 되어 있습니다.
이는 1번 강의 30시간+3번 강의 40시간으로 계산된 것 같은데요.

문제 설명에서 "동시에 여러 개의 강의를 들을 수 있다고 가정한다"라고 되어 있는데,
이는 1번 강의랑 2번 강의를 (예를 들면 같은 학기에 있어서) 동시에 듣는데, 30시간이면 두 강의를 모두 완수할 수 있고
(예를 들면 다음학기의)3번 강의를 들어서 40시간을 들어 총 70시간이라고 보면 될까요?

만약 이렇게 이해한 게 맞다면, 문제 설명을 바꾸는 게 좋을 것 같습니다.
"동시에 여러 개의 강의를 들을 수 있다" 보다는 "같은 학기 내에 있는 강의는 동시에 여러개 들을 수 있다.
예를 들어, 30시간이면 1번 강의와 2번 강의를 모두 들을 수 있다. ~~~~"
가 낫다고 생각합니다.

안녕하세요

상하좌우를 아래처럼 풀었는데
제가 놓친 부분이 있을 것 같아서요
혹시 이렇게 풀었을 때 해당 문제에서 문제 될 부분이 있나요?

n= int(input())
arr = list(input().split())

y, x = 1, 1
for a in arr:
    if a == 'R' and x != n:
        x += 1
    elif a == 'L' and x != 1:
        x -= 1
    elif a == 'U' and y != 1:
        y -= 1
    elif a == 'D' and y != n:
        y += 1

print(y,x)

책으로 많은 도움 받고 있습니다. 좋은 책 출판해주셔서 감사합니다.
저는 초판 2쇄 책을 보고 있는데, 303페이지 커리큘럼 문제의 설명 부분에 오탈자인지, 제가 이해를 못한 것인지 하여 문의드립니다.

예시에서 1번 강의 30시간, 2번 강의 20시간, 3번 강의 40시간이라고 적혀 있는데
3번 강의를 수강하기까지의 최소 시간이 70시간이라고 적혀 있습니다.

제가 생각하기에는 30 + 20 + 40 == 90 하여 90시간인 것 같은데..
아니면 모두 수강할 필요가 없다면, 20 + 40 == 60 하여 60시간이어도 이해가 될텐데..
혹시 제가 잘못 이해하고 있는 것인지, 아니면 오탈자인지 알려주시면 감사하겠습니다!

정오표에도 없어서 이렇게 문의 드립니다.

dfs안에 graph를 매개함수로도 받지않고 전역으로 설정하지 않았는데도 함수안에서 graph를 사용할수있는 이유가 궁금합니다!

안녕하세요 신지호입니다.

Chapter7 - 190p 에서 이진탐색 파이썬 코드 맨 윗부분에

if array[mid] == tartget:
return mid
# 중간점의 값보다 찾고자 하는 값이 작은 경우 왼쪽 확인
elif array[mid] > target:
return binary_search(array, target, start, mid - 1)
# 중간점의 값보다 찾고자 하는 값이 작은 경우 오른쪽 확인 -> # 중간점의 값보다 찾고자 하는 값이 큰 경우 오른쪽 확인
return binary_search(array, target, mid + 1, end)

'# 중간점의 값보다 찾고자 하는 값이 작은 경우 오른쪽 확인' 이 부분에서 "작은 경우"가 "큰 경우"로 변경되어야 할 것 같습니다.

p.115 ~ p.117 왕실의 나이트 문제 풀이중 깃허브 저장소에 올라와있는 java 소스코드에서 오류가 있는 것 같습니다.

int column = inputData.charAt(0) - 'a' ; 부분을
int column = inputData.charAt(0) - 'a' + 1; 로 수정해야 맞을 것 같습니다.

혹시 제가 틀리다면 피드백 부탁드리겠습니다.

안녕하세요. 먼저 동빈님께서 집필해주신 책 정말 도움이 많이되고 있습니다.
제가 드릴 질문은 p.118 게임개발 문제에서 답안에서의 방향 정의 관련 질문입니다.
답안에서
북, 동, 남, 서 방향 정의가 dx = [-1, 0, 1, 0 ] 으로 되어있고 dy = [0, 1, 0, -1]으로 되어있습니다.
근데 동쪽과 서쪽이 dy의 부호가 반대가 되야하는게 아닌지 궁금합니다.
왜냐하면 동쪽에서 왼쪽을 바라봤을때 북쪽이 되는데 북쪽으로 가게되면 dx= 0, dy= -1이 되는게 아닌가요? 해당 책에서는 dx =0, dy = 1이라고 써져있습니다.
또한 서쪽에서 왼쪽을 바라보게되면 남쪽으로 가게되는데 남쪽으로 가게되면 dx =0, dy =1 이 되야하는게 아닌가 궁금합니다.

감사합니다

점화식 해설 2번에서 i-2까지 채워져 있을 때

1. 1x2 덮개를 2개 덮는 경우
2. 2x2 덮개를 1개 덮는 경우

라고 하셨는데
2x1 덮개를 2개 덮는 경우는 고려하지 않는 이유를 모르겠습니다...

안녕하세여.
나름대로 열심히 한다고 했지만,
이렇게 하는게 맞는지 확인하기 위해 올립니다.

현재 저는 무조건 하루에 3시간은 코테 공부를 하려고 하고 있습니다.
너무 안되는 날에도 최소한 2시간은 하려고 노력합니다.

근데 제가 구현쪽이 많이 약합니다.
책을 보니 풀이 시간이 적혀져 있더라구요. 그래서 저는 이 시간동안 최대한 고민해봅니다.
예를들어 풀이 시간이 40분이 적혀 있다면,
40분동안 문제를 풀고 답을 봅니다. 왜냐하면 문제를 계속 푸는건 의미가 없다고 생각했기 때문입니다.
그리고 문제 상단 오른쪽에 보면 1회,2회,3회 체크하는 부분이 있더라구요.
그래서 문제를 풀었으면(답을 보지 않고) 그곳에 체크 합니다.
그리고 나서 약 2번째 풀때는 4일, 3번째 풀때는 10일정도 있다 문제를 풀고 있습니다.
물론, 답을 본 코드는 체크하지않고, 다음 날에 다시 풀어봅니다.
답을 보지 않고 풀때까지 위 행동을 반복합니다. 그러면 언젠가는 풀리더라구요.
그렇게 체크가 3개가 될때까지 진행하지만,
너무 쉬운 문제는 한번만 풀고 안푸는 경우도 있기는 합니다.

이렇게 공부하는게 나쁘지는 않는것 같은데,
이게 맞는건지 잘 몰라 문의드립니다.

추가적으로 매주 화요일마다 스터디를 진행해 다른 분들이 어떻게 풀었는지 그 풀이를 듣습니다.

https://github.com/ndb796/python-for-coding-test/blob/master/5/11.java
에서 28번째 줄 네 가지 방향을 정의하는 코드가 있는데요.
dx[] ={-1, 1, 0, 0}
dy[] = {0, 0, -1 1}
이렇게 정의되어 있는데 어째서 -1, 1, 0, 0 으로 값이 정의되어있는지 잘 모르겠습니다 ㅜ.,ㅜ
상은 -1, 하는 1, 좌,우는 각각 0인 건가요??

102페이지 기재주신 코드 중에서

while True:

N이 K로 나누어 떨어지는 수가 될 때까지만 1씩 빼기

1. target = (n // k) * k
2. result += (n - target)
3. n = target

1,3번 문장은 범위가 커질 시, n과 target을 배수로 구현주신 부분으로 이해되온데
2번 문장이 어떤 관계인지 이해 되지 않아 질문드립니다..
n과 target이 같아 빼면 0이 되고, 0이 되야지만 result값이 1씩 누적되는건지..?
+=기호로 1씩 뺀다는 부분이랑 어떤 연관성이 있는지 이해가 되지 않아 답변 주시면 감사드리겠습니다.

314p의 "만들 수 없는 금액"

문제가 도저히 풀리지 않아 답지를 보니
"1부터 target -1까지의 모든 금액을 만들 수 있다고 가정"하자고 되어있습니다.

여기서 이런 가정이 어떻게 나온 것이며, 어떻게 증명 가능한가요..?
코드를 직접 쳐보니 정확한 답이 나와서 신기한데, 이게 어떤 원리인지 모르겠습니다.

답변 기다리겠습니다!

책 잘보고있습니다.
CHAPTER 8 다이나믹 프로그래밍 부분을 보던 중 이해가 잘 가지 않는 부분이 있어서 질문드립니다,
224p에 2번 항목에 i-2까지 덮개가 채워져 있는 경우
1x2 덮개 2개 또는
2x2 덮개 1개
이렇게 2가지 경우의 수가 존재한다고 되어있는데
2x1 덮개 2개는 포함이 안되는건가요?

책 제목을 검색해보니 아직 출판하지 않은 책인데 언제 출간하는 지 궁금합니다^^

문제

특정 거리의 도시 찾기 분류 문제 18352

풀이

풀이방법은 그래프로 표현 후 인덱스를 접근 하는식으로 제출을 하였더니 메모리초과가 발생합니다.

질문

제 생각에는 그래프로 표현 해서 인덱스로 접근 하기엔
N 의 범위가 1~30,000 인데 여기서 N^2 만 되어도 수가 너무 크다는 생각이 드는데
강의 의 1:19:55 쯤에 익덱스로 접근 하는법을 추천하셨는데, 이 경우에도 배열으로 해결하는게 맞나요?
우선 아래 코드 두개 다 메모리 초과가 발생하는데 자료구조 선택을 어떻게 가져가야하나요?

Code

1

from collections import deque

n, m, k, v = map(int, input().split())
queue = deque()
graph = [[0] * (n+1) for _ in range(m+1)]
visit = [0] * (n+1)
result = []

def bfs(v):
  visit[v] = 1
  queue.append(v)
  while queue:
    q = queue.popleft()
    for i in range(1, m+1):
      if not visit[i] and graph[q][i] == 1:   
        queue.append(i)
        visit[i] = visit[q] + 1
        if visit[i] == k+1:
          result.append(str(i))

for i in range(m):
  x, y = map(int, input().split())
  graph[x][y] = 1

bfs(v)
print((len(result) != 0) and "\n".join(result) or -1)

2

from collections import deque
import sys
 
n, m, k, v = map(int, sys.stdin.readline().split())
queue = deque()
graph = [[0] for _ in range(n+1)]
visit = [0] * (n+1)
result = []

def bfs(v):
  visit[v] = 1
  queue.append(v)
  while queue:
    q = queue.popleft()
    for i in graph[q]:
      if not visit[i] and i:  
        queue.append(i)
        visit[i] = visit[q] + 1
        if visit[i] == k+1:
          result.append(str(i))

for i in range(m):
  x, y = map(int, sys.stdin.readline().split())
  graph[x].append(y)

bfs(v)

print((len(result) != 0) and "\n".join(result) or -1)

readme.md 파일에 적혀있는
Part3 알고리즘 유형별 기출문제의

11장 그리디 무지의먹방라이브 링크가 https://www.acmicpc.net/problem/2437 백준 저울문제로 되어있습니다

• 무지의 먹방 라이브 (카카오): Python 3.7 코드

아래와 같이변경하여야 할것같습니다 (프로그래머스 링크) https://programmers.co.kr/learn/courses/30/lessons/42891

• 무지의 먹방 라이브 (카카오): Python 3.7 코드

코드는 다음과 같습니다. 문제 풀이는 저자님 풀이랑 거의 동일합니다.
그런데 백준에 테스트 돌리니 런타임 에러가 납니다.

시도해본 것들은
1.parent 배열 크기를 100001로 해본다. ->똑같이 런타임 에러가 나므로 배열 인덱스 참조 에러는 아닌 것 같습니다.
2. findParent()메소드의 재귀호출 깊이가 너무 깊은 것은 아닌가하여 다른 코드 검색해봄->똑같이 재귀 호출한 코드를
복붙하여 제출했더니 성공함... 즉, 재귀호출과는 무관함을 알 수 있다.

``
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DividingCityProject {
static BufferedWriter bw;

static class Edge implements Comparable<Edge>{

    private int cost;
    private int a;
    private int b;

    public Edge(int a , int b, int cost){
        this.a=a;
        this.b=b;
        this.cost=cost;
    }

    public int getA() {
        return a;
    }

    public int getB() {
        return b;
    }

    public int getCost() {
        return cost;
    }

    @Override
    public int compareTo(Edge other) {
        if(this.cost<other.cost){
            return -1;
        }
        return 1;
    }
}
static int n,m;

static List<Edge> edges=new ArrayList<>();

static int[]parent;

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    bw = new BufferedWriter(new OutputStreamWriter(System.out));

    String[]splits=br.readLine().split(" ");

    n=Integer.parseInt(splits[0]);
    m=Integer.parseInt(splits[1]);

    parent=new int[n+1];

    for(int i=1;i<=n;i++){
        parent[i]=i;
    }

    for(int i=0;i<m;i++){
        splits=br.readLine().split(" ");
        int a=Integer.parseInt(splits[0]);
        int b=Integer.parseInt(splits[1]);
        int cost=Integer.parseInt(splits[2]);
        edges.add(new Edge(a,b,cost));
    }

    //간선을 비용 순으로 오름 차순 정렬한다.
    Collections.sort(edges);

    //크루스칼 알고리즘 진행

    int result=0;

    for(int i=0;i<edges.size();i++){



        if(findParent(edges.get(i).getA())!=findParent(edges.get(i).getB())) {//서로소 집합인지 확인 == 사이클이 있는지 확인
            unionParent(edges.get(i).getA(), edges.get(i).getB());//사이클이 없으면 그룹으로 합친다.

            result += edges.get(i).cost;
            n--;
            if(n<=2)break;
        }

    }

    bw.write(Integer.toString(result)+"\n");




    br.close();
    bw.close();
}







private static int findParent(int a) {
    if(parent[a]==a) return a;
    return parent[a]=findParent(parent[a]);
}

private static void unionParent(int a, int b) {
    a=findParent(a);
    b=findParent(b);
    if(a<b)parent[b]=a;
    else parent[a]=b;
}

}

문제 해설에서는 플로이드 워셜 알고리즘을 이용할 수 있을 정도로 n이 작기 때문에, 해당 알고리즘으로 풀려있습니다.
저는 다르게 풀었는데요.
K는 반드시 경유하고 X로 가야하기 때문에
start->K까지의 다익스트라 알고리즘 리턴값 + K->X까지의 다익스트라 알고리즘 리턴 값으로 풀었습니다.
물론, 두 가지 중 하나라도 도달할 수 없는 경로면 -1을 출력하고 프로그램을 종료하였습니다.

이렇게 푸는 방식에도 문제가 없겠죠?

그리고 책은 좋다고 생각하지만, 책에 있는 예제만으로는 테스트를 확실하게 하기 어렵다고 봅니다..
따라서 해당 문제에 대한 사이트 링크를 첨부하여 독자들이 "확실하게"답을 맞출 수 있는지 확인하게 좋다고 봐요.

혹시, c++ 답안 코드에서 'if (count >= i)' 하는 부분을 'if (count >= arr[i])' 로 고쳐야 하지 않을까요...?
c++ 정답 코드가 'if (count >= i)' 로 되어 있어서 오타인 것인지 질문 드립니다.

p. 201에서는 M의 범위를 1 <= M <= 2,000,000,000 (20억) 이라고 했는데, 뒷 장에서 설명할 때는
M이 최대 10억까지 가능하다고 반복적으로 말하고 있습니다. 아마도 앞의 조건이 잘못된게 아닐까 하고 생각이 듭니다.

p.205 첫 문장에서

"같을 때마다 H 값을 중간점(MID) 값으로 갱신해주면 된다." (X) --> "작을 때마다 H 값을 중간점(MID) 값으로 갱신해주면 된다"

문맥상 "크거나 같다" 라는 표현이 아니라 "크거나 작은 경우에 중간점이 갱신되는게 맞는 것 같습니다.

오타가 맞는지 확인 부탁드립니다 : )

안녕하세요
전보문제 질문자입니다
답변해주신 내용 잘 보았습니다.
통로라는 것이 1개의 edge를 의미한다면,
문제에서 메시지를 보낼 수 있는 조건 x에서 y로 향하는 통로가 있어햐하고, 반대로 y에서 x로 향하는 통로도 있어야하므로,

x      y
|--->|
|<---|

위의 형태여야 한다는 의미로 받아들여지는데,
앞서 드린 질문에서와 마찬가지로 x에서 y로 가는 edge는 있는 것이 INF로 필터링이 가능하지만 반대의 경우도 가능한지는 잘 모르겠습니다.

입력예시
3 2 1
1 2 4
1 3 2
의 결과가 2 4가 나오는데
1 2 4가 1번에서 2번으로 가는데 걸리는 시간 4라는 의미인 동시에 2에서 1로가는 것도 4가 걸리는 즉,
양방향이라는 뜻을 내포하는 것인가요?

감사합니다

안녕하세요! 책 너무 잘 보고 있습니다. 알고리즘을 처음 접하는 저에게는 너무 든든한 교본 같은 책입니다. 다이나믹 프로그래밍 실전 문제 '개미 전사' 해설에 오탈자로 보이는 곳이 있어서 글 남깁니다.

p 221의 b부분에서 '(i - 2) 번째 식량창고를 털기로 결정한 경우 현재의 식량창고를 털 수 있다.'라고 나와있는데 그림에서는 '털 수 없음'이라고 나오네요.

개정판이 나온다면 수정되어 더 완벽한 교재가 되길 바라는 마음에 글 남깁니다. 감사합니다.

코드를 아래 와 같이 작성하면 문제가 되는 경우가 있을까요?

N, K = map(int,input().split())

result = 0

while N != 1:
if N%K == 0:
N = N/K
result += 1
else:
N -= 1
result += 1

print(result)

안녕하세요. 방향벡터 질문이 있습니다.

강의상에서는
dx = [0,-1,0,1]
dy = [1,0,-1,0]

으로 표시하셧는데 책에서는
dx = [0,0,-1,1]
dy = [-1,1,0,0] 으로 되어있는데

왜 이렇게 된건가요??

책을 보면서 C로 풀이 하면서 LinkedList를 이용하여 Queue를 구현하여서 풀었는데 어디서 틀렸는지 잘 모르겠습니다.

여러가지 예제를 넣어가면서 테스트 했을때에는 정상적으로 나오는데 어디가 문제인지 궁금합니다!

https://github.com/JaeSeoKim/algorithmStudy/blob/f18fc8eac3c8b4c67b63f0dd7bdb2b298938ea73/DFS%5CBFS/4_%EB%AF%B8%EB%A1%9C%ED%83%88%EC%B6%9C(BFS).c

구현 - 자물쇠와 열쇠 문제에서
java 소스에서 rotateMatrixBy90Degree 메서드 에서
result[j][n - i - 1] = a[i][j];
result의 인덱스가 [j][n - i - 1] 인지 잘 모르겠어요.
설명 좀 해주 실수 있나요?

그리고 46번째 라인에서
for (int x = 0; x < n * 2; x++)
for (int y = 0; y < n * 2; y++)
에서 왜 n * 3 까지 탐색을 하지 않고 n * 2 까지 탐색 하는지 설명 해주실 수 있나요?
책, 너무 잘 읽고 있습니다.

res= count_by_range(array[len(q)], q.replace('?', 'a'), q.replace('?','z')) 부분 이해가 가질 않아 질문드립니다.

count_by_range() 함수를 보면 이진탐색으로 right_value의 인덱스를 찾고 left_value의 인덱스를 찾아서 이를 뺴잖아요.

근데 반복문이나 재귀 없이 개수가 구해지는 건지 잘 이해가 가질 않습니다.

만약 a,나 z가 없으면 index값을 반환하지 못해서 0이 리턴될 것이라고 생각되서요.

게임개발 task순서중에

1. 왼쪽으로 회전한다.
2. 회전후 앞칸을 방문하지 않았으면 한칸 전진한다. 막혀있거나 방문한 칸이면 다시 1로 돌아간다.
3. 조건을 확인후 뒤로 가야하면 뒤로간다. 뒤로 갈 수 없으면 종료한다.

이정도로 이해 했는데요

순서가 1,2,3 번을 반복해야 하는건지
아니면 3번 조건은 항상 확인해야하는건지 ex. (1번 회전후 3번확인, 2번 전진후 3번확인)
2번 조건에서 비어있으면 전진후 1번으로 돌아가는건지 아니면 전진을 계속 하는건지 3번 조건확인문으로 넘어가는건지

추가로 part3에서 문제 푸는 횟수를 체크하는 박스가 있던데
어떤방식으로 공부하길 권장하시는지,
같은문제를 3번 푸는게 어떤의미가 있는건지 궁금합니다.

--
항상 유튜브 잘 보고 있고 이번 책 정말 도움이 되는 내용이 많아 좋습니다. 감사합니다 😀

이진탐색 문제로써
쓰여진 정답을 보면은 N개의 리스트를 (1 <= N <= 1000000) 일단 정렬하고
M개의 리스트에 (1 <= M <= 1000000) 있는 각 요소들을 이진탐색한다고 나와있는데요

1초에 10억번을 처리하므로 해당 알고리즘으로는 해결이 안되는것같은데
혹시 제가 계산에 틀린걸까요?

java 소스 코드에서 아래 소스가 잘 이해가 안가는데, 설명해 주실수 있나요?

// summary + (현재의 음식 시간 - 이전 음식 시간) * 현재 음식 개수와 k 비교
while (summary + ((pq.peek().getTime() - previous) * length) <= k) {
int now = pq.poll().getTime();
summary += (now - previous) * length;
length -= 1; // 다 먹은 음식 제외
previous = now; // 이전 음식 시간 재설정
}

(현재의 음식 시간)에서 (이전 음식 시간)을 왜 빼는지 잘 모르겠습니다.
그리고, summary를 왜 더하는지, 잘 모르겠습니다.

안녕하세요. 책 너무 잘보고 있습니다. 감사합니다.
그런데 '모험가 길드 문제' 를 풀고나서, 그리디 말고 파라메트릭 서치 로도 풀수 있을거 같은데,
혹시, 파라메트릭 서치로 구현 하신 소스가 있을까요? java 나 c++ 소스이면, 더 좋을거 같습니다.
아니면, 혹시 파라메트릭 서치로 풀수 없는 건가요? 풀어 보려니깐 잘 안돼서요.
어쩌면, 책 이외의 질문 이라, 죄송 합니다.

자세하게 잘 써주셔서 책 보면서 재밌게 공부 중입니다. 그런데 저는 알고리즘을 풀면서 이런 부분은 이렇게 하는 게 좋구나 이런 식으로 정리를 하면서 푸는 편인데 책이랑 번갈아 보면서 풀기가 어렵더라고요 혹시 이북 출간 계획이 있으실까요?

문제를 풀다 궁금한점이 있습니다.

문제에는 [각 화폐는 몇 개라도 사용할 수 있으며... 이하 생략]
이런 것으로 봐서 화폐의 갯수를 구하는 문제이구나 생각했습니다.

그런데 출력 조건이 경우의 수라고 적혀 있어서 이상함에 질문합니다.

예를들어,
동전은 2원과 3원이 존재하구,
4원을 만든다고 생각해보면
4원은 2원 2개가 필요합니다.
즉, 화폐의 개수로 따졌을 때는 2개가 답이지만
경우의 수는 2원 2개만 존재하기 때문에 1이 답이라 생각했습니다.

하지만 이 예제는 15원을 만들기 위한 예제인데..
저와 같이 경우의 수로 계산할시... 정답보다 더 큰 숫자가 나오는게 확인되었습니다.

이에 따라 2가지를 유추해 볼수 있을 것 같습니다.
첫 번째, 책 내용이 오타다.
단순히 오타라고 본다면, 경우의 수가 아니라 화폐의 갯수라고 표현하는게 맞는것 같습니다.

두번째, 계산 실수다.
어쩌면 경우의 수나 화폐의 개수가 같은 의미로 작성되었을지도 모르죠.
또, 15원으로 점차적으로 계산하면서 중복된 내용이 다수 발견 되었습니다.
그렇다는건 중복된 내용을 제거하기만 하면 정답이 될 수 있을 것 같습니다.

하지만, 계산 실수일수도 있지만, 책의 오타일 가능성도 배재할 수 없다고 판단했습니다.
더 정확한 내용이 무엇인지 확인하고자 질문올립니다.
동빈님의 의견은 어떠신가요?

게임 개발 문제의 답안예시 (p.121) 에 count 의 초기값을 1 로 놓은 이유가 뭔가요 ?_?

안녕하세요
전보문제에서 x에서 y로 메시지를 보낼 때, x에서 y로 가는 경로와 y에서 x로 가는 경로가 모두 존재해야만 메시지를 전송할 수 있다고 써있는데, 소스코드에서

for d in distance:
   if d != INF
      count +=1
     max_distance = max(max_distance, d)

해당 부분에서 d를 보면 x에서 y로 가는 최단경로는 INF가 아니라면 존재하지만, y에서 x로 간다는 보장을 할 수 있을까요?

x     M     y   

| -> | -> |
   
|      | <- |      

요런 형태가 만약 주어져도 문제가 없을지 궁금합니다

감사합니다