Problem Solving on Kelly Dev

LeetCode 1563. Stone Game V

Mon, 17 Aug 2026 11:30:13 +0900

문제

https://leetcode.com/problems/stone-game-v

풀이

돌이 일렬로 놓여 있고, 매 턴마다 현재 구간을 둘로 나눈 뒤 더 작은 합을 가진 쪽을 가져간다. Alice가 얻을 수 있는 최대 점수를 리턴하는 문제이다.

매 턴마다 현재 구간을 둘로 나눈 뒤 더 작은 합을 가진 쪽을 가져가므로, 구간 DP로 보는 게 자연스럽다.

dp[left][right]를 stoneValue[left...right] 구간에서 Alice가 얻을 수 있는 최대 점수라고 하자. 구간을 split으로 나눠서 왼쪽 합과 오른쪽 합을 비교하면 된다.

왼쪽 합이 더 작으면 왼쪽을 가져간다.
오른쪽 합이 더 작으면 오른쪽을 가져간다.
두 합이 같으면 둘 중 더 좋은 쪽을 선택한다.

구간 합은 Prefix Sum으로 미리 구해두면 되고, dp는 짧은 구간부터 채우면 된다. 각 구간마다 모든 분할을 확인하므로 전체 시간 복잡도는 $O(n^3)$이다.

Codeforces 1360D. Buying Shovels

Sun, 16 Aug 2026 10:53:55 +0900

문제

https://codeforces.com/problemset/problem/1360/D

풀이

정확히 n개의 삽을 사야 하고, 한 번에 살 수 있는 패키지 크기는 1부터 k까지이다. 또한 한 번 고른 패키지 크기만 계속 사야 하므로, 결국 n을 나누는 어떤 수 x를 골라 n / x개의 패키지를 사는 문제로 바뀐다.

패키지 개수를 최소화하려면 패키지 크기 x를 최대한 크게 잡아야 한다. 따라서 n의 약수 중에서 k 이하인 가장 큰 값을 찾으면 된다.

예를 들어 n = 8, k = 7이면 8의 약수는 1, 2, 4, 8인데, 이 중 k 이하인 가장 큰 약수는 4이다. 그래서 답은 8 / 4 = 2가 된다.

LeetCode 2029. Stone Game IX

Sun, 16 Aug 2026 10:22:55 +0900

문제

https://leetcode.com/problems/stone-game-ix

풀이

돌을 순서대로 가져가면서, 합이 3의 배수가 되지 않게 해야 하는 게임이다. Alice가 이길 수 있는지 리턴하는 문제이다.

각 돌의 값은 3으로 나눈 나머지만 보면 된다. 합이 3의 배수인지 아닌지만 중요하기 때문이다. 그래서 0, 1, 2의 개수만 세면 충분하다.

0은 합의 나머지를 바꾸지 않으므로, 실제 승부는 1과 2를 어떻게 번갈아 쓰느냐에 달려 있다. count[0]이 짝수인지 홀수인지에 따라 가능한 진행이 달라진다.

count[0]이 짝수면 1과 2가 둘 다 있어야 한다.
count[0]이 홀수면 1과 2의 개수 차이가 너무 크면 안 된다.

코드

class Solution {
 func stoneGameIX(_ stones: [Int]) -> Bool {
 var count = [Int](repeating: 0, count: 3)
 for stone in stones {
 count[stone % 3] += 1
 }
 let count0 = count[0]
 let count1 = count[1]
 let count2 = count[2]
 if count0 % 2 == 0 {
 return count1 > 0 && count2 > 0
 }
 return abs(count1 - count2) > 2
 }
}

Codeforces 276C. Little Girl and Maximum Sum

Sat, 15 Aug 2026 12:48:53 +0900

문제

https://codeforces.com/problemset/problem/276/C

풀이

크기 n인 수열 a와 쿼리 q개가 주어진다. 각 쿼리는 인덱스 $[l, r]$ 범위를 지정하며, 해당 범위의 원소 합을 구한다. 수열 a를 적절히 재배열하여 모든 쿼리의 합의 총합을 최대화 한 수를 출력하면 된다.

쿼리가 여러번 나오고 어떤 원소들은 쿼리 안에 중복되어서 포함되어 있을 수 있다. 쿼리의 범위 안에 가장 많이 포함된 원소의 순서대로, 높은 값을 배치하는 정렬 문제로 환원된다.

어떤 원소 $a_i$가 쿼리 내부에 포함되어 있는지를 일반적으로 판단하게 되면 $O(q \times n)$이 되는데, q, n의 범위가 $1 \leq q 2 \times 10^5$ 이므로, 시간 안에 문제를 해결하기 어려워진다.

Leetcode 3702. Longest Subsequence With Non-Zero Bitwise XOR

Sat, 15 Aug 2026 12:38:30 +0900

문제

https://leetcode.com/problems/longest-subsequence-with-non-zero-bitwise-xor

풀이

수열 nums가 주어지고, 이 nums의 서브시퀀스 중, 모든 원소를 XOR해서 0이 아니게 되는 서브시퀀스의 최대 길이를 리턴하면 된다.

이 문제는 XOR 연산의 특성을 잘 알아야 한다. 만약 XOR이 아니라 $+$이었다면, 모든 $\text{nums}$의 원소들을 더해보고, 0이 아니라면 $\text{nums}$ 전체를, 0이라면 원소 중 0이 아닌 것 하나를 제외하면 된다. $+$의 역연산은 $-$이므로, 어떤 원소 $x$를 제외했을 때 다음과 같이 된다.

$$\sum \text{nums} - x \neq 0$$

만약 모든 원소가 0이라면 답은 0이 된다.

Codeforces 550A. Two Substrings

Fri, 14 Aug 2026 12:17:14 +0900

문제

https://codeforces.com/problemset/problem/550/A

풀이

스트링 s가 주어지고, 이 s 안에서 서브스트링 "AB"와 "BA"가 겹쳐지지 않은 상태로 존재하면 "YES" 아니라면 "NO" 출력하면 된다.

문제에서 주어진 예시인 "ABA" 같은 경우는 "NO"가 된다. "AB"와 "BA"가 서로 따로 존재하지 않기 때문이다. 하지만 "ABCABA" 같은 경우에는 "AB"와 "BA"가 "BA"는 겹쳐져 있지만 이미 앞에서 "AB"가 존재하기 때문에, "YES"가 된다.

이런 예외들을 알아내면, 문제를 푸는 방식은 단순하다. "AB"를 찾은 후, 그 이후("B" 이후)에 있는 인덱스부터 "BA"를 찾고, 만약 존재한다면 "YES", 존재하지 않는다면 다시 "BA"를 먼저 찾은 후, "A"의 인덱스 이후에 있는 인덱스부터 "AB"를 찾으면 된다. 둘 다 불가능하다면 "NO"가 된다.

Leetcode 3090. Maximum Length Substring With Two Occurrences

Fri, 14 Aug 2026 11:53:07 +0900

문제

https://leetcode.com/problems/maximum-length-substring-with-two-occurrences

풀이

스트링 s가 주어지고, 스트링 s의 서브스트링 중에서 같은 문자가 최대 2번 까지만 등장하는 서브스트링의 최대 길이를 리턴하는 문제이다.

투 포인터를 이용해서, 서브스트링 내부의 각 문자의 개수는 frequencies 딕셔너리로 추적하고, 같은 문자가 2개를 초과하면 start, 그렇지 않다면 end를 증가시키는 방향으로 s를 탐색하면 된다.

문제의 제약조건이 널널해서 $O(n^2)$ 방식의 브루트 포스로도 풀 수 있지만 투 포인터를 이용하면 $O(n)$으로 쉽게 풀 수 있다.

코드

class Solution:
 def maximumLengthSubstring(self, s: str) -> int:
 frequencies = {}
 answer = 0
 start = 0
 for end in range(len(s)):
 frequencies[s[end]] = frequencies.get(s[end], 0) + 1
 while frequencies[s[end]] > 2:
 frequencies[s[start]] -= 1
 start += 1
 answer = max(answer, end - start + 1)
 return answer

Leetcode 2213. Longest Substring of One Repeating Character

Thu, 13 Aug 2026 20:45:10 +0900

문제

https://leetcode.com/problems/longest-substring-of-one-repeating-character

풀이

스트링 s에 대해 여러 번의 문자 변경 쿼리가 주어진다. 각 쿼리마다 특정 인덱스의 문자를 변경하고, 같은 문자가 연속되는 가장 긴 부분 스트링의 길이를 리턴하면 된다.

스트링의 길이와 쿼리의 개수가 최대 $10^5$이므로, 문자를 변경할 때마다 스트링 전체를 탐색하는 방식으로는 해결할 수 없다.

문자 하나를 변경하는 업데이트가 반복되고, 변경 이후 스트링 전체에서 가장 긴 연속 스트링의 길이를 구해야 한다. 따라서 변경된 구간만 갱신할 수 있는 Segment Tree를 사용했다.

다만, 단순히 concat을 하면 안되고, 두 접합부의 경계를 확인한 다음 처리를 해줘야 한다.

LeetCode 2996. Smallest Missing Integer Greater Than Sequential Prefix Sum

Wed, 12 Aug 2026 22:47:12 +0900

문제

https://leetcode.com/problems/smallest-missing-integer-greater-than-sequential-prefix-sum

풀이

정수 배열 nums가 주어진다. 배열의 첫 원소부터 연속해서 증가하는 부분의 합을 구한 뒤, 그 합보다 크거나 같으면서 배열에 존재하지 않는 가장 작은 정수를 찾으면 된다.

먼저 첫 번째 원소를 합에 더해두고, 현재 원소가 다음 조건을 만족하는지 확인한다.

$$ nums[i] = nums[i - 1] + 1 $$

조건을 만족하는 동안에는 현재 원소를 합에 더하고, 연속 조건이 깨지면 순회를 종료한다.

이제 구한 합을 후보값으로 두고, 후보값이 배열 안에 있으면 1씩 증가시킨다. 배열에 없는 첫 번째 값이 정답이다. 이 부분은 코드처럼 배열에 후보값이 존재하는 동안 반복하면 된다.

LeetCode 2958. Length of Longest Subarray With at Most K Frequency

Wed, 12 Aug 2026 21:14:37 +0900

문제

https://leetcode.com/problems/length-of-longest-subarray-with-at-most-k-frequency

풀이

정수 배열 nums와 정수 k가 주어질 때, 어떤 숫자도 k번보다 많이 등장하지 않는 가장 긴 연속 부분 배열의 길이를 구하면 된다.

연속 부분 배열이므로 슬라이딩 윈도우를 사용했다. start부터 end까지를 현재 윈도우로 두고, end를 오른쪽으로 이동하면서 숫자별 등장 횟수를 갱신한다.

새로 추가한 숫자의 등장 횟수가 k를 초과하면 조건을 만족할 때까지 start를 오른쪽으로 이동한다. 이때 윈도우의 가장 왼쪽 숫자부터 하나씩 제거하면 된다. 윈도우가 조건을 만족하는 상태가 되면 현재 길이로 정답을 갱신한다.

LeetCode 1140. Stone Game II

Mon, 10 Aug 2026 22:18:06 +0900

문제

https://leetcode.com/problems/stone-game-ii

풀이

돌이 일렬로 놓여 있고, 현재 M일 때 1개부터 2M개까지 가져갈 수 있다. 돌을 가져간 뒤에는 M이 max(M, 가져간 개수)로 바뀐다. Alice가 항상 먼저 시작하고, Alice가 얻을 수 있는 돌의 최대 개수를 구하면 된다.

현재 차례인 사람이 상대보다 얼마나 더 많이 가져갈 수 있는지로 DP를 정의할 수도 있지만, 이 문제에서는 현재 상태에서 현재 플레이어가 최대로 가져갈 수 있는 돌의 수를 저장하는 방식이 더 직관적이다.

dp[i][m]을 i번째 돌부터 시작하고 현재 M이 m일 때, 현재 플레이어가 얻을 수 있는 최대 돌의 수라고 하자. suffix[i]는 i번째 돌부터 끝까지 남은 돌의 합이다.

LeetCode 1510. Stone Game IV

Mon, 10 Aug 2026 20:32:58 +0900

문제

https://leetcode.com/problems/stone-game-iv

풀이

돌이 n개 있고, 매 턴마다 제곱수만큼의 돌을 가져간다. 마지막 돌을 가져가는 사람이 이긴다고 할 때, Alice가 이길 수 있는지 구하면 된다.

dp[i]를 돌이 i개 남았을 때 현재 차례인 사람이 이길 수 있는지로 정의한다. 어떤 제곱수 $r^2$을 가져간 뒤 상대 차례의 상태가 패배라면, 현재 플레이어는 그 선택으로 이길 수 있다.

따라서 점화식은 다음과 같다.

$$ dp[i] = \text{true} \quad \text{if there exists } r \text{ such that } dp[i - r^2] = \text{false} $$

Codeforces 1294C. Product of Three Numbers

Sat, 08 Aug 2026 22:41:23 +0900

문제

https://codeforces.com/problemset/problem/1294/C

풀이

테스트 케이스가 t개 존재한다. 먼저, 정수 n이 주어진다. 각 n에 대해 $n = a \times b \times c, \ a, b, c > 1, \ a \neq b, b \neq c, a \neq c$를 만족하는 세 정수 a, b, c가 존재하면 "YES"와 세 수를 출력하고, 그렇지 않으면 "NO"를 출력하면 된다.

인수 분해 문제이다. n이 3개의 정수의 곱으로 표현되어야 하는데, 3개의 정수가 서로소라는 제약조건은 없다. 64처럼 지수가 6이면 $64 = 2^1 \times 2^2 \times 2^3$ 처럼 표현할 수 있기 때문에 인수와 지수 둘 다 중요하다.

LeetCode 3302. Find the Lexicographically Smallest Valid Sequence

Sat, 08 Aug 2026 21:06:44 +0900

문제

https://leetcode.com/problems/find-the-lexicographically-smallest-valid-sequence

풀이

word1에서 인덱스를 고르고, 그 문자들로 word2를 만들면 된다. 선택한 문자는 순서를 유지해야 하고, word1의 문자 중 최대 하나는 다른 문자로 바꿔서 사용할 수 있다. 가능한 수열 중 인덱스가 사전순으로 가장 작은 것을 구하면 된다.

앞에서부터 무조건 현재 문자가 같은지 확인하면서 고르면 되지만, 문자가 다른 위치에서 변경 기회를 바로 사용해도 뒤쪽에 남은 문자를 모두 맞출 수 있는지 확인해야 한다. 즉, 현재 위치를 선택했을 때 남은 문자의 개수가 충분해야 한다.

Codeforces 459B. Pashmak and Flowers

Fri, 07 Aug 2026 20:55:17 +0900

문제

https://codeforces.com/problemset/problem/459/B

풀이

n의 원소가 있는 수열 b가 주어진다. b의 원소 두 개를 짝지었을 때, 두 원소의 차이가 가장 클때의 그 차이와, 그 경우의 원소짝의 개수 출력하면 된다.

경우의 수를 구하기 위해 ‘가장 큰 값’을 가진 원소의 개수와 ‘가장 작은 값’을 가진 원소의 개수를 구해야 한다. 가장 큰 값을 가진 원소의 개수를 $maxCount$, 가장 작은 값을 가진 원소의 개수를 $minCount$ 라고 했을 때, 경우의 수는 $maxCount \times minCount$로 어렵지 않게 구할 수 있다.

Codeforces 489C. Given Length and Sum of Digits

Thu, 06 Aug 2026 13:40:23 +0900

문제

https://codeforces.com/problemset/problem/489/C

풀이

자리수가 m이고 각 자리수의 합이 s인 정수 중 가장 큰 수와 가장 작은 수를 찾는 문제이다.

처음에는 DP로 접근했는데, DP로는 수의 개수 정도만 구할 수 있고, 최대값과 최소값을 찾기는 힘들 것 같았다. 그래서 다시 그리디로 접근했다.

자리수가 m인데 $1 <= m <= 100$ 이기 때문에, int 타입으로 수를 다루는건 쉽지 않고, 배열이나 벡터로 다루는게 더 쉽다.

최대값은 계수가 높은 쪽에 큰 숫자를 배치하고, 최소값은 계수가 낮은 쪽에 큰 숫자를 배치하는 방법을 사용하자.

Leetcode 3345. Smallest Divisible Digit Product I

Thu, 06 Aug 2026 13:32:20 +0900

문제

https://leetcode.com/problems/smallest-divisible-digit-product-i

풀이

n보다 큰 수 중에서 각 자리수의 곱이 t로 나눌 수 있는(나머지가 0인 ) 가장 작은 수를 리턴해야 한다.

문제의 제약조건이 $1 <= n <= 100$, $1 <= t <= 10$ 이라서 모든 수를 찾아봐도 된다.

정수의 각 자리수를 모두 곱한 수를 구하는 로직만 구현한 후에, n 부터 시작해서 숫자를 1씩 증가시키면서 t로 나눈 나머지를 구해서 찾으면 된다.

코드

class Solution:
 def smallestNumber(self, n: int, t: int) -> int:
 def productDigits(x: int) -> int:
 product = 1
 while x > 0:
 product *= x % 10
 x //= 10
 return product
 answer = n
 while productDigits(answer) % t != 0:
 answer += 1
 return answer

LeetCode 3310. Remove Methods From Project

Wed, 05 Aug 2026 21:10:33 +0900

문제

https://leetcode.com/problems/remove-methods-from-project

풀이

메소드 k에서 시작해서 도달할 수 있는 노드들을 ‘suspicious’ 하다고 했을 때, 이 ‘suspicious’한 메소드들을 k가 직, 간접적으로 호출하는 것을 제외하고도 호출되는 경우가 있는지 확인하고 있다면 전체 메소드를, 없다면 ‘suspicious’한 메소드를 제외하고 리턴하면 된다.

메소드들의 호출 관계가 단방향 엣지 그래프를 이루기 때문에, BFS나 DFS 무엇을 써도 쉽게 k가 직, 간접적으로 호출하는 함수들을 알 수 있다. k에서 시작해서 도달하는 모든 메소드들은 ‘suspicious’ 하기 때문에 방문 여부를 확인하는 배열을 그대로 사용하면 된다.

Codeforces 451B. Sort the Array

Wed, 05 Aug 2026 21:03:54 +0900

문제

https://codeforces.com/problemset/problem/451/B

풀이

n 크기 수열 a가 주어진다. 이 수열의 특정 구간을 선택해서 뒤집는 것을 1번 했을 때, 이 수열이 오름차순으로 정렬되어 있다면 "yes"와 그 구간을, 불가능하면 "no"를 출력하면 된다.

n의 제약 조건이 $1 <= n <= 10^5$ 이기 때문에, 브루트 포스로는 시간 내에 풀기 힘들다.

특정 구간을 선택해서 뒤집는 행동을 1번만 한다는 것이 힌트인데, 구간 하나를 1번 뒤집어서 수열 전체가 오름차순이 된다는 것은, 수열의 일부 구간만 내림차순 이라는 것이다.

Codeforces 580C. Kefa and Park

Tue, 04 Aug 2026 11:34:01 +0900

문제

https://codeforces.com/problemset/problem/580/C

풀이

노드의 값이 1 혹은 0인 트리 그래프와 그 크기인 정수 n이 주어진다. 루트 노드인 1번 노드에서 시작했을 때, 중간에 값이 1인 노드를 연속으로 m번을 초과해서 만날 수 없다. 이 때, 도달할 수 있는 리프 노드의 개수를 출력하면 된다.

트리 전체를 탐색하면서 연속으로 조우한 값이 1인 노드 개수를 관리하면 된다. 그리고 현재 방문한 노드가 리프 노드인지 판정하고, 만약 리프 노드면 1을 더하면 된다. 트리도 그래프이기 때문에, BFS, DFS 어느 쪽이든 가능하지만, 풀이를 할 때 DFS를 사용했다.

LeetCode 3731. Find Missing Elements

Tue, 04 Aug 2026 09:33:33 +0900

문제

https://leetcode.com/problems/find-missing-elements

풀이

연속된 정수 구간에 속한 모든 정수가 들어 있’던’ 수열 nums가 주어진다. 일부 원소가 사라진 상태인 상태인데, 이 사라진 원소들을 배열에 오름차순으로 담아 리턴하면 된다.

최대값과 최소값은 사라지지 않았다고 하니까, 정수 구간의 크기를 구할 수 있다. 그 정수 구간을 순회하면서 빠진 원소들을 찾으면 된다.

정렬을 이용해서 풀 수도 있는데, 이러면 시간 복잡도가 평균 $O(n \times \log n)$이 된다. 큰 차이는 안나지만 Hast Set을 이용하면 평균 $O(n)$에 풀 수 있다.

Codeforces 520B. Two Buttons

Mon, 03 Aug 2026 13:30:19 +0900

문제

https://codeforces.com/problemset/problem/520/B

풀이

정수 n, m이 주어지고, 연산 2개 (* 2, - 1)을 이용해서 n을 m으로 만드는데 필요한 연산의 최소 개수를 출력하면 된다.

$1 <= n, m <= 10^4$ 제약조건과 2배로 만드는 연산을 생각해보면 만들 수 있는 숫자의 개수는 최대 2만개 정도이다. 이 숫자들을 각각을 노드라 생각하면, 연산으로 정의되는 노드간 연결도 명확한 그래프로 생각할 수 있다.

그러면 이 문제는 최단 거리 문제가 되므로 BFS를 사용해서 쉽게 풀 수 있다. 2배 연산이 있으므로 방문 확인 배열의 크기를 m * 2로 잡고 BFS를 하면된다. (방문 확인 배열도 할 겸 거리를 세는 기능도 넣으면 좋다.)

Leetcode 1406. Stone Game III

Mon, 03 Aug 2026 12:31:05 +0900

문제

https://leetcode.com/problems/stone-game-iii

풀이

번호가 적힌 돌이 있고, 두 명(Alice, Bob)이 번갈아 가면서 그 돌을 1개에서 3개까지 가져갈 수 있다. 2명 다 이상적으로 플레이 했을 때, 돌에 적힌 번호를 더한 합이 더 많이 가져간 사람의 이름을 리턴하면 된다. 항상 Alice가 먼저 시작한다.

약간 특이한 DP 문제이다. 점화식을 ‘Alice’ ‘Bob’을 특정하지 않고 ‘현재 차례인 사람이 상대보다 돌을 가질 수 있는 최대 개수’로 정의해야한다.

점화식은 다음과 같다.

$$ dp[i] = \max \begin{cases} stoneValue[i] - dp[i+1] \\ stoneValue[i] + stoneValue[i+1] - dp[i+2] \\ stoneValue[i] + stoneValue[i+1] + stoneValue[i+2] - dp[i+3] \end{cases} $$

Leetcode 1979. Find Greatest Common Divisor of Array

Fri, 31 Jul 2026 20:36:12 +0900

문제

https://leetcode.com/problems/find-greatest-common-divisor-of-array

풀이

수열 nums의 원소 중 가장 큰 원소의 가장 작은 원소의 GCD를 리턴하면 된다.

처음에 max()와 min()을 썼는데, 제출 시간이 거의 최하위권이길래 for loop로 다시 작성했다.

GCD 자체는 유클리드 호제법을 이용해서 구한다.

코드

class Solution {
 func findGCD(_ nums: [Int]) -> Int {
 func gcd(_ a: Int, _ b: Int) -> Int {
 b == 0 ? a : gcd(b, a % b)
 }
 var min = Int.max
 var max = 0
 for num in nums {
 min = min > num ? num : min
 max = max < num ? num : max
 }
 return gcd(min, max)
 }
}

Codeforces 455A. Boredom

Fri, 31 Jul 2026 20:22:51 +0900

문제

https://codeforces.com/problemset/problem/455/A

풀이

배열a에서 얻을 수 있는 최대 점수를 구하는 DP 문제이다. 어떤 값 x를 선택하면 x만큼의 점수를 얻고, 배열에 있는 x - 1과 x + 1은 모두 제거된다.

여기서 중요한 점은 같은 값을 여러 개 가지고 있다면 하나씩 선택할 이유가 없다는 것이다. x를 선택하는 순간 x - 1과 x + 1은 모두 사용할 수 없으므로, 선택한다면 값이 x인 원소는 모두 선택하는 것이 항상 이득이다.

따라서 입력 배열의 순서는 의미가 없어지고, 각 숫자가 몇 번 등장하는지만 알면 된다. 값 x가 frequencies[x]번 등장한다면, x를 선택했을 때 얻는 점수는 x * frequencies[x]이다.

Codeforces 279B. Books

Thu, 30 Jul 2026 23:08:53 +0900

문제

https://codeforces.com/problemset/problem/279/B

풀이

책을 읽는데 걸리는 시간이 담긴 크기 n 배열 a가 주어지고, 책을 읽을 수 있는 시간 t가 주어진다. 특정 인덱스를 정해서 그 인덱스부터 책을 순서대로 읽었을때, 최대로 읽을 수 있는 책의 개수를 출력하면된다.

모든 경우의 수를 탐색하려면 $O(n^2)$의 시간 복잡도를 가지는데 책의 개수가 10만개 이므로, 시간 내로 해결하기는 힘들다.

‘순서대로’라는 조건이 있으므로, 투 포인터를 이용하면 쉽게 풀 수 있다.

단 배열 a의 원소의 크기가 t보다 클 수 있으므로, 단 한권의 책도 읽지 못하는 경우가 있다. 그래서 책을 0권 읽는 경우의 수도 생각해서 코드를 짜야 한다.

Leetcode 3014. Minimum Numbers of Pushes to Type Word I

Thu, 30 Jul 2026 22:58:21 +0900

문제

https://leetcode.com/problems/minimum-number-of-pushes-to-type-word-i

풀이

휴대전화의 2에서 8까지의 숫자에 문자를 배치할 수 있고, 2개 이상의 수가 배치되었을 땐 여러번 눌러야 뒤에 있는 숫자를 타이핑 할 수 있다. 스트링 word가 주어졌을 때, 버튼을 가장 적게 눌러 word를 타이핑 했을 때의 타이핑 수를 리턴하면 된다.

각 키의 첫 번째 문자는 1번, 두 번째는 2번… 눌러야 하므로 많이 등장하는 문자일수록 누름 횟수가 적은 앞자리에 배치해야 한다.

빈도수 내림차순 정렬 후, 인덱스를 8로 나눈 몫 + 1이 해당 문자의 누름 횟수가 된다.

Codeforces 189A. Cut Ribbon

Wed, 29 Jul 2026 10:55:29 +0900

문제

https://codeforces.com/problemset/problem/189/A

풀이

길이가 n인 리본이 하나 주어지고, 이를 a, b, c 의 크기로만 조각낼 수 있을 때, 최대로 만들 수 있는 조각의 개수를 출력하는 문제이다.

잘린 리본 조각의 크기가 정해져 있으므로, 그리디가 아니라 DP로 접근해야 한다. 그리디로 접근하면 마지막에 남은 리본 조각의 크기를 확정할 수 없기 때문이다. dp[i]를 길이 i인 리본을 조각냈을 때의 최대 조각 수로 정의하면, 점화식은 다음과 같다.

$$dp[i] = \max_{x \in {a, b, c}}(dp[i - x] + 1) \quad \text{if } i \geq x \text{ and } dp[i-x] \neq -1$$

LeetCode 3518. Smallest Palindromic Rearrangement II

Wed, 29 Jul 2026 10:36:59 +0900

문제

https://leetcode.com/problems/smallest-palindromic-rearrangement-ii

풀이

1번 문제와 마찬가지로 팰린드롬의 성질상 절반만 결정하면 전체가 결정된다. 따라서 이 문제는 절반 문자열의 k번째 사전순 순열을 구하는 문제로 단순화된다.

각 문자의 등장 횟수를 세고, 홀수 번 등장하는 문자는 팰린드롬의 가운데에 배치한다. 나머지는 2로 나눠 halfTable을 만든다. 절반 문자열에는 중복 문자가 있을 수 있으므로, 전체 순열 수는 단순히 $n!$이 아니라 중복 순열 공식으로 구해야 한다.

$$\frac{n!}{\prod_{i} n_i!}$$

여기서 n은 절반 문자열의 길이, n_i는 각 문자의 개수이다. 이 값이 k보다 작으면 k번째 순열이 존재하지 않으므로 빈 문자열을 반환한다.

Codeforces 230B. T-Primes

Tue, 28 Jul 2026 10:39:27 +0900

문제

https://codeforces.com/problemset/problem/230/B

풀이

T-Prime을 약수가 3개인 수라고 정의하고, $n$개의 크기의 수열 $x$의 원소 각각에 대해서 그 수가 T-Prime인지 확인하는 문제이다.

약수가 3개라는 뜻은, $1$과 자기 자신 그리고 $\sqrt{x_i}$만을 약수로 가진다는 뜻이다. 즉, T-Prime은 어떤 수의 제곱이어야 한다.

그 ‘어떤 수’의 조건은 무엇일까? 약수의 약수는 결국 약수이다. T-Prime은 $1$, ‘어떤 수’, 자기 자신만을 약수로 가지므로, ‘어떤 수’는 소수여야 한다. 결국 이 문제는 소수 판별 문제로 단순화된다.

$x_i$의 최댓값이 $10^{12}$이지만, T-Prime 여부를 판별하려면 $\sqrt{x_i}$가 소수인지만 확인하면 되므로 체는 $\sqrt{10^{12}} = 10^6$까지만 구성하면 충분하다. 에라토스테네스의 체의 시간복잡도는 (거의) $O(N)$이고, 이후 각 쿼리는 $O(1)$에 처리되므로, $n \leq 10^5$인 입력 전체에 대해 전처리 $O(10^6)$ + 쿼리 $O(n)$으로 풀 수 있다.

Leetcode 3517. Smallest Palindromic Rearrangement I

Tue, 28 Jul 2026 09:12:06 +0900

문제

https://leetcode.com/problems/smallest-palindromic-rearrangement-i

풀이

팰린드롬 스트링 s가 주어지고, 이 s의 원소들을 재배열 하여 만들 수 있는 팰린드롬중 가장 사전순으로 빠른 문자열을 리턴하는 문제이다.

s가 팰린드롬 스트링인것이 보장되니, 팰린드롬의 성질인 대칭을 이용하면 정렬 문제로 바꿀 수 있다. s의 원소 개수가 홀수인지 짝수인지만 주의하면 된다. 만약 홀수면 대칭의 중심이 존재하니, 원소 중 등장 횟수가 홀수인 원소가 존재한다.

s에서 등장하는 모든 원소의 등장 횟수를 센다.
s의 원소 개수가 홀수라면, 원소들 중 홀수번 등장하는 원소를 center를 찾는다. 이 원소가 팰린드롬의 중간에 들어가는 문자이다.
원소들의 등장 횟수를 절반으로 줄인 다음, 사전 오름차순으로 정렬한 스트링 half를 만든다.
half와 center 그리고 half를 뒤집은 스트링을 합쳐서 결과를 만든다.

코드

class Solution {
 func smallestPalindrome(_ s: String) -> String {
 var countTable = [Character: Int]()
 var half = ""
 var center = ""
 for element in s {
 countTable[element, default: 0] += 1
 }
 for (element, count) in countTable.sorted(by: { $0.key < $1.key }) {
 if count % 2 == 1 {
 center = String(element)
 }
 half += String(repeating: element, count: count / 2)
 }
 return half + center + String(half.reversed())
 }
}

Codeforces 25A. IQ Test

Mon, 27 Jul 2026 16:26:14 +0900

문제

https://codeforces.com/problemset/problem/25/A

풀이

n 개의 원소를 가진 수열이 입력으로 들어오고 입력으로 들어온 숫자 중 홀/짝이 다른 하나의 숫자의 인덱스(1-base 인덱스)를 출력하면 된다.

수열이 들어올 때마다 홀/짝 각각의 마지막 인덱스를 저장하고, 홀수의 개수, 짝수의 개수를 세면된다.

마지막 이렇게 얻어진 개수로 홀/짝인지 판별을 한 뒤에, 홀수면 짝수의, 짝수면 홀수의 마지막 인덱스를 출력하면 된다.

코드

#include <iostream>

int main() {
 int n;
 std::cin >> n;
 int oddCount = 0;
 int evenCount = 0;
 int oddIndex = 0;
 int evenIndex = 0;
 for (int i = 1; i <= n; ++i) {
 int number;
 std::cin >> number;
 if (number % 2 == 0) {
 evenCount++;
 evenIndex = i;
 } else {
 oddCount++;
 oddIndex = i;
 }
 }
 std::cout << (oddCount == 1 ? oddIndex : evenIndex) << std::endl;
}

Codeforces 4C. Registration System

Mon, 27 Jul 2026 11:07:19 +0900

문제

https://codeforces.com/problemset/problem/4/C

풀이

데이터베이스를 흉내내는 문제이다. n 개의 스트링이 입력으로 주어지고(각각의 스트링을 name 이라고 한다), 그 스트링이 만약 등록된 이름이면 이름 + 번호를 붙여서 출력하고 등록되지 않은 이름이면 'OK'를 출력하면 된다.

딕셔너리를 쓰면 가장 쉽게 해결 가능하다. 딕셔너리에 name을 키로, 그리고 등장한 횟수를 값으로 저장하면 쉽게 존재 판별과 번호 붙이기 둘 다 가능하다.

코드

#include <iostream>
#include <map>

int main() {
 int n;
 std::cin >> n;
 std::map<std::string, int> db;
 while (n--) {
 std::string name;
 std::cin >> name;
 if (db.find(name) != db.end()) {
 db[name]++;
 std::cout << name << db[name] << std::endl;
 } else {
 db[name] = 0;
 std::cout << "OK" << std::endl;
 }
 }
 return 0;
}

Leetcode 1464. Maximum Product of Two Element in an Array

Sun, 26 Jul 2026 10:34:58 +0900

문제

https://leetcode.com/problems/maximum-product-of-three-numbers

풀이

정수형 배열 nums 안에서 세 개의 수를 뽑아 곱한 값 중 최대값을 리턴하면 된다.

LeetCode 3536 3536번 문제처럼 nums 배열을 정렬하면 된다. 다만 이번에는 3개의 수를 뽑아야 하기에, 음수, 음수, 양수도 정답의 후보가 될 수 있다.

따라서 정답의 후보는 다음과 같다.

가장 작은 값 2개와 가장 큰 값 1개를 곱한 값
가장 큰 값 3개를 곱한 값

이 두 수를 계산한 다음, 대소를 비교해서 리턴하면 된다.

코드

class Solution:
 def maximumProduct(self, nums: List[int]) -> int:
 nums.sort()
 return max(nums[-1] * nums[-2] * nums[-3],nums[0] * nums[1] * nums[-1])

Leetcode 3536. Maximum Product of Two Digits

Sat, 25 Jul 2026 21:13:47 +0900

문제

https://leetcode.com/problems/maximum-product-of-two-digits

풀이

10 이상 10억 이하의 정수 n이 주어지고, 각 자리수 중 두 개를 골라서 곱한 값중 가장 큰 수를 리턴하면 되는 문제이다.

문제의 힌트에선 브루트 포스를 사용하라 했는데, 정렬하면 더 쉽게 풀 수 있다.

코드

class Solution:
 def maxProduct(self, n: int) -> int:
 digits = sorted(str(n), reverse=True)
 return int(digits[0]) * int(digits[1])

Leetcode 3514. Number of Unique XOR Triplets II

Fri, 24 Jul 2026 11:34:15 +0900

문제

https://leetcode.com/problems/number-of-unique-xor-triplets-ii

풀이

n 길이의 배열 nums가 주어지고, 여기에서 3개의 인덱스 i, j, k를 (i <= j <= k) 뽑아서 XOR 했을 때, 얻을 수 있는 모든 결과의 수를 리턴하는 문제이다.

Leetcode 3513 문제와 다른 점은, nums가 순열이 아니다. 따라서, 자연스럽게 모든 경우의 수를 커버하지 못한다. 다만, 인덱스 제약조건이 저번과 같으므로 ‘값 3개를 무작위’로 뽑는다는 점은 같다. 여전히 n이 최대 1500이기 때문에, $O(n^3)$ 으로 풀기에는 무리가 있다.

우선, 값의 중복을 가리지 않고, 인덱스도 가리지 않으므로 배열의 순서가 중요하지 않다. 따라서 배열에 있는 모든 중복을 제거하는 전처리를 한다.

Codeforces 492B. Vanya and Lanterns

Fri, 24 Jul 2026 02:34:52 +0900

문제

https://codeforces.com/contest/492/problem/B

풀이

길의 길이 l과 가로등의 위치 배열 a가 주어지고, 모든 가로등이 길 전체를 비춰야 할때, 가로등 하나가 비추는 거리 d를 출력하는 문제이다.

문제 풀이는 단순하다. 가로등 사이의 간격을 계산하고, 그 간격을 모두 채울수만 있으면 된다.

가로등이 길을 비추는 건 3가지 케이스로 생각해볼수 있다.

시작 가로등
(양 옆에 가로등이 있는) 중간 가로등
끝 가로동

1번 3번 케이스가 엣지 케이스인데, 중간 가로등은 가로등 사이의 거리의 절반 만큼만 비추면 되지만, 시작 가로등과 끝 가로등은 시작점과 자신의 위치까지를 모두 스스로 비춰야 해서, 따로 처리해줘야 한다.

Leetcode 3513. Number of Unique XOR Triplets I

Thu, 23 Jul 2026 10:33:25 +0900

문제

https://leetcode.com/problems/number-of-unique-xor-triplets-i

풀이

1에서 n까지의 모든 값이 들어있는 n 크기 배열 nums 배열이 주어지고, 그 배열에서 인덱스 3개 i, j, k (i <= j <= k)를 골라서 XOR 했을 때, 나올 수 있는 모든 값을 리턴하면 되는 문제이다.

nums 배열의 크기가 10만이고, 브루트 포스를하면 시간 복잡도가 $O(n^3)$ 이기 때문에 시간 내에 해결할 수 없다.

nums가 순열이라는 것과 XOR의 연산 특징을 알면 생각보다 간단한 공식으로 해결할 수 있다. 우선 인덱스 제약조건은 없는 것과 마찬가지인데, 등호를 포함한 대소관계이기 때문에, 인덱스를 중복해서 골라도 된다.

LeetCode 3499. Maximize Active Section With Trade I

Tue, 21 Jul 2026 10:29:30 +0900

문제

https://leetcode.com/problems/maximize-active-section-with-trade-i

풀이

'0'와 '1'로만 이루어진 문자열 s가 존재하고, 문제에서 주어진 연산을 최대 1번 적용하여 문자열에 있는 '1'의 개수를 최대로 만든 뒤 그 개수를 리턴하면 된다.

주어진 연산은 다음과 같다. (순서대로 둘 다 적용해야 한다.)

양 옆이 '0'로 둘러싸인 연속된 '1' 블록 하나를 선택해서 모두 '0'로 바꾼다.
양 옆이 '1'으로 둘러싸인 연속된 '0' 블록 하나를 선택해서 모두 '1'으로 바꾼다.

문제에서 s의 양 옆에 '1'을 붙이라 했는데, 이때 추가된 '1'은 최종 반환값에 포함되지 않는다.

Codeforces 1A. Theatre Square

Tue, 21 Jul 2026 10:28:57 +0900

문제

https://codeforces.com/problemset/problem/1/A

풀이

Codeforces에서 푼 첫 문제.

$n \times m$ 크기의 직사각형 도시가 있고, 그 도시를 $a \times a$ 크기의 타일로 뒤덮는 문제이다. 타일은 도시 경계를 넘어가도 되지만, 잘라선 안되고 겹쳐도 안된다. 즉, 필요한 타일의 개수는 가로/세로 각각을 $a$로 나눈 값을 올림하여 곱하면 된다.

문제에 간단한 함정이 하나 있는데, n, m, a의 범위가 최대 $10^9$이라 곱셈 결과가 int 범위를 넘어갈 수 있으므로 long long을 사용을 사용해야 한다.

코드

#include <iostream>
#include <cmath>

int main() {
 long long n, m, a;
 std::cin >> n >> m >> a;
 std::cout << ((n + a - 1) / a) * ((m + a - 1) / a) << std::endl;
 return 0;
}

LeetCode 1081. Smallest Subsequence of Distinct Characters

Mon, 20 Jul 2026 00:00:00 +0000

문제

https://leetcode.com/problems/smallest-subsequence-of-distinct-characters

풀이

문자열 s에 있는 모든 개별 문자를 정확히 한 번씩 포함하는 부분수열 중, 사전순으로 가장 작은 것을 리턴하면 된다.

처음에 투 포인터를 생각했는데, 원소가 굳이 쭉 이어질 필요가 없으니 스택을 활용했다. 처음에 전처리로 각 문자의 마지막 등장 인덱스를 구해둔다.

스택 top의 마지막 인덱스가 현재 인덱스보다 크면 뒤에 또 나온다는 뜻이므로 제거할 수 있다. 스택에 문자를 추가하기 전, 아래 세 조건을 모두 만족할 때 top을 pop하면 된다.

스택이 비어있지 않다
스택 top이 현재 문자보다 크다 (사전순으로 뒤에 있다)
스택 top 문자가 뒤에 또 등장한다 (lastIndice[stack[-1]] > idx)

코드

class Solution:
 def smallestSubsequence(self, s: str) -> str:
 stack = []
 lastIndice = {}
 for idx, c in enumerate(s):
 lastIndice[c] = idx
 for idx, c in enumerate(s):
 if c in stack:
 continue
 while stack and c < stack[-1] and lastIndice[stack[-1]] > idx:
 stack.pop()
 stack.append(c)
 return "".join(stack)

LeetCode 1260. Shift 2D Grid

Mon, 20 Jul 2026 00:00:00 +0000

문제

https://leetcode.com/problems/shift-2d-grid

풀이

$m \times n$ 2d 그리드에 있는 원소들을 오른쪽으로 k번 민 결과를 리턴하면 된다.

grid[row][n - 1] → grid[row + 1][0] : 마지막 열의 원소는 다음 행의 첫 번째 열로 이동
grid[m - 1][n - 1] → grid[0][0] : 마지막 행의 마지막 열 원소는 첫 번째 행의 첫 번째 열로 이동

k번 직접 반복하는 대신, 그리드를 1차원으로 평탄화하면 shift 연산이 단순한 배열 회전으로 바뀐다.

평탄화한 배열을 오른쪽으로 k칸 회전시킨 뒤, 다시 $m \times n$ 2차원 배열로 복원하면 된다. 단, k가 배열 길이 $m \times n$ 보다 클 수 있으므로 모듈러 연산으로 정규화한다.

Leetcode 3867. Sum of GCD of Formed Pairs

Thu, 16 Jul 2026 10:29:15 +0900

문제

https://leetcode.com/problems/sum-of-gcd-of-formed-pairs

풀이

문제에서 지시한 내용을 그대로 구현하면 되는 문제다. 문제의 지시사항은 다음과 같다:

인티저 배열 nums의 누적 최대값 배열 mx를 만든다.
prefixGcd[i] = gcd(nums[i], mx[i]) 으로 이루어진 배열을 만든다.
prefixGcd를 오름차순 정렬한다.
prefixGcd의 제일 큰 값과 제일 작은 값의 쌍을 만들어, GCD를 구하는 것을 더 이상 만들지 못할 때 까지 반복한다. 만약 prefixGcd의 원소의 개수가 홀수라서 페어을 만들지 못한 하나가 남는다면 무시한다.
‘4’에서 구한 모든 GCD 값의 합을 리턴한다.

페어을 만드는건 간단한 형태의 투 포인터로 해결했다. 정렬과 유클리드 호제법을 제외하곤 모두 $O(n)$에 해결되기 때문에, 시간복잡도는 $O(n \log n + n \log V) = O(n \log (nV))$이다.

Leetcode 3658. GCD of Odd and Even Sums

Wed, 15 Jul 2026 10:32:37 +0900

문제

https://leetcode.com/problems/gcd-of-odd-and-even-sums

풀이

인티저 n이 하나 주어지고 작은 짝수 n개, 가장 홀수 n개를 각각 모두 더한 합 간의 GCD를 구하는 문제이다.

문제에서 요구하는 내용이 너무 간단해서, gcd()를 쓰지 않고, 유클리드 호제법을 직접 작성해서 GCD를 구했다.

코드

class Solution {
public:
 int gcdOfOddEvenSums(int n) {
 int sumOdd = 0;
 int sumEven = 0;
 for (int num = 1; num <= n * 2; num++) {
 if (num % 2 == 0) sumEven += num;
 else if (num % 2 != 0) sumOdd += num;
 }
 while(sumEven) {
 sumOdd %= sumEven;
 swap(sumOdd, sumEven);
 }
 return sumOdd;
 }
};

Leetcode 3336. Find the Number of Subsequences With Equal GCD

Tue, 14 Jul 2026 09:28:12 +0900

문제

https://leetcode.com/problems/find-the-number-of-subsequences-with-equal-gcd

풀이

수열 nums이 주어지고, nums에서 서로 원소가 겹치지 않게 부분 수열을 두 개 만든 뒤, 각 부분 수열(이하 A, B라 함)의 GCD가 같은 경우의 수를 찾는 문제이다.

만약 브루트 포스를 시도한다면, 원소의 개수 n, 각 원소가 가질 수 있는 상태가 3개(부분 수열 A, 부분 수열 B, 아예 미포함)이므로, 시간 복잡도가 $O(n \times 3^n)$ 이 되는데, nums의 최대 크기가 200이므로 유효한 시간 내에 해결할 수 없다.

하지만 부분 수열을 점점 채워나가면서 두 부분 수열을 비교할 수 있으므로, DP를 사용하면 O(n * 부분 수열A의 최대 gcd * 부분 수열B의 gcd 최대값)이 된다. 문제의 제약조건에서 원소의 최대 크기는 200이고, GCD는 원소보다 클 수 없으므로, $O(n \times 200 \times 200)$으로 줄일 수 있다.

Leetcode 1331. Rank Transform of an Array

Mon, 13 Jul 2026 11:09:28 +0900

문제

https://leetcode.com/problems/rank-transform-of-an-array

풀이

배열의 각 원소를 크기 기준으로 순위로 변환해 리턴하는 문제이다. 배열을 정렬한 뒤 각 원소에 순위를 매핑하고, 원본 배열 순서대로 순위를 꺼내 리턴한다.

문제에서 주의점이 하나 있는데, 같은 숫자는 같은 순위를 가진다는 것이다. 따라서 매핑할 때, 중복처리를 해줘야 한다.

코드

class Solution:
 def arrayRankTransform(self, arr: List[int]) -> List[int]:
 sortedArr = sorted(arr)
 rankDict = {}
 rank = 1
 for element in sortedArr:
 if not element in rankDict:
 rankDict[element] = rank
 rank += 1
 return list(map(lambda x: rankDict[x], arr))

Leetcode 1291. Sequential Digits

Mon, 13 Jul 2026 10:59:57 +0900

문제

https://leetcode.com/problems/sequential-digits

풀이

low와 high 사이의 수 중, 각 자릿수가 123, 3456 처럼 연속으로 이어지는 수를 모두 리턴하는 문제이다

문제와 제약조건을 보고 바로 DFS 백트래킹로 풀어야겠다는 생각을 했다. 구간의 크기가 최대 1억이기 때문에, 하나하나 확인하는 것은 무리가 있다. 따라서 수를 하나씩 붙여나가면서 확인하고, 조건에 벗어나면 프룬닝 하면 되는 전형적인 문제로 생각했다.

백트래킹으로도 충분히 빠른 속도로 문제를 풀 수 있지만, 문제를 제출하고 난 뒤 효율성을 검증해보니. high 크기가 최대 1억이기 때문에, 후보들의 수가 몇개 되지 않기 때문에, 실제로 자리수가 연속되는 모든 숫자들을 만들고 확인하는 방식이 더 빠를수도 있다고 한다.

Leetcode 3532. Path Existence Queries in a Graph I

Thu, 09 Jul 2026 09:21:23 +0900

문제

https://leetcode.com/problems/path-existence-queries-in-a-graph-i

풀이

그래프 각 노드의 연결 조건이 주어지고, 들어오는 쿼리들에 있는 두 노드들이 연결되어있는지 확인하는 문제이다.

queries 배열의 길이가 최대 10만이므로, BFS를 이용해서 풀기는 거의 불가능하다. BFS보다 더 빠르게 ‘연결 여부만’ 확인하는 방법은 Union-Find Set을 사용하면 된다.

우선 연결 조건은 두 노드의 절대 차이(노드 번호의 차이의 절대값)가 maxDiff 이하여야 하는데, 문제에서 nums 배열이 오름차순으로 정렬되어 있다고 했으므로, nums[j] - nums[i] <= maxDiff 를 만족하는 연속된 범위를 투 포인터로 찾을 수 있다.

Leetcode 3020. Find the Maximum Number of Elements in Subset

Thu, 09 Jul 2026 08:23:02 +0900

문제

https://leetcode.com/problems/find-the-maximum-number-of-elements-in-subset/

풀이

주어진 배열의 원소들로 만들 수 있는 가장 긴 [x, x², x⁴, ..., x^(2^k), ..., x⁴, x², x] 형태의 부분집합 길이를 반환하는 문제다. 이하에서는 이 형태를 피라미드라고 부른다.

어떤 문제든 제약 조건이 중요하지만, 이 문제는 특히 제약 조건이 중요하다. 주어진 꼴에서 원소들은 급격히 증가하는데, 1 <= nums[i] <= 10^9 라는 제약 조건이 있기에, 배열의 최대 크기를 예상할 수 있다.

x가 1일 때는 몇 번을 제곱해도 1이므로, nums 배열 내부에 있는 1의 개수에 따라 달려있다. 피라미드 꼴은 항상 홀수이므로, 1의 개수가 홀수일때는 그대로, 짝수일때는 1을 뺀 값을 문제에서 요구하는 최대값의 초기 값으로 정한다.

LeetCode 3756. Concatenate Non-Zero Digits and Multiply by Sum II

Wed, 08 Jul 2026 14:30:01 +0900

문제

https://leetcode.com/problems/concatenate-non-zero-digits-and-multiply-by-sum-ii

풀이

1번 문제와 로직은 동일하다. 차이점은 스트링 s의 서브스트링에 같은 작업을 queries마다 반복해야 한다는 점이다. queries의 원소가 최대 10만 개이므로, 매 쿼리마다 부분 문자열을 슬라이싱해서 처리하면 시간 초과가 난다. 따라서 전처리를 통해 각 쿼리를 $O(1)$ 혹은 $O(n \log n)$에 처리할 수 있도록 해야 한다.

전처리 단계에서 네 가지 누적 배열을 만든다.

pow10: $\text{pow10}[i] = 10^i \mod (10^9 + 7)$
preSum: 각 인덱스까지 자릿수의 합
preConcat: 각 인덱스까지 0이 아닌 숫자들을 이어붙인 값
nonZeroCount: 각 인덱스까지 0이 아닌 숫자의 개수

쿼리 [l, r]이 들어오면 네 배열로 x와 sum을 $O(1)$에 구해 $x \times \text{sum} \mod (10^9 + 7)$를 리턴한다. 0이 아닌 숫자가 없는 경우는 수식이 자연스럽게 $0$을 리턴하게 된다.

LeetCode 3754. Concatenate Non-Zero Digits and Multiply by Sum I

Tue, 07 Jul 2026 14:30:01 +0900

문제

https://leetcode.com/problems/concatenate-non-zero-digits-and-multiply-by-sum-i

풀이

문제에서 주어진 조건에 따라서 스트링을 조작하면 되는 간단한 문제이다. 인티저에서 스트링으로, 스트링에서 인티저로 타입 컨버전만 조심하면된다.

주어진 정수 n을 스트링으로 변환한 다음, 앞에서부터 순회하여 "0"을 제거한 스트링 filtered를 만든다.
filered를 인티저로 타입 컨버전 해서 x를 구한다.
filered의 각 원소를 인티저로 컨버전 한 다음, 합을 구해서 sum을 구한다.
x * sum을 리턴한다.

코드

class Solution:
 def sumAndMultiply(self, n: int) -> int:
 filtered = "".join(char for char in str(n) if char != "0")
 if not filtered:
 return 0
 return int(filtered) * sum(map(int, filtered))

LeetCode 1288. Remove Covered Intervals

Mon, 06 Jul 2026 12:33:49 +0900

문제

https://leetcode.com/problems/remove-covered-intervals

풀이

여러 개의 구간이 주어지고, 다른 구간에 완전히 포함되는 구간을 제거한 이후, 남은 구간의 개수를 리턴하면 되는 문제이다.

가장 쉬운 방법은 브루트 포스이다. 구간의 개수가 최대 1000개이기 때문에, O(n^2) 방식을 사용해도 충분히 통과 가능하다.

하지만 정렬을 이용하면 쉽게 O(n * log(n)) 으로 풀 수 있다.

구간 시작 부분을 기준으로 오름차순 정렬한다. 시작 부분이 같은 경우엔 끝 부분을 기준으로 내림차순 정렬한다.
정렬된 배열을 앞에서부터 순회하며, 지금까지 등장한 끝 부분의 최대값(maxEnd)을 추적한다.
현재 구간의 끝이 maxEnd보다 크면, 이전 어떤 구간에도 포함되지 않는 새로운 구간이므로 카운트하고 maxEnd를 갱신한다.
현재 구간의 끝이 maxEnd보다 작거나 같으면, 이전 구간에 완전히 포함되는 구간이므로 제거한다.

1번에서 시작 부분 기준으로 정렬했기 때문에, 시작 조건은 자동으로 만족되어 끝 부분만 비교하면 충분하다.

LeetCode 1301. Number of Paths with Max Score

Sun, 05 Jul 2026 14:30:01 +0900

문제

https://leetcode.com/problems/number-of-paths-with-max-score

풀이

2차원 그리드의 우하단에서 시작해 좌상단까지 이동하면서, 경로에 있는 숫자들의 합의 최대값과 그 최대값이 나오는 경로의 개수를 구하는 문제이다.

최단 거리를 찾는 문제가 아니므로 BFS나 Dijkstra는 필요 없고, 어떻게 경로의 수를 구할지가 핵심이다. 이동 방향은 문제에서 주어져 있으므로, 각 노드에서 인접한 노드들의 값을 활용해 특정 합(v)에 도달하는 경로의 개수를 구할 수 있다.

이런 문제를 효율적으로 푸는 방법은 결국 DP이다. 처음에 점화식을 이렇게 만들었다.

dp[r][c][v]: row = r, column = c인 노드에서 지나온 경로에 있는 칸들의 합이 v가 되는 경로의 개수.

테스트 케이스는 통과할 수 있었지만, 실제 제출했을 때는 시간 초과가 되어서 통과하지 못했다. v 차원 때문에 dp공간이 너무 커지는 것이 문제였다.

Programmers. 미로 탈출 명령어

Sat, 23 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/150365

풀이

분명히 배열(문자열)의 원소를 하나씩 채워나가야 하는 DFS 완전 탐색 스타일의 문제인데 k의 최대값이 2,500으로 너무 크다. 하지만 문제에서 주어진 조건들을 읽어보면 프루닝을 통해 백트래킹 문제로 만들 수 있다.

현재 위치와 종료 위치 사이의 맨하탄 거리가 남은 이동 횟수보다 적으면, 더 이상 탐색할 필요가 없다.
- 목표에 도달하지 못하는 분기이기 때문에, 분기를 버려야 한다.
남은 이동 횟수와 현재 위치와 종료 위치 사이의 맨하탄 거리의 차가 홀수인 경우에도 더 이상 탐색할 필요가 없다.
- 이동 횟수는 고정이고, 두 위치의 거리보다 크다면 이동 횟수를 어딘가에서 소모해야한다. 그런데 다른 위치로 갔다가, 다시 현재 위치로 돌아올때 소모하는 값은 2이므로, 홀수인 경우에는 목적지에 절대 도달할 수 없게 된다.
마지막으로, 탐색 순서를 잘 정했다면 처음으로 성공한 케이스가 곧 사전순에서 가장 앞선 순서가 된다. 한 번만 성공하게 되면 그 뒤의 모든 분기는 의미가 없어진다.

이렇게 프루닝을 하면 완전 탐색으로 절대로 해결 불가능한 문제를 풀 수 있게 된다.

Programmers. 표 편집

Thu, 14 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/81303

풀이

이 문제에서 핵심은 삭제된 칸을 건너 뛰면서 칸을 옮기는 것이다. 칸을 옮기는 횟수가 최대 1,000,000 번이라고 제한되어 있지만, 명령의 개수도 200,000 개 이므로 칸을 단순히 부울리언 값으로 켜고 끄면서 이동하는 것은 최악의 경우에 굉장히 많은 시간이 걸릴 것이다.

여기서 생각해야할 점은 이 문제에서는 ‘랜덤 액세스’를 요구하지 않는다는 것이다. 문제에서 삭제된 칸을 복구할때 커서를 옮기지 않는다고 했으므로, 랜덤 액세스가 들어갈 부분은 처음 커서 위치를 지정하는 부분밖에 없다. 또한 중간에 있는 칸을 삭제하고 복구하는 작업들이 있으므로, 컨테이너 중간에서 삭제/삽입 연산이 쉬운 자료구조를 생각해야 하고, 바로 링크드 리스트가 떠올랐다.

Programmers. 합승 택시 요금

Thu, 14 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/72413

풀이

문제를 간단히 하는 것이 중요하다. 이 문제에서 원하는 것은 S에서 시작해서 A와 B 노드로 가야하는데, 그 최단 거리를 요구하고 있다. 그러면 둘이 헤어지는 지점이 존재할 것이고, 이 헤어지는 지점은 S일 수도 있다(문제에서 주어진 내용이다). 그러면 헤어지는 지점을 M이라고 했을때, 우리가 구해야 하는 것은 S → M, M → A, M → B의 최단거리들의 합이다.

문제가 최단거리를 구하는 문제로 단순화 되었다. 음수 사이클이 존재하지 않으므로, 다익스트라 알고리즘이나 플로이드 워셜 알고리즘을 사용하면 된다. 만약 다익스트라를 사용한다면 M을 우리가 모르므로 모든 노드에 대해서 다익스트라 알고리즘을 적용해보고 M을 찾아야 한다. 플로이드 워셜은 모든 노드 상호간의 최단거리를 알 수 있고, 노드의 개수도 200개가 상한이기 때문에 플로이드 워셜을 쓰는 것이 훨씬 간단하게 풀 수 있다.

Programmers. 인사고과

Wed, 06 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/152995

풀이

정렬 문제다. 두 개의 수를 가진 튜플(혹은 배열)이 있고, 두 수의 합이 아닌, 각 수를 개별적으로 두 값이 모두 작거나 큰지 판단해야 하는 경우에는 첫 번째 기준이 되는 값은 오름차순, 그리고 두 번째 기준이 되는 값은 내림차순으로 정렬하는 것이 일반적이다. 반대도 가능하고, 이 문제에서도 첫 번째 기준이 되는 값을 내림차순, 두 번째 기준이 되는 값을 오름차순으로 정렬하는 것이 더 편하다.

순위를 셀 때도 조금은 최적화할 수 있다. 제거해야할 원소들을 제거하고 새로운 배열을 만드는 것이 아닌, 그냥 배열을 순회하면서, 기준이 되는 원소보다 큰 수를 카운트 하면 된다.

Programmers. 순위

Tue, 05 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/49191

풀이

처음에 문제를 막 읽었을 때는 조금 어려워 보이지만, 문장을 살짝 다르게 해석해보자. ‘정확하게 순위를 매길 수 있는 선수의 수’를 알아야 하는데 정확하게 순위를 매긴다는 것은 어떨 때 성립할까? 특정 선수 A가 존재할 때, A와 서로 승패를 알 수 없는 선수 B가 존재하면 정확하게 순위를 매길 수 없는 것이다. 반대로 A가 다른 모든 선수들과 확실하게 승패의 결과를 알 수 있다면, 정확하게 순위를 매길 수 있다.

문제에서는 경기 결과를 제공해주므로, 선수들의 실력을 간접적으로 알 수 있다. 실력을 수치화 해서 관리할 수 있으면 좋지만, 그럴게 할 수 없는 조건이고 그럴 필요도 없다. 단순하게 선수들간의 ‘승’, ‘패’ 결과를 그래프로 관리해주면 된다. 승리 그래프와 패배 그래프를 따로 만들어서, 경기 결과를 그래프로 표현하고, 각 선수마다 이 선수가 승리할 선수, 패배할 선수의 수를 세어주면 된다. 특정 선수가 다른 모든 선수들과 확실하게 승패의 결과를 알 수 있다는 것은, 결국 승리할 선수와 패배할 선수의 합이 현재 선수를 제외한 나머지 선수의 수와 같은 것이기 때문이다.

Programmers. 풍선 터트리기

Tue, 05 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/68646

풀이

문제의 조건은 쉬운데, 풀이 과정은 쉽지 않아보인다. 하지만 문제를 최대한 단순화해보자. 기본적으로, 인접한 두 풍선을 고를 수 있고 두 풍선중 번호가 더 큰 풍선을 터트려야 한다. 하지만 1회에 한정에서 번호가 더 작은 풍선을 터트릴 수 있다.

일단 기본적으로 마지막까지 남을 수 있는 풍선의 개수를 세야 하므로 모든 풍선에 대해 확인해봐야 한다. 그리고 마지막까지 남을 수 있는 풍선이라고 했으므로, 항상 마지막에 고르는 두 풍선들 중 하나는 현재 내가 확인하고 싶은 풍선일 것이다.

Programmers. 거스름돈

Sun, 03 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/12907

풀이

DP 문제다. 순열인지 조합인지 조심하면 쉽게 풀 수 있다. 문제에서 예시로 든 1, 2, 5원이 있을 때를 생각해보자. (5도 마찬가지지만) 2는 1의 배수이다. 따라서 순열로 하면 ‘3’을 만드는 경우에 1+1+1, 1+2, 2+1 이라는 세 가지 방법이 나오게 된다. 하지만 이 문제는 조합 문제이므로 중복을 제거해야한다.

그러면 중복을 어떻게 제거해야 할까? 작은 동전부터 순서대로 만들면 된다. 이 방법이 조합 DP의 가장 기본적인 방법이다.

가장 작은 동전을 써서 만들 수 있는 조합을 다 만든 다음 DP 테이블에 저장한다.
작은 순서대로 (오름차순으로) 조합을 더한다.

이런 식으로 하면 중복을 방지할 수 있다. 위 예제로 따지면 1원짜리 동전을 먼저 써서 1+1+1을 우선 만들고, 다음에 2원을 써서 1+2를 만든다. 작은 순서대로 하므로 알고리즘 상에서 2+1 같은 방법을 만들지 않는다.

Programmers. 셔틀버스

Sun, 03 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/17678

풀이

단순 구현으로 풀 수 있는 문제다. 문제를 단순화하면 조건에 맞는 최대 값을 구하는 문제이므로 바이너리 서치도 쓸 수 있겠다.

우선 시간을 다루는 문제에서는 시간, 분을 분으로 통일하는 경우가 더 시간을 다루기 쉬워지는 경우가 많다. 예를 들어서 셔틀의 첫 도착 시간인 9:00을 540으로 바꾸는 것이다.

그리고 timetable 배열의 길이가 최대 2000이므로 모든 배열을 순회해도, 심지어 $O(n^2)$시간으로 순회해도 아무런 걱정이 없다. 따라서 앞 번호부터 순서대로 버스에 태우면 된다. 이제 마지막 버스인 경우에 콘이 탈 수 있는 여유가 있다면, 마지막 버스의 도착 시간을 리턴하면 되고, 만약 여유가 없다면, 마지막 버스에 마지막으로 타는 사람보다 ‘1분’ 일찍 나오면 된다.

Programmers. 디스크 컨트롤러

Sat, 02 Aug 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/42627

풀이

우선 순위대로 문제를 처리하므로 힙을 써야하는 것은 명확하다. 하지만, 이 힙을 어떻게 다루느냐가 더 중요한 문제이기 때문에 사실상 힙보다는 단순 구현 문제에 가깝다.

코드

import heapq

def solution(jobs):
 jobs.sort(key = lambda x: x[0])
 waitQueue = []
 finished = 0
 currentTime = 0
 jobIdx = 0
 totalReturnTime = 0
 while finished < len(jobs):
 while jobIdx < len(jobs) and jobs[jobIdx][0] <= currentTime:
 requestTime, duration = jobs[jobIdx]
 heapq.heappush(waitQueue, (duration, requestTime))
 jobIdx += 1
 if waitQueue:
 duration, requestTime = heapq.heappop(waitQueue)
 currentTime += duration
 returnTime = currentTime - requestTime
 totalReturnTime += returnTime
 finished += 1
 else:
 currentTime = jobs[jobIdx][0]
 return totalReturnTime // len(jobs)

Programmers. 징검다리 건너기

Tue, 22 Jul 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/64062

풀이

처음 문제를 읽어보고 바이너리 서치를 이용해야겠다고 생각했다. 결정해야 할 값을 건널 수 있는 최대 인원수로 맞춰놓고 바이너리 서치를 이용하여 찾으면 되기 때문이다.

바이너리 서치를 이용한 알고리즘은 다음과 같다.

바이너리 서치를 통해 찾고 싶은 값은 징검다리를 건널 수 있는 최대 인원 수이다.
징검다리 하나의 내구도가 최대 2억이므로 1에서 2억까지의 범위 내에서 인원 수의 최대값을 찾는다
1. 값이 유효한지 체크하는 방법은 징검다리에서 현재 인원 수가 밟은 수를 뺀 다음 0 이하의 징검다리 돌들이 연속되는 경우가 k개 이하면 통과, 초과면 통과시키지 않는다.
바이너리 서치 결과를 리턴한다.

이 코드의 시간 복잡도는 $N$이 stones 배열의 크기, $M$이 돌 내구도의 최대값이라 했을 때 $O(N \log M)$이다. 돌 내구도의 최대값은 2억이고, 2의 30제곱이 약 10억이므로 30번 이내에 찾을 수 있다. 최대 20만 크기의 배열을 30번 정도 반복한다고 생각하면 충분히 시간 복잡도가 나온다.

Programmers. 단속 카메라

Mon, 21 Jul 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/42884

풀이

그리디 문제다. 그리디는 따로 정석 구현이 있는 알고리즘이 아니라 일종의 컨셉이지만, 배열 + 그리디면 잘 알다시피 정렬이 중요한 경우가 많다.

단순하게 생각해보자, 문제에서 주어지는 것은 시작 위치와 종료 위치다. 그냥 종료하는 위치를 기준으로 오름차순 정렬한 후에 앞에서부터 탐색을 한다.

현재 자동차의 종료 위치에 카메라를 설치하고, 다음 자동차를 살펴본다. 다음 자동차의 시작 위치가 이전 자동차의 종료 위치(즉 카메라가 설치된 위치)보다 앞에 있으면 다음 자동차도 설치된 카메라를 만나게 된다. 그렇지 않다면 또 그 자동차의 종료 위치에 카메라를 설치하면 된다.

Programmers. 불량 사용자

Mon, 21 Jul 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/64064

풀이

일정 크기의 배열(혹은 컬렉션)을 만들어서 매칭되는지 확인해야 하는 문제다.

DFS를 사용해서 모든 경우의 수를 만들기는 쉽지만, 그 경우의 수가 문제에서 제시하는 조건에 맞는지 확인하는 것은 어렵다. 따라서 알고리즘을 약간 수정해서 좀 더 효율적이고 만들기 쉬운 알고리즘을 만들어야 한다.

알고리즘은 다음과 같다:

주어진 banned_id 배열 원소 하나하나에 대응가능한 id를 user_id에서 뽑아서 후보 set에 넣는다.
1번을 재귀적으로 진행한다. set에 담는 이유는 id가 중복되면 안되기 때문이다.
후보 set이 완성되면, 정답 set에 저장한다. set은 set에 담을 수 없으므로 frozenset을 이용한다.
정답 set의 개수를 리턴한다.

코드

def compare(strA, strB):
 if len(strA) != len(strB):
 return False
 for char in zip(strA, strB):
 if char[0] != char[1] and char[1] != '*':
 return False
 return True

def dfs(user_id, banned_id, index, candidateSet, idSet):
 if index == len(banned_id):
 idSet.add(frozenset(candidateSet))
 return
 for id in user_id:
 if id in candidateSet:
 continue
 if compare(id, banned_id[index]):
 dfs(user_id, banned_id, index + 1, candidateSet + [id], idSet)

def solution(user_id, banned_id):
 idSet = set()
 dfs(user_id, banned_id, 0, [], idSet)
 return len(idSet)

Programmers. 최고의 집합

Sun, 20 Jul 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/12987

풀이

n의 값이 최대 10000, s의 값이 최대 1000000의 값을 가질 수 있으므로 모든 경우의 수를 DFS로 탐색하는 것은 매우 비효율적이다.

하지만 수학적 직관을 이용해 생각해보자. 예시로 주어진 s = 9, n = 2인 경우에서도 {4, 5}가 최고의 집합이다. 만약 s = 5, n = 2인 경우에는? {2, 3}이다. s = 10, n = 2인 경우는 {5, 5} 이다. 집합 원소들이 최대한 고르게 되어있을 때 원소들의 곱이 최대가 된다는 것(= 최고의 집합이라는 것)을 알 수 있다. 그러면 이 직관을 증명해보자.

BOJ 12852. 1로 만들기 2

Wed, 30 Apr 2025 00:00:00 +0000

문제

https://www.acmicpc.net/problem/12852

풀이

DP를 사용해서 해결했다.

문제를 거꾸로 뒤집어보자. n에서 1을 가는 최단거리가 아니라, 1에서 n으로 가는 최단거리로 바꾸는 편이 편하다.

이렇게 뒤집으면 개별 숫자에서 다른 숫자로 갈 수 있는 방법은 3가지가 주어진다.

1 더하기
2 곱하기
3 곱하기

쉽게 점화식을 만들 수 있다.

dp[i] = max(dp[i - 1], dp[i / 2], dp[i / 3]) + 1

하지만 경로도 트래킹 해야 하는데, 이건 각 개별 숫자에 도달하기 전에 어떤 수에서 왔는지를 저장하는 배열 하나를 만들고, 최종적으로 이 배열을 루프로 순회하거나, 재귀를 통해서 경로를 얻어낼 수 있다.

BOJ 2193. 이친수

Wed, 30 Apr 2025 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2193

풀이

문제에서 명시적으로 두 가지 조건을 제공해준다.

0으로 시작하지 않는다.
1이 연속되지 않는다.

이진수라는 조건도 있으므로, 3가지 조건이 있다고 볼 수 있다.

케이스를 몇개 써보면 쉽게 DP로 풀 수 있는걸 알 수 있다.

dp[1] = 1 // 1
dp[2] = 1 // 10
dp[3] = 2 // 100, 101
dp[4] = 3 // 1000, 1001, 1010

2번째 조건 때문에, 0으로 끝나는 경우에는 1을 붙일 수 있지만, 1로 끝나는 경우에는 0으로 붙일 수 없는 것을 알 수 있다.

DP 테이블을 다음과 같이 정의하자.

Programmers. 순위 검색

Tue, 07 Jan 2025 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/72412

풀이

많이 해맨 문제다. 처음에는 다음과 같이 알고리즘을 생각했다.

일단 쿼리의 개수와 info 배열의 크기를 생각해보면 filter를 사용하는 문제는 아님
바이너리 서치, Upper bound와 Lower bound의 차이가 해당하는 원소의 개수가 같음
info 배열을 잘 정렬해서 바이너리 서치만 하면 쉽게 해결될 문제

하지만 조금만 생각해보면 이러한 방식의 알고리즘은 문제를 절대로 해결할 수 없다.

우선 쿼리의 조건들이 독립적이다. 정렬 기준에 따라서 포함되어야 할 값이 포함되지 않게 된다.
그렇다고 바이너리 서치 -> 다시 정렬을 반복하기엔 차라리 filter를 쓰는게 더 시간 복잡도가 더 좋다.

다음에 생각한 방식은 트리를 이용하는 방식이었다.

BOJ 13144. list of unique numbers

Wed, 12 Jun 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/13144

풀이

매우 특이한 유형의 투 포인터 문제다. start, end가 증가만 해서는 모든 경우의 수를 나타낼 수 없으며, 모든 경우의 수를 탐색하려면 O(n^2)이 된다.

1 2 3 1 2 라는 수열이 있을 때를 생각해보자

겹치는 원소가 나오지 않도록 작성한 일반적인 투 포인터는 1, 12, 123, 231, 312 이렇게 5번 탐색을 하고 종료한다. 하지만 1 2 3 1 2의 정답은 5가 아니라 15이다. 하지만 이 5번의 탐색만으로도 15라는 결과를 얻을 수 있는데, 우리는 정확한 부분 수열의 형태보다 경우의 수만 알면 되기 때문이다.

BOJ 4179. 불

Mon, 10 Jun 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/4179

풀이

지훈이가 움직이고, 불을 퍼뜨리면 된다. 순서대로 진행하면 되는데 주의해야 할 점이 두 가지 있다.

1분마다 기준으로 번갈아서 움직여야 한다.
지훈이가 움직이기 전에 불에 타면 안된다.

코드

from collections import deque

def bfs(jihun, fires):
 is_jihun_Visited = [[-1] * c for _ in range(r)]
 fire_queue = deque()
 jihun_queue = deque()
 fire_queue.append(fires)
 jihun_queue.append([jihun])

 is_jihun_Visited[jihun[0]][jihun[1]] = 0

 while jihun_queue or fire_queue:
 if jihun_queue:
 jihun_temp_queue = []
 jihun_nodes = jihun_queue.popleft()
 for cur in jihun_nodes:
 if graph[cur[0]][cur[1]] == "F":
 continue
 for move in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
 next = (cur[0] + move[0], cur[1] + move[1])
 if next[0] == -1 or next[1] == -1 or next[0] == r or next[1] == c:
 return is_jihun_Visited[cur[0]][cur[1]] + 1
 if next[0] < 0 or next[0] >= r or next[1] < 0 or next[1] >= c:
 continue
 if is_jihun_Visited[next[0]][next[1]] != -1:
 continue
 if graph[next[0]][next[1]] == ".":
 jihun_temp_queue.append(next)
 is_jihun_Visited[next[0]][next[1]] = is_jihun_Visited[cur[0]][cur[1]] + 1
 if jihun_temp_queue:
 jihun_queue.append(jihun_temp_queue)

 if fire_queue:
 fire_temp_queue = []
 fire_nodes = fire_queue.popleft()
 for cur in fire_nodes:
 for move in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
 next = (cur[0] + move[0], cur[1] + move[1])
 if next[0] < 0 or next[0] >= r or next[1] < 0 or next[1] >= c:
 continue
 if graph[next[0]][next[1]] == ".":
 fire_temp_queue.append(next)
 graph[next[0]][next[1]] = "F"
 if fire_temp_queue:
 fire_queue.append(fire_temp_queue)
 return "IMPOSSIBLE"

r, c = map(int, input().split())
graph = []
for _ in range(r):
 graph.append(list(input()))

jihun = (0, 0)
fires = []

for row in range(r):
 for column in range(c):
 if graph[row][column] == "J":
 jihun = (row, column)
 elif graph[row][column] == "F":
 fires.append((row, column))

print(bfs(jihun, fires))

BOJ 7490. 0 만들기

Mon, 10 Jun 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/7490

풀이

DFS 문제이다. 3가지 연산자 (" ", "+", "-")를 배치하는 모든 경우의 수를 수식으로 만든 후 계산하면 된다.

코드

import Foundation

func calcuate() {
 var rawExpression = ""
 for idx in 0..<n - 1 {
 rawExpression += String(seq[idx])
 rawExpression += cal[idx]
 }
 rawExpression += String(seq[n - 1])

 let expression = rawExpression.replacingOccurrences(of: " ", with: "")
 var numbers = [Int]()
 var operators = [Character]()
 var numBuffer = ""
 for element in expression {
 if element.isNumber {
 numBuffer.append(element)
 } else {
 numbers.append(Int(numBuffer)!)
 operators.append(element)
 numBuffer = ""
 }
 }
 if let lastNumber = Int(numBuffer) {
 numbers.append(lastNumber)
 }

 var result = numbers[0]
 for idx in 0..<operators.count {
 if operators[idx] == "-" {
 result -= numbers[idx + 1]
 } else {
 result += numbers[idx + 1]
 }
 }
 if result == 0 {
 print(rawExpression)
 }
}

func dfs() {
 if cal.count == n - 1 {
 calcuate()
 return
 }
 for op in [" ", "+", "-"] {
 cal.append(op)
 dfs()
 cal.removeLast()
 }
}

let t = Int(readLine()!)!

var n = Int()
var seq = [Int]()
var cal = [String]()

for _ in 0..<t {
 n = Int(readLine()!)!
 seq = Array(1...n)
 cal = []
 dfs()
 print()
}

BOJ 2668. 숫자고르기

Tue, 04 Jun 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2668

풀이

문제를 간단하게 표현하면 그래프 내의 사이클을 모두 찾은 다음에, 사이클에 포함되는 노드을 모두 출력하면 된다. 사이클을 찾으려면 그래프내의 모든 노드에서 dfs를 쓰면 되는데 다음과 같은 케이스들로 나눌 수 있겠다.

1. 사이클에 도달하긴 하나 시작 노드는 사이클에 포함되지 않는 케이스

주어진 예제에서 2번, 4번, 6번, 7번 노드가 해당한다.

탐색을 시작한 노드에서 사이클에 도달하긴 하나, 시작한 노드는 사이클에 포함되지 않는다. 최적화를 위해 이러한 케이스에도 사이클만 따로 분리해 중복되는 연산을 줄일 수 있겠지만, 이 문제의 n이 큰 수가 아니므로, 그냥 아무런 행동도 하지 않는다.

BOJ 14719. 빗물

Tue, 28 May 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14719

풀이

스택 문제이다. 빗물은 양 옆이 블록으로 막혀있을 때, 낮은 블록의 높이를 기준으로 그 사이에 빗물이 고이게 된다. 따라서 스택을 하나 만들고 인덱스 순서대로 입력받은 다음에, “현재까지” 가장 높게 쌓여있던 블록의 높이(currentMax)와 같거나 더 높게 쌓여있는 블록이 스택에 들어오려 할 때, 스택에 쌓여있는 모든 블록들을 빼내면서 고여있는 물의 양을 더하면 된다(currentMax - 중간 블록의 높이).

하지만 이러한 방법을 쓰면 문제점이 하나 있는데, 블록이 계속 커진다는 보장이 없기 때문에, 마지막에 있는 블록들이 붕 뜨게 된다. 이 때는 스택을 뒤집어서 해결하면 된다. 현재 currentMax보다 더 큰 수가 앞에 존재하지 않는다면 뒤집힌 스택은 무조건 currentMax가 마지막에 존재하게 된다. (만약 currentMax보다 낮은 블록은 이미 pop된 상태일 것이기 때문에) 따라서 스택을 뒤집은 다음(혹은 다른 스택에 차례대로 옮긴 후에) 이 전의 과정을 한번 반복하면 문제가 해결된다.

BOJ 17266. 어두운 굴다리

Mon, 06 May 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/17266

풀이

가로등 간의 최대 간격을 찾으면 되는 문제이다. 일반적인 가로등 간의 간격과, 시작점과 첫 가로등의 간격, 도착점과 마지막 가로등의 간격을 알아내면 된다.

가로등 사이의 간격은 양 사이드 모두가 가로등이기 때문에 간격에서 2를 나눠줄 필요가 있다.

이 문제에는 작은 함정이 하나 있는데, 가로등 사이의 간격이 만약 홀수인 경우에는 2로 나눴을 때 0.5가 내림 되기 때문에 주의해야 한다.

코드

import Foundation

let n = Int(readLine()!)!
let m = Int(readLine()!)!
let x = readLine()!.split(separator: " ").map { Int($0)! }

var answer = max(x.first!, n - x.last!)
for idx in 1..<m {
 let interval = Int(ceil(Double(x[idx] - x[idx - 1]) / 2.0))
 if interval > answer {
 answer = interval
 }
}
print(answer)

BOJ 14890. 경사로

Fri, 19 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14890

풀이

경사로의 방향을 생각해보면 왼쪽에서 오른쪽으로 올라가는 방향이 있을 것이고, 그 반대인 오른쪽에서 왼쪽으로 올라가는 방향도 있을 것이다. 이러한 경우에는 한 번에 해결하기 보다는 배열을 정방향, 역방향으로 각각 순회하여 경사로를 만들어주는 것이 좋다.

따라서 알고리즘은 다음과 같다.

주어진 2차원 배열을 Transpose한 배열을 하나 더 만든다. 세로 모양의 길을 찾기 위해서이다.
정방향으로 우선 순회한다. 다음에 있는 칸의 높이가 현재 칸보다 같으면 count를 하나 늘리고(count는 경사로를 지을 수 있는지 판단할 때 사용한다.) 1 낮으면 일단은 패스(역방향에서 확인한다), 1 높으면 경사로를 설치할 수 있는지 판단한다.
경사로를 설치할 수 있는지 판단하는 기준은 두 가지이다. 일단 경사로를 설치하기 충분한 공간이 확보되었는가 (count로 충분한 공간이 얼마나 있는지를 알 수 있다.), 만약 가능하다면 이미 그곳에 경사로가 설치되어 있지는 않는가(이는 is_built 배열로 추적한다. 하지만 정방향을 먼저 하므로 지금 상황에선 필요 없다.)
역방향으로 순회한다. 정방향과 같지만 정방향을 순회하면서 경사로를 지은 곳을 유의할 필요가 있다.

코드

def check(line):
 is_built = [False] * n
 current_height = line[0]
 count = 1
 for idx in range(1, n):
 if current_height == line[idx]:
 count += 1
 elif current_height - line[idx] == 1:
 current_height = line[idx]
 continue
 elif current_height - line[idx] == -1:
 if count >= l:
 for back in range(1, l + 1):
 is_built[idx - back] = True
 count = 1
 else:
 return False
 current_height = line[idx]
 else:
 return False

 current_height = line[n - 1]
 count = 1
 for idx in range(n - 2, -1, -1):
 if current_height == line[idx]:
 count += 1
 elif current_height - line[idx] == 1:
 current_height = line[idx]
 continue
 elif current_height - line[idx] == -1:
 if count >= l:
 for back in range(1, l + 1):
 if is_built[idx + back]:
 return False
 is_built[idx + back] = True
 count = 1
 else:
 return False
 current_height = line[idx]
 else:
 return False
 return True

n, l = map(int, input().split())
graph = []
graph_tranposed = [[0] * n for _ in range(n)]
answer = 0

for _ in range(n):
 graph.append(list(map(int, input().split())))

for row in range(n):
 for column in range(n):
 graph_tranposed[row][column] = graph[column][row]

for idx in range(n):
 answer += 1 if check(graph[idx]) else 0
 answer += 1 if check(graph_tranposed[idx]) else 0

print(answer)

BOJ 14891. 톱니바퀴

Fri, 19 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14891

풀이

상황 설명이 굉장히 난해하고 비직관적이므로 글을 잘 읽어야 한다. 문제를 겨우 이해하고 나면 알고리즘이나 구현 능력 자체는 크게 요구하지 않는다. 글을 이해하는것 자체가 이 문제의 가장 큰 난관이다.

이 문제에서 톱니바퀴는 현실의 톱니바퀴처럼 움직이지 않는다. 이전 톱니바퀴가 회전하면 다음 톱니바퀴도 회전해야할지 말아야 할지를 이미 돌아간 상태의 이전 톱니바퀴가 아닌 돌기 전의 이전 톱니바퀴의 상태로 판단해야 한다.

코드

class Gear():
 def __init__(self, stat):
 self.__stat = stat
 self.__top = 0
 self.__left = 6
 self.__right = 2

 def rotate(self, drct):
 self.__top = (self.__top - drct) % 8
 self.__left = (self.__left - drct) % 8
 self.__right = (self.__right - drct) % 8

 @property
 def top(self):
 return self.__stat[self.__top]
 @property
 def left(self):
 return self.__stat[self.__left]
 @property
 def right(self):
 return self.__stat[self.__right]

def left_shift(gear_num, drct):
 new_drct = drct * -1
 cur_gear = gear_num
 for next_gear in range(gear_num - 1, 0, -1):
 if gears[next_gear].right != gears[cur_gear].left:
 rotate_queue.append((next_gear, new_drct))
 cur_gear = next_gear
 new_drct *= -1
 else:
 break

def right_shift(gear_num, drct):
 new_drct = drct * -1
 cur_gear = gear_num
 for next_gear in range(gear_num + 1, 5):
 if gears[next_gear].left != gears[cur_gear].right:
 rotate_queue.append((next_gear, new_drct))
 cur_gear = next_gear
 new_drct *= -1
 else:
 break

gear1 = Gear(list(map(int, input())))
gear2 = Gear(list(map(int, input())))
gear3 = Gear(list(map(int, input())))
gear4 = Gear(list(map(int, input())))
gears = [None, gear1, gear2, gear3, gear4]

k = int(input())
answer = 0

rotate_queue = []

for _ in range(k):
 num, drct = map(int, input().split())
 rotate_queue.append((num, drct))
 left_shift(num, drct)
 right_shift(num, drct)
 for g, d in rotate_queue:
 gears[g].rotate(d)
 rotate_queue = []

rank = 1
for idx in range(1, 5):
 answer += gears[idx].top * rank
 rank *= 2

print(answer)

BOJ 14499. 주사위 굴리기

Mon, 15 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14499

풀이

특별한 알고리즘이나 문제 해결 기법을 사용할 필요 없이, 순수하게 딕셔너리 자료구조만을 사용해서 풀 수 있는 문제이다.

주어진 주사위의 전개도를 이용하여 각 면에 숫자를 붙이고(면에 써져있는 숫자가 아닌 각 면을 인식하게 해주는 숫자, 이하 ID숫자라고 하겠다.) 이를 방향: ID 숫자의 꼴로 딕셔너리를 생성한다.

또 ID숫자: 면에 적힌 숫자 꼴로 딕셔너리를 하나 더 생성하여 두개의 딕셔너리로 주사위의 방향과 각 면에 적혀있는 숫자를 추적할 수 있다.

코드

import copy

def north():
 global dice_drct
 original_drct = copy.deepcopy(dice_drct)
 for new, ori in zip(["u", "l", "n", "e", "w", "s"], ["s", "n", "u", "e", "w", "l"]):
 dice_drct[new] = original_drct[ori]

def south():
 global dice_drct
 original_drct = copy.deepcopy(dice_drct)
 for new, ori in zip(["u", "l", "n", "e", "w", "s"], ["n", "s", "l", "e", "w", "u"]):
 dice_drct[new] = original_drct[ori]

def east():
 global dice_drct
 original_drct = copy.deepcopy(dice_drct)
 for new, ori in zip(["u", "l", "n", "e", "w", "s"], ["w", "e", "n", "u", "l", "s"]):
 dice_drct[new] = original_drct[ori]

def west():
 global dice_drct
 original_drct = copy.deepcopy(dice_drct)
 for new, ori in zip(["u", "l", "n", "e", "w", "s"], ["e", "w", "n", "l", "u", "s"]):
 dice_drct[new] = original_drct[ori]

def change():
 if graph[x][y] == 0:
 graph[x][y] = dice_num[dice_drct["l"]]
 else:
 dice_num[dice_drct["l"]] = graph[x][y]
 graph[x][y] = 0

def check(x, y):
 if x < 0 or x >= n or y < 0 or y >=m:
 return False
 return True

n, m, x, y, k = map(int, input().split())
graph = []
for _ in range(n):
 graph.append(list(map(int, input().split())))
orders = list(input().split())

dice_num = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}
dice_drct = {"u": 1, "l": 6, "n": 2, "e": 3, "w": 4, "s": 5}

for order in orders:
 isTrue = False
 if order == "1":
 if check(x, y + 1):
 y += 1
 east()
 change()
 isTrue = True
 if order == "2":
 if check(x, y - 1):
 y -= 1
 west()
 change()
 isTrue = True
 if order == "3":
 if check(x - 1, y):
 x -= 1
 north()
 change()
 isTrue = True
 if order == "4":
 if check(x + 1, y):
 x += 1
 south()
 change()
 isTrue = True
 if isTrue:
 print(dice_num[dice_drct["u"]])

BOJ 12100. 2048(Easy)

Sun, 14 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/12100

풀이

최대 20 * 20 크기의 보드에서 2048 게임을 하는 것이다. 최대 5번의 이동만 한다고 문제에 주어져 있으므로, 모든 경우를 탐색하여 문제를 풀 수 있다.

이 문제에서 주의해야할 점은 다음과 같다.

이동하는 방향에서 가까운 숫자부터 이동해야한다.
한 번의 이동동안 이미 합쳐진 숫자는 다시 합쳐지지 않는다.

이 두가지 조건만 잘 생각하면서 작성하면 된다.

코드

import Foundation

func dfs(_ size: Int) {
 if size == 5 {
 for row in 0..<n {
 for column in 0..<n {
 answer = max(answer, graph[row][column])
 }
 }
 return
 }
 for i in 0..<4 {
 let currentGraph = graph
 shift(i)
 dfs(size + 1)
 graph = currentGraph
 }
}

func shift(_ order: Int) {
 var isMerged = [[Bool]](repeating: [Bool](repeating: false, count: n), count: n)
 if order == 0 {
 for row in 0..<n {
 for column in 0..<n {
 if graph[row][column] != 0 {
 var newRow = row
 while newRow > 0 {
 if graph[newRow - 1][column] == 0 {
 let temp = graph[newRow][column]
 graph[newRow][column] = graph[newRow - 1][column]
 graph[newRow - 1][column] = temp
 newRow -= 1
 } else if graph[newRow][column] == graph[newRow - 1][column] {
 if isMerged[newRow - 1][column] {
 break
 }
 let temp = graph[newRow][column]
 graph[newRow][column] = graph[newRow - 1][column]
 graph[newRow - 1][column] = temp * 2
 graph[newRow][column] = 0
 isMerged[newRow - 1][column] = true
 break
 } else {
 break
 }
 }
 }
 }
 }
 }
 if order == 1 {
 for column in 0..<n {
 for row in (0..<n).reversed() {
 if graph[row][column] != 0 {
 var newRow = row
 while newRow < n - 1 {
 if graph[newRow + 1][column] == 0 {
 let temp = graph[newRow][column]
 graph[newRow][column] = graph[newRow + 1][column]
 graph[newRow + 1][column] = temp
 newRow += 1
 } else if graph[newRow][column] == graph[newRow + 1][column] {
 if isMerged[newRow + 1][column] {
 break
 }
 let temp = graph[newRow][column]
 graph[newRow][column] = graph[newRow + 1][column]
 graph[newRow + 1][column] = temp * 2
 graph[newRow][column] = 0
 isMerged[newRow + 1][column] = true
 break
 } else {
 break
 }
 }
 }
 }
 }
 }
 if order == 2 {
 for row in 0..<n {
 for column in 0..<n {
 if graph[row][column] != 0 {
 var newColumn = column
 while newColumn > 0 {
 if graph[row][newColumn - 1] == 0 {
 let temp = graph[row][newColumn]
 graph[row][newColumn] = graph[row][newColumn - 1]
 graph[row][newColumn - 1] = temp
 newColumn -= 1
 } else if graph[row][newColumn] == graph[row][newColumn - 1] {
 if isMerged[row][newColumn - 1] {
 break
 }
 let temp = graph[row][newColumn]
 graph[row][newColumn] = graph[row][newColumn - 1]
 graph[row][newColumn - 1] = temp * 2
 graph[row][newColumn] = 0
 isMerged[row][newColumn - 1] = true
 break
 } else {
 break
 }
 }
 }
 }
 }
 }
 if order == 3 {
 for row in 0..<n {
 for column in (0..<n).reversed() {
 if graph[row][column] != 0 {
 var newColumn = column
 while newColumn < n - 1 {
 if graph[row][newColumn + 1] == 0 {
 let temp = graph[row][newColumn]
 graph[row][newColumn] = graph[row][newColumn + 1]
 graph[row][newColumn + 1] = temp
 newColumn += 1
 } else if graph[row][newColumn] == graph[row][newColumn + 1] {
 if isMerged[row][newColumn + 1] {
 break
 }
 let temp = graph[row][newColumn]
 graph[row][newColumn] = graph[row][newColumn + 1]
 graph[row][newColumn + 1] = temp * 2
 graph[row][newColumn] = 0
 isMerged[row][newColumn + 1] = true
 break
 } else {
 break
 }
 }
 }
 }
 }
 }
}

var n = Int(readLine()!)!
var graph = [[Int]]()
for _ in 0..<n {
 graph.append(readLine()!.split(separator: " ").map { Int(String($0))! })
}
var answer = 0

dfs(0)
print(answer)

BOJ 13460. 구슬 탈출 2

Sat, 13 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/13460

풀이

기울이는 방향에 따라서 구슬이 이동하므로, 구슬이 이동할 수 있는 방향은 상하좌우임을 알 수 있다. 이 때, 한 번 기울일 때 마다 구슬의 최종 위치는 하나가 나오므로, BFS를 이용해서 문제를 해결할 수 있다.

문제의 조건을 정리하면 다음과 같다.

한 칸에는 구슬 한 개만 들어갈 수 있다.
한 번 기울이면 구슬이 더 이상 움직이지 못할 때 까지 움직인다.
10번 이하의 횟수로만 기울인다.

1, 2 조건을 조합하면 구슬이 다른 구슬을 만나도 벽을 만난것과 같음을 알 수 있고, 따라서 구슬이 겹친 경우에는 처리를 해줘야 한다.

BOJ 10021. watering the fields

Fri, 12 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/10021

풀이

“모든 필드를 파이프 네트워크로 연결하는 데 필요한 최소 금액"에서 MST 문제임을 알았다. 크루스칼 알고리즘을 쓰면 쉽게 풀릴 문제다.

우선 각 노드간의 거리를 알 수 없으므로 모든 경우의 수를 계산해야 한다. 필드의 개수가 2000개 이하이므로 O(n^2)의 연산을 해도 충분하다.

그 이후에는 크루스칼 알고리즘을 적용하면 되는데, 제약조건 중 하나가 비용이 C 미만인 파이프는 만들지 않는다는 것이다. 따라서 두 노드간 거리가 C 미만인 엣지는 존재하지 않는 것으로 해야한다.

코드

def find(field):
 if parent[field] == field:
 return field
 else:
 parent[field] = find(parent[field])
 return parent[field]

def union(a, b):
 pa = find(a)
 pb = find(b)
 if pa != pb:
 parent[pa] = pb

def squared_euclidean_length(a, b):
 return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2

n, c = map(int, input().split())
fields = []
mapping = {}

for idx in range(n):
 xi, yi = map(int, input().split())
 fields.append((xi, yi))
 mapping[(xi, yi)] = idx
edges = []
parent = list(range(n))

for i in range(0, len(fields) - 1):
 for j in range(i + 1, len(fields)):
 distance = squared_euclidean_length(fields[i], fields[j])
 if distance >= c:
 edges.append((mapping[fields[i]], mapping[fields[j]], distance))

edges.sort(key = lambda x: x[2])

answer = 0
count = 0
for edge in edges:
 if find(edge[0]) != find(edge[1]):
 union(edge[0], edge[1])
 answer += edge[2]
 count += 1

print(answer if count == n - 1 else -1)

BOJ 15591. mootubesliver

Fri, 12 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/15591

풀이

문제가 복잡하게 설명되어 있다. 중요한 것은 모든 노드가 연결되어 있고 웨이트를 가진 엣지가 존재하지만, 두 노드간의 거리는 경로상의 가장 작은 웨이트를 가진 엣지가 된다.

따라서 웨이트가 있다 해서 다익스트라를 쓸 필요가 없다. 들어오는 쿼리마다 BFS를 이용하여 그래프를 탐색하고 두 노드간의 거리는 실시간으로 업데이트 해주면 된다.

코드

from collections import deque

def bfs(k, v):
 queue = deque()
 queue.append((v, 987_654_321))
 isVisited = [False] * (n + 1)
 isVisited[v] = True
 answer = 0

 while queue:
 cur_node, cur_usado = queue.popleft()
 for next_node, next_usado in graph[cur_node]:
 if isVisited[next_node]:
 continue
 if cur_usado < next_usado:
 next_usado = cur_usado
 if next_usado >= k:
 queue.append((next_node, next_usado))
 isVisited[next_node] = True
 answer += 1
 print(answer)

n, q = map(int, input().split())
graph = {}
for _ in range(n - 1):
 pi, qi, ri = map(int, input().split())
 if pi in graph:
 graph[pi].append((qi, ri))
 else:
 graph[pi] = [(qi, ri)]
 if qi in graph:
 graph[qi].append((pi, ri))
 else:
 graph[qi] = [(pi, ri)]

for _ in range(q):
 k, v = map(int, input().split())
 bfs(k, v)

BOJ 5558. チズ cheese

Fri, 12 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/5558

파파고 번역

올해도 JOI 마을의 치즈 공장이 치즈 생산을 시작하여, 쥐들이 둥지에서 얼굴을 내밀었다. JOI 마을은 동서남북으로 구획 정리되어 있고, 각 구획은 둥지, 치즈 공장, 장애물, 공터 중 하나이다. 쥐들은 둥지에서 출발하여 모든 치즈 공장을 방문 하여 치즈를 한 개씩 먹는다.
이 마을에는 N개의 치즈 공장이 있는데, 모든 공장이 한 종류의 치즈만을 생산한다. 치즈의 단단함은 공장마다 다르고 단단함도 다르다 1부터 N까지의 치즈를 생 산하는 치즈공장이 마침 하나씩 있다.
증가
쥐들의 첫 번째 체력은 1이고, 치즈를 한 개 먹을 때마다 그들의 체력은 1증가 하지만, 쥐들은 자신의 체력보다 더 단단한 치즈를 먹을 수는 없다.
쥐는 동서남북으로 이웃한 구역으로 1분이면 이동할 수 있지만, 장애물 구역에는 들어갈 수 없다. 치즈 공장을 치즈를 먹지 않고 지나갈 수도 있다. 치즈를 다 먹을 때까지 걸리는 가장 짧은 시간을 요구하는 프로그램을 작성하라. 쥐가 치즈를 먹 는 데 걸리는 시간은 무시할 수 없다.

풀이

처음에 문제를 읽었을 땐, 치즈를 먹는 순서를 어떻게 정해야 하나 싶었지만, 시작 할 때 쥐의 체력이 1 고정이므로 고민할 필요 없이 1, 2, 3, …, N 순서대로 먹으면 된다.

BOJ 14226. 이모티콘

Tue, 09 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14226

풀이

현재 상태를 나타내는 변수를 화면에 있는 이모티콘의 개수, 클립보드에 저장되어 있는 이모티콘의 개수로 나타낼 수 있다. 각각의 연산이 모두 1초가 걸리므로 BFS를 사용할 수 있다.

BFS를 사용하려면 노드에 방문했는지를 판별할 방법이 필요한데, 여기에선 Array보다는 Set을 쓰는것이 효율적이다. 두 개의 정수가 노드를 구성하므로 2차원 배열을 만들면 되겠지만, 이런 방식으로 한다면 배열의 크기가 너무 커질 뿐더러 효율적인 배열의 크기를 정하기도 머리가 복잡해진다. 따라서 방문한 노드를 Set에 저장해서 contains()함수로 방문 여부를 판단하는 방식을 이용한다.

BOJ 10159. 저울

Sun, 07 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/10159

풀이

노드간의 연결 여부를 따지는 따지는 문제이므로 처음에는 단순히 Union-Find Set을 사용하면 될 줄 알았다. 하지만 물건 A와 B의 관계가 있을 때 가능한 경우의 수는 ‘A가 B보다 무겁다’ 혹은 ‘B가 A보다 무겁다’ 두 가지의 경우가 있으므로 방향 그래프 가 된다. 따라서 Union-Find Set을 사용하는 것 보다는 방향 그래프에서도 적용 가능한 알고리즘을 사용해야 한다. (아래의 코드에서 엣지의 방향은 무거운 쪽에서 가벼운 쪽으로 했으며. 반대로 해도 상관 없다.)

문제에서 각 물건에 따라서 그 물건과의 비교 결과를 알 수 없는 물건의 개수를 출력하라고 했기 때문에, 노드에서 다른 노드로 가는 모든 경우의 수를 알아야 한다. 따라서 다익스트라 알고리즘을 n번 쓰거나 플로이드-워셜 알고리즘을 한 번만 쓰면 된다.

BOJ 14658. 하늘에서 별똥별이 빗발친다

Sun, 07 Apr 2024 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14658

풀이

우선 최악의 경우를 생각해보자. N, M이 각각 500,000 이고, L은 1, K가 100일 때가 최악인 경우가 된다. 이 상태에서 모든 경우의 수를 확인하려면 별의 위치를 250,000,000,000,000번 확인해야 한다. 따라서 모든 경우의 수를 판단하는건 불가능 하다.

따라서 트램펄린을 설치할 위치를 합리적으로 정해야 한다. 주어진 조건을 보면 별이 최대 100개 까지밖에 없으므로 이를 활용하여 생각해본다.

우선 별 하나를 기준으로 보면 L * L 크기의 트램펄린이고, 별이 최대 100개 있으므로 확인해야 할 위치는 최악의 경우에 100,000,000,000,000개 이다. 사실상 위의 경우와 다를바가 없으므로 불가능하다.

BOJ 17298. 오큰수

Mon, 10 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/17298

풀이

스택을 이용하는 문제이다. 2493번 문제와 사실상 같은 문제인데, 배열이 뒤집혀 있다는 것과 인덱스가 아닌 해당 인덱스에 대응하는 값을 사용하는 것이 다르다.

코드

Swift

import Foundation

let n = Int(readLine()!)!
let a = Array(readLine()!.split(separator: " ").map { Int(String($0))! }.reversed())
var stack: [Int] = []
var answer: [Int] = []

for element in a {
 while !stack.isEmpty && stack.last! <= element {
 stack.removeLast()
 }
 if let last = stack.last {
 answer.append(last)
 } else {
 answer.append(-1)
 }
 stack.append(element)
}

print(answer.map { String($0) }.reversed().joined(separator: " "))

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
 int n;
 cin >> n;
 vector<int> a;
 for(int i = 0; i < n; i++) {
 int temp;
 cin >> temp;
 a.push_back(temp);
 }
 vector<int> stack;
 vector<int> answer;
 reverse(a.begin(), a.end());
 for(int element: a) {
 while(!stack.empty() && stack.back() <= element) {
 stack.pop_back();
 }
 if(stack.empty()) {
 answer.push_back(-1);
 } else {
 answer.push_back(stack.back());
 }
 stack.push_back(element);
 }
 for(int answerIndex = (int)answer.size() - 1; answerIndex >= 0; answerIndex--) {
 cout << answer[answerIndex] << " ";
 }
}

BOJ 2293. 동전 1

Mon, 10 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2293

풀이

DP를 사용하는 문제이다. dp 테이블의 각 인덱스가 해당 인덱스 만큼의 가치를 만들 수 있는 경우의 수 라고 하면 쉽게 풀 수 있다.

동전의 가치를 value라고 하면 그 동전을 하나 추가해서 i만큼의 가치를 만들 수 있는 경우의 수는 dp[i] += dp[i - value] 라고 할 수 있다. 따라서 하나의 가치에 대해서 동전의 종류의 수 만큼 반복문을 돌려야 한다.

문제에서 주어진 또 다른 조건은 경우의 수가 2의 31제곱이 넘지 않는다는 것이다. 또한 스위프트에서는 오버플로우를 방지하기 위해 2의 31제곱이 넘어가는 수를 다 제거해줘야 한다. (최종적으로 출력할 결과가 2의 31제곱이 넘어가지 않으므로 중간에 2의 31제곱이 넘는 값은 자연스럽게 쓸모가 없는 값이 된다.)

BOJ 2493. 탑

Mon, 10 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2493

풀이

스택을 사용하면 쉽게 풀 수 있는 문제이다. 각 탑에서 왼쪽에 신호를 발사하므로, 현재 인덱스보다 앞에 있는 인덱스중 가장 먼저 나오는 값이 더 큰 인덱스를 찾으면 된다.

현재 인덱스의 탑과 스택의 top에 있는 인덱스의 탑을 비교한다. top 인덱스의 탑이 더 크면 이 인덱스에 있는 탑은 처음으로 신호를 받는 탑이므로, answer 배열에 추가한다. 그렇지 않다면, 해당 인덱스에 있는 탑은 신호를 받지 못하는 탑 이므로 스택에서 제거한다. 현재 인덱스가 다음 인덱스들의 신호를 받을 수 있으므로 스택에 현재 인덱스를 추가한다.

BOJ 1939. 중량 제한

Fri, 07 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1939

풀이

섬(노드)들과 다리(엣지)로 이루어진 그래프가 주어지고, 그 다리들 사이를 지나 목표 노드에 도착해야 한다.

다리에 웨이트가 존재하지 않고 (중량 제한은 엣지가 유효한지 판단하는 기준일 뿐 엣지의 웨이트랑 관련 없다) 최단 거리를 구하는 문제도 아니므로, 다익스트라 알고리즘이 아닌 BFS를 이용해 탐색할 수 있다.

중량이 늘어날수록 건널 수 있는 다리가 적어진다(엣지가 비활성화 된다). 우리는 이 때 주어진 두 섬 중 하나의 섬에서 다른 하나의 섬으로 갈 수 있는 최대의 중량을 구하면 된다. 리니어 서치로도 결과를 구할 수야 있겠지만 현실적으로 1 - 1,000,000,000 값을 다 탐색하는건 너무 비효율적이기 때문에 바이너리 서치를 하면 된다.

BOJ 1520. 내리막 길

Thu, 06 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1520

풀이

dfs를 이용하면 쉽게 풀 수 있는 문제일 것 같지만, 주어지는 그래프의 크기가 커서 시간초과가 나오는 문제이다. 하지만 이러한 문제들은 중첩되는 연산이 많으므로 DP를 이용하면 시간초과 없이 해결할 수 있는 경우가 흔하다.

DP의 컨셉은 다음과 같다.

그래프의 특정 칸에서 목적지로 도착하는 경우의 수는 앞선 경로에 상관없이 항상 같다.
따라서 각 칸에서 목적지로 가는 경로의 수를 dp테이블에 메모이제이션 한다면 불필요한 연산을 하지 않아도 된다.

따라서 점화식을 dp[x][y] = dp[x - 1][y] + dp[x + 1][y] + dp[x][y - 1] + dp[x][y + 1]로 일반화 할 수 있다. 각 항에서 탐색이 불가능한 칸((x, y)보다 높은 칸, 존재하지 않는 칸) 에 대응되는 항은 제외해야하기 때문에 엄밀히 말해서는 틀리지만, 이해하는데는 충분하다.

BOJ 16234. 인구 이동

Thu, 06 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/16234

풀이

그래프 각 원소를 전체 탐색하며, BFS를 수행하는 문제이다. 탐색할 수 있는 칸에 대한 제약조건이 문제에 제시되므로, 이에 따라 BFS를 수행하면 된다.

알고리즘은 다음과 같다.

그래프 전체를 순서대로 순회한다. 이 때 칸이 isVisited가 false인 칸에서 bfs를 수행한다. 따라서 isVisited는 전역 변수(혹은 call by reference)가 되어야 한다.
bfs로 탐색한 칸은 서로 연합이 가능한 칸이다. bfs 탐색의 조건은 문제에 상세히 적혀있다. 그래프 전체를 순회하며 bfs 탐색을 실시하고 각 칸의 값을 조정하면, 이게 문제에서 말하는 ‘하루’가 지난 것이다. isVisited가 false인 칸만 연합을 수행하므로, 앞선 칸에서 수행한 bfs 탐색이 뒤에 있는 칸에 영향을 끼칠 일은 없다.
1회의 인구 이동이 끝났어도 또 인구 이동이 가능할 수 있다. 따라서 1.을 더 이상 인구이동이 불가능해 질 때까지 수행한다.

코드

import Foundation

func bfs(root: (Int, Int)) -> Bool {
 struct Queue {
 private var queue = [(Int, Int)]()
 private var ptr = 0
 var isEmpty: Bool {
 ptr >= queue.count
 }
 mutating func insert(v: (Int, Int)) {
 queue.append(v)
 }
 mutating func delete() -> (Int, Int) {
 let popped = queue[ptr]
 ptr += 1
 return popped
 }
 }
 let moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]
 var queue = Queue()
 var union: [(Int, Int)] = [root]
 var unionPop = graph[root.0][root.1]
 queue.insert(v: root)
 isVisited[root.0][root.1] = true
 while !queue.isEmpty {
 let node = queue.delete()
 for move in moves {
 let newNode = (node.0 + move.0, node.1 + move.1)
 if newNode.0 < 0 || newNode.0 >= n || newNode.1 < 0 || newNode.1 >= n { continue }
 if isVisited[newNode.0][newNode.1] { continue }
 let differ = abs(graph[node.0][node.1] - graph[newNode.0][newNode.1])
 if differ >= l && differ <= r {
 isVisited[newNode.0][newNode.1] = true
 queue.insert(v: newNode)
 union.append(newNode)
 unionPop += graph[newNode.0][newNode.1]
 }
 }
 }
 let dividedPop = unionPop / union.count
 for element in union {
 graph[element.0][element.1] = dividedPop
 }
 if union.count > 1 {
 return true
 } else {
 return false
 }
}

let nlr = readLine()!.split(separator: " ").map { Int(String($0))! }
let (n, l, r) = (nlr[0], nlr[1], nlr[2])
var graph = [[Int]]()
for _ in 0..<n {
 graph.append(readLine()!.split(separator: " ").map { Int(String($0))! })
}
var isVisited = [[Bool]](repeating: [Bool](repeating: false, count: n), count: n)
var answer = 0

while true {
 var isEnd = true
 for row in 0..<n {
 for column in 0..<n {
 if !isVisited[row][column] && bfs(root: (row, column)){
 isEnd = false
 }
 }
 }
 if isEnd {
 break
 }
 isVisited = [[Bool]](repeating: [Bool](repeating: false, count: n), count: n)
 answer += 1
}
print(answer)

BOJ 14502. 연구소

Wed, 05 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14502

풀이

dfs와 bfs가 합쳐진 문제이다. 벽을 꼭 3개를 세워야 하므로 dfs를 이용하여 벽을 세울 위치를 전체 탐색할 수 있다. 연구소의 크기가 최대 8 * 8 이므로 전체 탐색하는데 큰 문제가 발생하지 않는다.

벽을 세웠으면 bfs를 이용하여 바이러스가 퍼졌을 때의 연구소의 모습을 그린다. 이 때 바이러스가 지나간 자리는 2로 마킹되고, 벽은 바이러스가 지나가지 못하므로 isVisited와 같은 배열이 없어도 이미 지나간 곳임을 알 수 있다.

알고리즘을 순서대로 나타내면 다음과 같다.

BOJ 6087. 레이저 통신

Wed, 05 Jul 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/6087

풀이

다익스트라 알고리즘을 사용하여 해결하는 문제이다. 각 인접한 노드가 연결되어있다고 생각하고, 전의 노드에서 현재 노드로 온 방향과 수직인 노드만 거리를 1로 설정해주면 된다.

일반적인 다익스트라 알고리즘 문제에서는 연결된 노드간의 거리가 주어지는데, 이 문제에서는 연결된 노드의 거리를 0으로 할지, 1로 할지 선택해야한다. 하지만 다익스트라 알고리즘과 BFS의 관계를 잘 생각해보면, 어렵지 않게 풀 수 있다(개인적으로 BFS는 일종의 다익스트라 특이 케이스라고 생각한다.)

알고리즘은 다음과 같다.

그래프에서 인접한 칸끼리는 서로 연결된 노드라고 가정함 (노드간 거리는 기본적으로 0으로 생각)
현재 있는 칸에서 내가 바라보고 있는 방향을 기준으로 수직인 노드는 거리가 1, 아닌 노드는 0으로 설정
2.를 반복하면서 다익스트라 수행

vertical은 가로 이동 horizontal은 세로 이동 neutral은 중립 방향인데, 시작 지점이나 아래에서 설명할 다른 Direction이지만 같은 거리에 있는 노드가 가지는 방향이다. none은 아직 탐색하지 않은 노드가 가지는 방향이다.

BOJ 1049. 기타줄

Fri, 16 Jun 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1049

풀이

6개 묶음 패키지의 가격과 낱개의 가격이 각각 여러 개가 주어졌을 때, 가장 적은 비용으로 n개 이상의 수를 채워야 하는 문제이다.

문제의 알고리즘은 다음과 같다.

패키지의 가격과 낱개의 가격이 같이 들어오므로 현재 가장 싼 패키지와 낱개의 가격과, 입력으로 들어온 가격을 각각 비교해서 갱신한다.
패키지만 샀을때, 낱개만 샀을때, 패키지와 낱개를 동시에 샀을때 세가지 경우를 비교해서 가장 비용이 낮은 값을 출력한다.

이 문제에서 구매 수량에 제한을 두지 않았으므로, 굳이 배열을 만들고 정렬을 할 필요가 없다. 패키지든 낱개든 무조건 가장 싼 가격만 알고 있으면 된다.

BOJ 11000. 강의실 배정

Fri, 16 Jun 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/11000

풀이

정렬 후 그리디를 수행하는 전형적인 그리디 알고리즘 문제이다.

강의가 시작하는 시간과 끝나는 시간이 주어져 있으므로 배열에 입력으로 주어진 시간들을 저장한 다음에 정렬해서, 강의가 가장 많은 시간의 강의 수를 출력하면 된다.

알고리즘을 글로 표현하면 다음과 같다.

수업이 시작하는 시간과 끝나는 시간을 배열 lecture에 저장한다. 이때 배열은 [(Int, Bool)] 타입이며, Int에는 시간, Bool에는 강의가 시작하는 시간일 경우 true, 끝나는 시간일 경우 false를 저장한다.
배열 lecture를 정렬한다.
lecture를 for 반복문으로 전체 순회한다. 튜플의 두 번째 원소가 true인 경우 현재 진행 중인 강의 수를 저장하는 변수 current의 값을 1 더한다. false인 경우 강의가 끝난 것 이므로 변수 current의 값을 1 뺀다.

이때, 배열 lecture를 시간순으로만 정렬하게 되면 문제에서 다음과 같은 부분 때문에 문제가 생긴다.

Programmers. 하노이의 탑

Wed, 03 May 2023 00:00:00 +0000

문제

https://school.programmers.co.kr/learn/courses/30/lessons/12946

풀이

이런 문제는 문제를 읽었을 때 어떻게 풀어야 할지 감이 잘 잡히지 않는다. 이러한 상황에서는 우선 문제를 시각화 해보자.

좌측은 n = 1일때, 우측은 n = 2일때의 이동을 시각화 한 것이다. 빨간색 숫자는 원판을 뜻하고 파란색 선은 이동루트를 뜻한다. n = 1 일 때는 당연한 이동 경로지만 n = 2일 때는 중간에 있는 기둥을 사용해야한다. 하지만 아직까진 규칙이 뚜렷하게 드러나지 않는다.

n = 3 일때의 이동경로를 시각적으로 나타냈다. 사실 직접 손으로 그리지 않고 다른 사람이 그린 그림으로 봤을 땐 아직도 규칙이 아리송 할 수 있지만 손으로 직접 그렸을 땐 규칙을 바로 알아 챌 수 있다.

BOJ 1753. 최단경로

Sun, 05 Mar 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1753

풀이

다익스트라 입문 문제이다. 단, 스위프트로 풀려면 힙을 직접 구현해야 한다.

입력으로 주어지는 엣지의 웨이트가 모두 같다는 조건이 없으므로, BFS가 아닌 다익스트라로 탐색해야 한다.

코드

import Foundation

struct Heap {
 var heap: [(Int, Int)] = []

 func isEmpty() -> Bool {
 return heap.isEmpty ? true : false
 }

 mutating func insert(_ value: (Int, Int)) {
 heap.append(value)
 var currentIndex = heap.count - 1
 while currentIndex > 0 {
 let parentIndex = (currentIndex - 1) / 2
 if heap[currentIndex].1 < heap[parentIndex].1 {
 heap.swapAt(currentIndex, parentIndex)
 currentIndex = parentIndex
 } else {
 break
 }
 }
 }

 mutating func deleteMin() -> (Int, Int) {
 if heap.isEmpty{
 return (0, 0)
 }
 let min = heap[0]
 heap[0] = heap[heap.count - 1]
 heap.removeLast()

 var currentIndex = 0
 while true {
 let leftChildIndex = 2 * currentIndex + 1
 let rightChildIndex = 2 * currentIndex + 2

 if leftChildIndex >= heap.count {
 break
 }
 var minChildIndex = leftChildIndex
 if rightChildIndex < heap.count && heap[rightChildIndex].1 < heap[leftChildIndex].1 {
 minChildIndex = rightChildIndex
 }
 if heap[minChildIndex].1 < heap[currentIndex].1 {
 heap.swapAt(currentIndex, minChildIndex)
 currentIndex = minChildIndex
 } else {
 break
 }
 }
 return min
 }
}

func dijkstra(k: Int) {
 var heap = Heap()
 heap.insert((k, 0))
 distanceTable[k] = 0
 while !heap.isEmpty() {
 let edge = heap.deleteMin()
 if distanceTable[edge.0] < edge.1 {
 continue
 }
 for node in graph[edge.0] {
 let cost = edge.1 + node.1
 if cost < distanceTable[node.0] {
 distanceTable[node.0] = cost
 heap.insert((node.0, cost))
 }
 }
 }
}

let ve = readLine()!.split(separator: " ").map { Int(String($0))! }
let k = Int(readLine()!)!
var graph = [[(Int, Int)]](repeating: [], count: ve[0] + 1)
for _ in 0..<ve[1] {
 let uvw = readLine()!.split(separator: " ").map { Int(String($0))! }
 graph[uvw[0]].append((uvw[1], uvw[2]))
}
var distanceTable = [Int](repeating: 300_001, count: ve[0] + 1)

dijkstra(k: k)

for i in 1...ve[0] {
 if distanceTable[i] == 300_001 {
 print("INF")
 } else {
 print(distanceTable[i])
 }
}

BOJ 14003. 가장 긴 증가하는 부분 수열 5

Wed, 01 Mar 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/14003

풀이

LIS(Longest Increasing Subsequence)라고 하는 유명한 DP 문제이다. 이 문제 외에도 연계된 문제들이 많으니 1번(BOJ 11053)부터 차례대로 풀면 어느새 여기까지 풀게 된다.

이 문제들은 총 2가지 기준으로 분류된다. 첫 번째 기준은 O(n²), O(nlogn) 두 번째는 LIS 출력 여부이다. 이 중에 O(nlogn) 알고리즘을 사용하고 LIS를 직접 출력해야 하는 문제가 이 문제이다. 원래는 Swift로 작성하려 했지만, 백준의 입력시간 문제 때문에 Swift론 입력 횟수가 적은 O(n²)문제를 풀고 O(nlogn) 문제는 C++로 작성하였다.

기본적인 알고리즘 콘셉트는 다음과 같다.

BOJ 16398. 행성 연결

Sat, 25 Feb 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/16398

풀이

모든 행성을 연결해야 하고, 그 비용을 최소로 하려면 최소 스패닝 트리(MST)를 찾아야 한다.

따라서 알고리즘의 흐름은 다음과 같아진다.

2차원 배열로 입력받은 플로우 관리비용을 정렬한다.
Kruskal 알고리즘을 이용해 최소 스패닝 트리를 구한다.

여기서 에지(플로우 관리비용)의 정보가 2차원 배열로 입력되므로 배열을 순회하여 (노드, 노드, 비용)꼴의 튜플 배열로 만들어 정렬했다.

2차원 배열의 각 인덱스가 노드를 특정하므로 이렇게 하는 것이 최선이라 생각했다.

코드

func find(_ a: Int) -> Int {
 if parent[a] != a {
 parent[a] = find(parent[a])
 }
 return parent[a]
}

func union(_ a: Int, _ b: Int) {
 let pa = find(a)
 let pb = find(b)
 if pa < pb {
 parent[pb] = pa
 } else {
 parent[pa] = pb
 }
}

import Foundation

let n = Int(readLine()!)!
var graph: [[Int]] = []
var edges: [(Int, Int, Int)] = []
var parent = Array(0..<n)
var answer: Int = 0
for _ in 0..<n {
 graph.append(readLine()!.split(separator: " ").map { Int(String($0))! })
}

for row in 0..<n {
 for column in 0..<row {
 edges.append((row, column, graph[row][column]))
 }
}

edges.sort(by: { $0.2 < $1.2 } )

for edge in edges {
 if find(edge.0) != find(edge.1) {
 union(edge.0, edge.1)
 answer += edge.2
 }
}

print(answer)

BOJ 4195. 친구 네트워크

Thu, 23 Feb 2023 00:00:00 +0000

문제

https://www.acmicpc.net/problem/4195

풀이

전형적인 Union-Find 문제이지만, 각 원소들이 정수가 아닌 문자열로 구성되어 있는 특징이 있다. 정수를 문자열로 대응시키는 것은 Dictionary를 쓰면 쉽게 할 수 있으므로 다음과 같은 방식으로 알고리즘이 진행된다

입력값(문자열 2개)에 대해 각 문자열이 Dictionary에 대응되는 Value가 있는지 판단한다.
1에서 없다면 Dictionary에 [String:Integer] 꼴로 매핑한다. 있다면 그냥 넘어간다.
매핑이 끝났다면, 들어온 두 문자열로 union(a, b) 연산을 하고 그 집합 내부의 원소의 개수를 카운트한다.

여기서 문제는 3번이다. 어떻게 해야 효율적으로 집합 내부의 원소를 카운트 할 수 있을까?

BOJ 1726. 로봇

Fri, 18 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1726

풀이

로봇이 바라보는 방향에 따라서 갈 수 있는 노드가 달라진다 -> 3차원 그래프다 (세로 m, 가로 n, 높이가 4인)

이 발상만 빠르게 해낸다면 평범한 BFS 문제가 된다.

하나의 노드에서 최대 5개의 노드와 연결이 가능하다(회전 2방향, 전진 3방향) 하지만 2칸 이상 전진했을때, 앞선 칸이 1이면 넘어가지 못한다. (점프를 할 수 없다)

이것만 주의하고 BFS 탐색을 하면 쉽게 결과를 낼 수 있다.

코드

# east 0 west 1 south 2 north 3
from collections import deque

def bfs(start):
 bfsQ = deque()
 bfsQ.append(start)
 isVisited[start[0]][start[1]][start[2]] = True
 count[start[0]][start[1]][start[2]] = 0

 while(bfsQ):
 node = bfsQ.popleft()
 currentDir = node[2]
 currentCount = count[node[0]][node[1]][node[2]]
 if node == end:
 return currentCount

 for dir in rotate[currentDir]:
 if end == [node[0], node[1], dir]:
 return currentCount + 1
 if isVisited[node[0]][node[1]][dir]:
 continue
 isVisited[node[0]][node[1]][dir] = True
 count[node[0]][node[1]][dir] = currentCount + 1
 bfsQ.append((node[0], node[1], dir))

 if currentDir == 0:
 moves = [(0, 1), (0, 2), (0, 3)]
 elif currentDir == 1:
 moves = [(0, -1), (0, -2), (0, -3)]
 elif currentDir == 2:
 moves = [(1, 0), (2, 0), (3, 0)]
 else:
 moves = [(-1, 0), (-2, 0), (-3, 0)]

 for move in moves:
 row = node[0] + move[0]
 column = node[1] + move[1]
 if end == [row, column, currentDir]:
 return currentCount + 1
 if row < 0 or row >= m or column < 0 or column >= n:
 continue
 if isVisited[row][column][currentDir]:
 continue
 if graph[row][column] == 1:
 break
 isVisited[row][column][currentDir] = True
 count[row][column][currentDir] = currentCount + 1
 bfsQ.append((row, column, currentDir))

graph = []
rotate = {0: [2, 3],
 1: [2, 3],
 2: [0, 1],
 3: [0, 1]}
m, n = map(int, input().split())
for _ in range(m):
 graph.append(list(map(int, input().split())))
start = list(map(int, input().split()))
end = list(map(int, input().split()))

for i in range(3):
 start[i] -= 1
 end[i] -= 1

isVisited = [[[False] * 4 for i in range(n)] for j in range(m)]
count = [[[0] * 4 for i in range(n)] for j in range(m)]
print(bfs(start))

BOJ 3055. 탈출

Thu, 17 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/3055

풀이

입력으로 그래프가 주어지고, 어느 칸에서 BFS를 시작해야하는지 알려준다. 문제를 읽어보면 고슴도치와 물 둘 다 BFS 탐색을 해야 하는 것을 알 수 있다.

주의할 점은 예제에는 초기에 물인 칸이 1개밖에 없지만 문제를 읽어보면 1칸이라는 제약조건이 없다. 따라서 물이 여러칸일 때도 생각하고 프로그래밍을 해야 한다.

처음에 두 가지 생각을 했다.

BFS탐색을 각각 따로 하는 방법
- 고슴도치를 먼저 BFS 탐색시켜서 그래프에 각 칸마다 몇번째 이동에 도달하는지 검사한다.
- 다음에 물을 BFS 탐색해서 1의 결과가 가능한지를 판단한다.
고슴도치와 물을 단계별로 번갈아가면서 BFS 탐색 하는 방법

BOJ 7576. 토마토

Thu, 10 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/7576

풀이

처음엔 무난한 BFS 문제라고 생각했다. 처음부터 익어있는 토마토(루트 토마토라고 하겠다.)가 들어있는 칸을 알아낸 다음에 반복문으로 BFS를 적용하고, 루트 토마토를 할 때마다 만약 칸에 더 적은 숫자가 들어 갈 수 있다면 숫자를 업데이트 하는 식으로 문제를 풀었다.

그랬더니 시간초과가 나온다. 쓸데없는 연산이 너무 많아서 그렇다.

정확한 풀이는 BFS 큐를 처음 만들때부터 모든 루트 토마토를 넣어서 초기화 하는 것이었다. 그러면 모든 루트 토마토를 기준으로 동시에 탐색할 수 있으니까.

칸을 탐색할때도 더 높은 숫자가 나오면 그 칸은 큐에 넣을 필요가 없다. 이미 전에 했던 탐색이 더 좋은 결과를 가져다 주었을태니

BOJ 1697. 숨바꼭질

Mon, 07 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1697

풀이

입력으로 수빈이와 동생의 위치, 그리고 수빈이가 이동할 수 있는 제약조건을 알려준다.

수빈이의 위치보다 동생의 위치가 더 앞에 있거나 같을때는 (n >= k) 뒤로 가는 방법이 한칸 이동하는 것 밖에 없으므로 n - k 로 쉽게 결과를 도출 할 수 있다.

그 외의 경우에는 각각의 좌표를 노드라고 생각했을 때, 이 그래프는 각 노드가 노드값이 1만큼 크거나 작은 노드와 2배인 노드와 연결되어 있다.

따라서 BFS를 이용하면 쉽게 해결 할 수 있다.

BOJ 2331. 반복 수열

Mon, 07 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2331

풀이

수열을 만드는 반복문을 만든다.
도중에 기존에 있는 원소와 같은 원소가 나오면 반복문을 종료한다.
처음으로 나온 같은 원소의 인덱스를 출력한다. (인덱스는 0부터 시작이기에 더하고 뺄 필요가 없다.)

너무 간단하게 풀렸는데 시간복잡도가 별로 좋아보이진 않는다. 더 좋은 방법이 있을듯 싶다.

코드

a, p = map(int, input().split())
seq = [a]

while True:
 element = 0
 for i in str(seq[-1]):
 element += (int(i) ** p)
 if element in seq:
 break
 seq.append(element)

print(seq.index(element))

BOJ 2667. 단지 번호 붙이기

Mon, 07 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2667

풀이

그래프가 입력으로 주어지고, 각 노드마다 탐색의 범위가 상하좌우로 제한된다. 앞서 해결했던 미로 탐색과 순열 사이클을 섞어놓은 듯 한 문제이다.

따라서 다음과 같은 과정으로 출력값을 얻었다.

전체 그래프를 탐색하는 2중 반복문을 작성한다.
방문하지 않은 노드가 나올 때마다 그래프 탐색(DFS, BFS)를 실시한다.
각 그래프를 탐색했을때 노드의 개수를 저장하고 정렬한 다음에 출력한다.

코드

from collections import deque

def bfs(v):
 bfsQ = deque()
 bfsQ.append(v)
 isVisited[v[0]][v[1]] = True
 moves = [(1, 0), (-1, 0), (0, 1), (0, -1)]
 count = 1
 while bfsQ:
 node = bfsQ.popleft()
 for move in moves:
 row = node[0] + move[0]
 column = node[1] + move[1]
 if row < 0 or row >= n or column < 0 or column >= n:
 continue
 if graph[row][column] != 0 and not isVisited[row][column]:
 isVisited[row][column] = True
 bfsQ.append((row, column))
 count += 1
 return count

n = int(input())
graph = []
for _ in range(n):
 temp = input()
 graph.append(list(map(int, temp)))

isVisited = [[False] * n for i in range(n)]
area = []
for row in range(n):
 for column in range(n):
 if graph[row][column] == 1 and not isVisited[row][column]:
 area.append(bfs((row, column)))
area.sort()
print(len(area))
for i in range(len(area)):
 print(area[i])

BOJ 10451. 순열 사이클

Sun, 06 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/10451

풀이

순열이 각각의 (1부터 시작하는)인덱스와 매칭되어있는 그래프를 만들면 쉽게 해결된다. (친절하게 문제에 그림도 있다.)

순열과 인덱스는 내부 원소들이 순서를 제외하고 같으므로 무조건 내부에 사이클을 형성하게 된다.

따라서 문제에서 주어진 그대로 우리는 서로 가르키는 방향을 재귀로 따라가고, 이미 방문한 숫자가 나온다면 재귀를 종료시키기를 반복해서 생기는 사이클의 총 개수를 카운트 하기만 하면 된다.

코드

def dfs(v, start):
 isVisited[v] = True
 if not isVisited[permutation[v - 1]]:
 dfs(permutation[v - 1], start)

n = []
per = []
t = int(input())
for _ in range(t):
 n_temp = int(input())
 per_temp = list(map(int, input().split()))
 n.append(n_temp)
 per.append(per_temp)

for case in range(t):
 count = 0
 isVisited = [False] * (n[case] + 1)
 permutation = per[case]
 for i in range(1, n[case] + 1):
 if not isVisited[i]:
 dfs(i, i)
 count += 1
 print(count)

굳이 재귀를 쓰지 않더라도 반복문만으로도 깔끔한 코드가 나올것 같다.

BOJ 1260. dfs와 bfs

Sun, 06 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/1260

풀이

심플하다. 입력값으로 그래프가 주어지고, DFS와 BFS를 이용해 탐색한 결과를 각각 출력하면 된다.

코드

from collections import deque

def dfs(v, dfsArray):
 isVisitedDFS[v] = True
 dfsArray.append(v)
 for i in range(len(graph[v])):
 if graph[v][i] != 0 and isVisitedDFS[i] == False:
 dfs(i, dfsArray)

def bfs(v, bfsArray):
 QueueBFS = deque()
 isVisitedBFS[v] = True
 QueueBFS.append(v)
 while len(QueueBFS) != 0:
 node = QueueBFS.popleft()
 bfsArray.append(node)
 for i in range(len(graph[node])):
 if graph[node][i] != 0 and not isVisitedBFS[i]
 QueueBFS.append(i)
 isVisitedBFS[i] = True

n, m, v = map(int, input().split())
graph = [[0] * (n + 1) for i in range(n + 1)]
isVisitedDFS = [False for i in range(n + 1)]
isVisitedBFS = [False for i in range(n + 1)]
dfsArray = []
bfsArray = []

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

dfs(v, dfsArray)
bfs(v, bfsArray)

for node in dfsArray:
 print(node, end=" ")
print()
for node in bfsArray:
 print(node, end=" ")
print()

BOJ 2178. 미로 탐색

Sun, 06 Nov 2022 00:00:00 +0000

문제

https://www.acmicpc.net/problem/2178

풀이

입력값으로 미로의 크기와 구성이 주어진다.

미로 안에서는 값이 1인 칸으로만 이동 할 수 있고, 또 각 칸에서는 상하좌우의 칸으로밖에 이동하지 못한다.

-> 현재 칸에서 상하좌우의 칸을 탐색해서 1인 경우에만 Queue에 넣는다.

이 문제에서는 각 노드를 방문했는지의 여부보다 몇번째에 방문했는지의 여부가 더 중요하다.

-> 이전 노드의 방문 순서에 1을 더한 값을 현재 노드의 방문 순서로 한다. (isVisited가 Bool이 아닌 Integer로 구현된다)

이렇게 얻어낸 두가지 인사이트로 BFS를 구현한다.

코드

from collections import deque

def bfs(location):
 visit = [[0] * m for _ in range(n)]
 bfsQ = deque()
 bfsQ.append(location)
 visit[0][0] = 1
 while bfsQ:
 node = bfsQ.popleft()
 up = [node[0] - 1, node[1]]
 down = [node[0] + 1, node[1]]
 left = [node[0], node[1] - 1]
 right = [node[0], node[1] + 1]
 moves = [up, down, left, right]
 for i in range(len(moves)):
 x = moves[i][0]
 y = moves[i][1]
 if x < 0 or y < 0 or x >= n or y >= m:
 continue
 if maze[x][y] == "0":
 continue
 if visit[x][y] == 0:
 visit[x][y] = visit[node[0]][node[1]] + 1
 bfsQ.append([x, y])
 return visit[n - 1][m - 1]

maze = []
n, m = map(int, input().split())
for i in range(n):
 temp = list(input())
 maze.append(temp)
print(bfs([0, 0]))

시작 노드와 종료 노드가 명확하게 정해져 있으므로 DFS로도 풀릴것이라는 생각이 든다.