Saurus2

[LeetCode 솔루션] 49. Group Anagrams 그룹 아나그램

saurus2 — Sat, 11 Nov 2023 08:22:35 +0900

49. Group Anagrams

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example 1:

Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

Example 2:

Input: strs = [""]
Output: [[""]]

Example 3:

Input: strs = ["a"]
Output: [["a"]]

Constraints:

1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] consists of lowercase English letters.

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 49 Group Anagrams 아나그램 그룹 문제를 다루는 스터디입니다.
LeetCode 49 Group Anagrams 아나그램 그룹

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/TlBOILHny9E

[LeetCode] LeetCode 48 Rotate Image, 이미지 회전시키기

saurus2 — Tue, 7 Nov 2023 03:23:35 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 48 Rotate Image, 이미지 회전시키기 문제를 다루는 스터디입니다.
LeetCode 48 Rotate Image, 이미지 회전시키기

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

48. Rotate Imageedium

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Example 1:

Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]

Example 2:

Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

Constraints:

n == matrix.length == matrix[i].length
1 <= n <= 20
-1000 <= matrix[i][j] <= 1000

https://youtu.be/PDng7bZ9v6Y

LeetCode 3 Longest Substring Without Repeating Characters 반복되는 문자열이 없는 가장 긴 부분 문자열

saurus2 — Fri, 3 Nov 2023 09:27:03 +0900

3. Longest Substring Without Repeating Characters

Given a string s, find the length of the longest

without repeating characters.

Example 1:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3:

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

Constraints:

0 <= s.length <= 5 * 104
s consists of English letters, digits, symbols and spaces.

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 3 Longest Substring Without Repeating Characters 반복되는 문자열이 없는 가장 긴 부분 문자열 문제를 다루는 스터디입니다.
LeetCode 3 Longest Substring Without Repeating Characters 반복되는 문자열이 없는 가장 긴 부분 문자열

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/e0H6bxRmiBU

LeetCode 100 Same Tree 같은 트리

saurus2 — Sat, 14 Oct 2023 07:46:55 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 100 Same Tree 같은 트리 문제를 다루는 스터디입니다.
LeetCode 100 Same Tree 같은 트리

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/f1cFqsdlmxg

https://leetcode.com/problems/same-tree/description/

Same Tree - LeetCode

Can you solve this real interview question? Same Tree - Given the roots of two binary trees p and q, write a function to check if they are the same or not. Two binary trees are considered the same if they are structurally identical, and the nodes have the

leetcode.com

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

Example 1:

Input: p = [1,2,3], q = [1,2,3]
Output: true

Example 2:

Input: p = [1,2], q = [1,null,2]
Output: false

Example 3:

Input: p = [1,2,1], q = [1,1,2]
Output: false

Constraints:

The number of nodes in both trees is in the range [0, 100].
-104 <= Node.val <= 104

LeetCode 141 Linked List Cycle 연결리스트 사이클

saurus2 — Sat, 14 Oct 2023 07:45:38 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 141 Linked List Cycle 문제를 다루는 스터디입니다.
LeetCode 141 Linked List Cycle

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/bOu5rqXoli4

https://leetcode.com/problems/linked-list-cycle/description/

Linked List Cycle - LeetCode

Can you solve this real interview question? Linked List Cycle - Given head, the head of a linked list, determine if the linked list has a cycle in it. There is a cycle in a linked list if there is some node in the list that can be reached again by continuo

leetcode.com

Given head, the head of a linked list, determine if the linked list has a cycle in it.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to. Note that pos is not passed as a parameter.

Return true if there is a cycle in the linked list. Otherwise, return false.

Example 1:

Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).

Example 2:

Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.

Example 3:

Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.

Constraints:

The number of the nodes in the list is in the range [0, 104].
-105 <= Node.val <= 105
pos is -1 or a valid index in the linked-list.

Follow up: Can you solve it using O(1) (i.e. constant) memory?

LeetCode 226 Invert Binary Tree 이진트리 뒤바꾸기

saurus2 — Sat, 14 Oct 2023 07:44:23 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 226 Invert Binary Tree 문제를 다루는 스터디입니다.
LeetCode 226 Invert Binary Tree

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/Hh1QFooYziE

https://leetcode.com/problems/invert-binary-tree/description/

Invert Binary Tree - LeetCode

Can you solve this real interview question? Invert Binary Tree - Given the root of a binary tree, invert the tree, and return its root. Example 1: [https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg] Input: root = [4,2,7,1,3,6,9] Output: [4

leetcode.com

Given the root of a binary tree, invert the tree, and return its root.

Example 1:

Input: root = [4,2,7,1,3,6,9]
Output: [4,7,2,9,6,3,1]

Example 2:

Input: root = [2,1,3]
Output: [2,3,1]

Example 3:

Input: root = []
Output: []

Constraints:

The number of nodes in the tree is in the range [0, 100].
-100 <= Node.val <= 100

LeetCode 206 Reverse Linked List 링크드 리스트(연결 리스트) 뒤집기

saurus2 — Sat, 14 Oct 2023 07:42:28 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 206 Reverse Linked List 문제를 다루는 스터디입니다.
LeetCode 206 Reverse Linked List

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/A3kQnKH10VQ

https://leetcode.com/problems/reverse-linked-list/description/

Reverse Linked List - LeetCode

Can you solve this real interview question? Reverse Linked List - Given the head of a singly linked list, reverse the list, and return the reversed list. Example 1: [https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg] Input: head = [1,2,3,4,5] O

leetcode.com

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example 1:

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Example 2:

Input: head = [1,2]
Output: [2,1]

Example 3:

Input: head = []
Output: []

Constraints:

The number of nodes in the list is the range [0, 5000].
-5000 <= Node.val <= 5000

Follow up: A linked list can be reversed either iteratively or recursively. Could you implement both?

LeetCode 70 Climbing Stairs 계단 오르기

saurus2 — Sat, 14 Oct 2023 07:41:11 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 70 Climbing Stairs 문제를 다루는 스터디입니다.
LeetCode 70 Climbing Stairs

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/0enKoHJWeLA

https://leetcode.com/problems/climbing-stairs/description/

Climbing Stairs - LeetCode

Can you solve this real interview question? Climbing Stairs - You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top? Example 1: Input: n = 2 Outpu

leetcode.com

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Example 1:

Input: n = 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2:

Input: n = 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

Constraints:

1 <= n <= 45

LeetCode 1 Two Sum 두개의 합

saurus2 — Sat, 14 Oct 2023 07:39:34 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 1 Two Sum 문제를 다루는 스터디입니다.
LeetCode 1 Two Sum

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/9tPyhQUUJL0

https://leetcode.com/problems/two-sum/description/

Two Sum - LeetCode

Can you solve this real interview question? Two Sum - Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not

leetcode.com

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints:

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?

LeetCode 704 Binary search 이진 탐색

saurus2 — Sat, 14 Oct 2023 07:38:05 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 704 Binary search 문제를 다루는 스터디입니다.
LeetCode 704 Binary search

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/cMWio2e7rlI

https://leetcode.com/problems/binary-search/description/

Binary Search - LeetCode

Can you solve this real interview question? Binary Search - Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

leetcode.com

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

You must write an algorithm with O(log n) runtime complexity.

Example 1:

Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4

Example 2:

Input: nums = [-1,0,3,5,9,12], target = 2
Output: -1
Explanation: 2 does not exist in nums so return -1

Constraints:

1 <= nums.length <= 104
-104 < nums[i], target < 104
All the integers in nums are unique.
nums is sorted in ascending order.

LeetCode 242 valid Anagram 유효한 아나그램

saurus2 — Sat, 14 Oct 2023 07:36:34 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) LeetCode 242 valid Anagram 문제를 다루는 스터디입니다.
LeetCode 242 valid Anagram

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/kXE3SJS9EPI

https://leetcode.com/problems/valid-anagram/description/

Valid Anagram - LeetCode

Can you solve this real interview question? Valid Anagram - Given two strings s and t, return true if t is an anagram of s, and false otherwise. An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using

leetcode.com

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example 1:

Input: s = "anagram", t = "nagaram"
Output: true

Example 2:

Input: s = "rat", t = "car"
Output: false

Constraints:

1 <= s.length, t.length <= 5 * 104
s and t consist of lowercase English letters.

Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

LeetCode 121 Best Time To Buy And Sell Stock 주식을 사고 팔기 가장 좋은시간

saurus2 — Sat, 14 Oct 2023 07:35:05 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) 121번 문제 Best Time To Buy And Sell Stock 1 문제를 다루는 스터디입니다.
LeetCode No 121 Best Time To Buy And Sell Stock 1

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/QTf2P4rcNgw

https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/

Best Time to Buy and Sell Stock - LeetCode

Can you solve this real interview question? Best Time to Buy and Sell Stock - You are given an array prices where prices[i] is the price of a given stock on the ith day. You want to maximize your profit by choosing a single day to buy one stock and choosin

leetcode.com

You are given an array prices where prices[i] is the price of a given stock on the ith day.

You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.

Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.

Example 1:

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.

Example 2:

Input: prices = [7,6,4,3,1]
Output: 0
Explanation: In this case, no transactions are done and the max profit = 0.

Constraints:

1 <= prices.length <= 105
0 <= prices[i] <= 104

LeetCode 21 Merge Two Sorted Lists 릿코드 두개의 정렬된 리스트 병합하기

saurus2 — Sat, 14 Oct 2023 07:33:27 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) 21번 문제 Merge Two Sorted Lists 문제를 다루는 스터디입니다.
LeetCode No 21 Merge Two Sorted Lists

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/MU9iA_SHSpQ

https://leetcode.com/problems/merge-two-sorted-lists/description/

Merge Two Sorted Lists - LeetCode

Can you solve this real interview question? Merge Two Sorted Lists - You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists

leetcode.com

You are given the heads of two sorted linked lists list1 and list2.

Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists.

Return the head of the merged linked list.

Example 1:

Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2:

Input: list1 = [], list2 = []
Output: []

Example 3:

Input: list1 = [], list2 = [0]
Output: [0]

Constraints:

The number of nodes in both lists is in the range [0, 50].
-100 <= Node.val <= 100
Both list1 and list2 are sorted in non-decreasing order.

Leetcode 20 Valid Parentheses 릿코드 20번 Valid Parentheses

saurus2 — Sat, 14 Oct 2023 07:31:44 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) 20번 문제, 유효 괄호들 문제를 다루는 스터디입니다.
LeetCode No 20 Valid Parentheses

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/E5Y4I2zV9bU

https://leetcode.com/problems/valid-parentheses/description/

Valid Parentheses - LeetCode

Can you solve this real interview question? Valid Parentheses - Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. An input string is valid if: 1. Open brackets must be closed by the sam

leetcode.com

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.
Every close bracket has a corresponding open bracket of the same type.

Example 1:

Input: s = "()"
Output: true

Example 2:

Input: s = "()[]{}"
Output: true

Example 3:

Input: s = "(]"
Output: false

Constraints:

1 <= s.length <= 104
s consists of parentheses only '()[]{}'.

LeetCode 217 Contains Duplicate 릿코드 중복 포함

saurus2 — Sat, 14 Oct 2023 07:30:05 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) 217번 문제 Contains Duplicate 문제를 다루는 스터디입니다.
LeetCode No 217 contains duplicate

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://youtu.be/Jtr1YmzYaSc

https://leetcode.com/problems/contains-duplicate/description/

217. Contains Duplicate

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

Example 1:

Input: nums = [1,2,3,1]
Output: true

Example 2:

Input: nums = [1,2,3,4]
Output: false

Example 3:

Input: nums = [1,1,1,3,3,4,3,2,4,2]
Output: true

Constraints:

1 <= nums.length <= 105
-109 <= nums[i] <= 109

LeetCode 125 Valid Palindrome 릿코드 유효 펠린드롬

saurus2 — Sat, 14 Oct 2023 07:27:07 +0900

안녕하세요 코딩세끼 입니다.
개발자가 되고 싶은 구독자들을 위해 코딩 스터디 영상을 제작하고 있습니다.
미국 실리콘 밸리 뿐만아니라 한국에서도 개발자 능력의 필수 요소로 코딩테스트 및 코딩 인터뷰가 요구 되고 있습니다. 영상 구성은 다음과 같습니다.

-영상 구성-
스터디 영상 하나에 리트코드 문제 하나를 각자 풀 수 있도록 영상을 구성하였습니다.
스터디를 진행해보시면서 궁금한 점이나 피드백이 있으면 댓글 부탁드립니다.

이번 영상은 릿코드(리트코드) 125번 문제 유효 팰린드롬 문제를 다루는 스터디입니다.
LeetCode No 125 Valid Palindrome.

-스터디 방식-
1. 동영상을 재생하는 동안 각자 문제를 풀 시간 20분이 주어집니다.
2. 5분마다 힌트를 드립니다.
2-1) 문제 번역
2-2) 문제 접근 방법
2-3) 문제 풀이 힌트
3. 20분이 지나면 문제 풀이를 진행 합니다.
3-1) 한 문제에서 나오는 모든 풀이들을 다루려고 노력하고 있습니다.

현재는 Python으로 해설을 진행하며, 추후 요청에따라 다른 언어로도 영상을 찍도록 하겠습니다.

https://leetcode.com/problems/valid-palindrome/description/

https://youtu.be/Hq5ImKruKGI

125. Valid Palindrome

A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.

Given a string s, return true if it is a palindrome, or false otherwise.

Example 1:

Input: s = "A man, a plan, a canal: Panama"
Output: true
Explanation: "amanaplanacanalpanama" is a palindrome.

Example 2:

Input: s = "race a car"
Output: false
Explanation: "raceacar" is not a palindrome.

Example 3:

Input: s = " "
Output: true
Explanation: s is an empty string "" after removing non-alphanumeric characters.
Since an empty string reads the same forward and backward, it is a palindrome.

Constraints:

1 <= s.length <= 2 * 105
s consists only of printable ASCII characters.

개발자가 되는 방법!! 코딩세끼 릿코드 스터디 지금 시작합니다 [안내영상]

saurus2 — Sat, 14 Oct 2023 07:24:59 +0900

코딩테스트 및 인터뷰, 면접을 준비하기 위한 첫 영상!!!
리트코드 스터디 영상을 시청하시기 전에 꼭 봐야할 가이드 영상입니다.
앞으로 어떻게 스터디를 진행하는지에 대한 설명이 있으니 꼭 시청바랍니다.
좋아요, 구독, 댓글, 알람설정 부탁드려요!

https://youtu.be/wAS-RgtvC44

릿코드가 도대체 뭐야? 개발자가 되고 싶으면 뭐 부터 공부해야하지? 무조건 공부해야하는 코딩 테스트 준비!!

saurus2 — Sat, 14 Oct 2023 07:24:13 +0900

리트코드(릿코드, leetcode) 공부를 처음 시작하는 분들께 필요한 영상입니다.
어떻게 공부를 시작해야하는지 모르시는 분들, 릿코드 웹사이트에 어떤 서비스가
있는지 모르시는 분들을 위해 준비했습니다.

https://youtu.be/SJ1xbxaZhqs

- YouTube

www.youtube.com

[LeetCode] 100 Same Tree [Easy] 같은 트리

saurus2 — Fri, 13 Oct 2023 09:01:23 +0900

100. Same Tree

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

Example 1:

Input: p = [1,2,3], q = [1,2,3]
Output: true

Example 2:

Input: p = [1,2], q = [1,null,2]
Output: false

Example 3:

Input: p = [1,2,1], q = [1,1,2]
Output: false

Constraints:

The number of nodes in both trees is in the range [0, 100].
-104 <= Node.val <= 104

해설 풀이

https://www.youtube.com/watch?v=f1cFqsdlmxg

206 Reverse Linked List [LeetCode]

saurus2 — Tue, 3 Oct 2023 10:35:31 +0900

206 Reverse Linked List

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example 1:

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Example 2:

Input: head = [1,2]
Output: [2,1]

Example 3:

Input: head = []
Output: []

Constraints:

The number of nodes in the list is the range [0, 5000].
-5000 <= Node.val <= 5000

Follow up: A linked list can be reversed either iteratively or recursively. Could you implement both?

해설 풀이 및 스터디

https://www.youtube.com/watch?v=A3kQnKH10VQ

[LeetCode] 280. Wiggle Sort

saurus2 — Tue, 14 Feb 2023 07:20:17 +0900

280. Wiggle Sort

Medium

Given an integer array nums, reorder it such that nums[0] <= nums[1] >= nums[2] <= nums[3]....

You may assume the input array always has a valid answer.

Example 1:

Input: nums = [3,5,2,1,6,4]
Output: [3,5,1,6,2,4]
Explanation: [1,6,2,5,3,4] is also accepted.

Example 2:

Input: nums = [6,6,5,6,3,8]
Output: [6,6,5,6,3,8]

Constraints:

1 <= nums.length <= 5 * 104
0 <= nums[i] <= 104
It is guaranteed that there will be an answer for the given input nums.

Follow up: Could you solve the problem in O(n) time complexity?

문제 풀이

주어진 배열을 지그재그로 정렬해야한다.

첫번째 숫자는 두번째 숫자보다 작거나 같고, 두번째 숫자는 새번째 숫자보다 크거나 같아야한다.

네번째 다섯번째 숫자도 마찬가지로 지그재그로 크기가 달라야한다.

시간복잡도를 정할때 문제 제한을 보면 최대 값이 5 * 10^4 이기 때문에 O(N^2)으로 풀기에는 조금 버거워 보이기도 한다.

정렬 O(NlogN)

숫자 배열을 우선 정렬하고 2칸씩 옮기면서 지금 자리보다 1개 앞인 자리의 숫자를 교환한다.

배열을 정렬했기 때문에 뒤로 갈수록 숫자가 커지는건 보장이 되기 때문에 2개씩 숫자를 교환해주면

그 두자리의 수들은 지그재그 정렬 조건에 맞아 떨어진다.

그리고 그 다음 숫자는 정렬한 배열에서는 앞 숫자들보다 클 수 밖에 없다.

그리디 O(N)

자리 수가 짝수이면서 앞자리가 그 다음자리 숫자보다 큰 경우

자리 수가 홀수이면서 앞자리가 그 다음자리 숫자보다 작은 경우

위 두가지 조건에 두자리 수를 교환한다.

짝수 자리의 경우 뒷자리 숫자가 무조건 크거나 같아야하고, 홀수 자리의 경우 뒷자리 숫자가 무조건 작거나 같아야한다.

이런 조건을 맞춰 숫자를 교환하다보면 숫자가 하나씩 밀리면서 위 조건들을 만족하도록 배열을 바꾸게 된다.

소스 코드

정렬

class Solution:
    def wiggleSort(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        nums.sort()
        for i in range(1, len(nums) - 1, 2):
            nums[i], nums[i + 1] = nums[i + 1], nums[i]

그리디

class Solution:
    def wiggleSort(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        for i in range(len(nums) - 1):
            if i % 2 == 0 and nums[i] > nums[i + 1] \
            or i % 2 == 1 and nums[i] < nums[i + 1]:
                nums[i], nums[i + 1] = nums[i + 1], nums[i]

[LeetCode] 1523. Count Odd Numbers in an Interval Range

saurus2 — Tue, 14 Feb 2023 06:23:33 +0900

1523. Count Odd Numbers in an Interval Range

Given two non-negative integers low and high. Return the count of odd numbers between low and high (inclusive).

Example 1:

Input: low = 3, high = 7
Output: 3
Explanation: The odd numbers between 3 and 7 are [3,5,7].

Example 2:

Input: low = 8, high = 10
Output: 1
Explanation: The odd numbers between 8 and 10 are [9].

Constraints:

0 <= low <= high <= 10^9

문제 풀이

숫자 두개가 주어진다.
두개 숫자들을 포함하여 숫자들 사이에 있는 모든 홀수의 갯수를 구하여라.
문제 풀이 제한을 보면 숫자의 최대값이 10^9이기 때문에 O(1) 시간복잡도로 풀어야한다.
두개의 숫자 사이에 존재하는 숫자들은 짝수 반, 홀수 반이라고 생각할 수 있다.
예를들어 1 부터 5일 경우 홀수는 1, 3, 5 짝수는 2, 4가 있다.
여기서 두가지 경우로 나눌 수 있다.
1 2 3 4 5: low와 high둘 중의 하나라도 홀수가 있는 경우에 홀수가 짝수보다 1개가 많다.
2 3 4 5 6: low와 high둘다 짝수라면 홀수는 두개 짝수는 세개가 된다.
이를 활용하여 문제를 풀 수 있는데, high 에서 low를 빼고 2로 나누면 각각 숫자의 개수가 나온다.
둘다 짝수일때는 홀수가 반이 있다고 가정할 수 있으며, 그게 아니라면 1을 더해줘야한다.

소스 코드

class Solution:
    def countOdds(self, low: int, high: int) -> int:
        ans = (high - low) // 2
        if low % 2 == 0 and high % 2 == 0:
            return ans
        else:
            return ans + 1

[LeetCode] 2477. Minimum Fuel Cost to Report to the Capital

saurus2 — Sun, 12 Feb 2023 16:00:38 +0900

2477. Minimum Fuel Cost to Report to the Capital

Medium

There is a tree (i.e., a connected, undirected graph with no cycles) structure country network consisting of n cities numbered from 0 to n - 1 and exactly n - 1 roads. The capital city is city 0. You are given a 2D integer array roads where roads[i] = [ai, bi] denotes that there exists a bidirectional road connecting cities ai and bi.

There is a meeting for the representatives of each city. The meeting is in the capital city.

There is a car in each city. You are given an integer seats that indicates the number of seats in each car.

A representative can use the car in their city to travel or change the car and ride with another representative. The cost of traveling between two cities is one liter of fuel.

Return the minimum number of liters of fuel to reach the capital city.

Example 1:

Input: roads = [[0,1],[0,2],[0,3]], seats = 5
Output: 3
Explanation: 
- Representative1 goes directly to the capital with 1 liter of fuel.
- Representative2 goes directly to the capital with 1 liter of fuel.
- Representative3 goes directly to the capital with 1 liter of fuel.
It costs 3 liters of fuel at minimum. 
It can be proven that 3 is the minimum number of liters of fuel needed.

Example 2:

Input: roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2
Output: 7
Explanation: 
- Representative2 goes directly to city 3 with 1 liter of fuel.
- Representative2 and representative3 go together to city 1 with 1 liter of fuel.
- Representative2 and representative3 go together to the capital with 1 liter of fuel.
- Representative1 goes directly to the capital with 1 liter of fuel.
- Representative5 goes directly to the capital with 1 liter of fuel.
- Representative6 goes directly to city 4 with 1 liter of fuel.
- Representative4 and representative6 go together to the capital with 1 liter of fuel.
It costs 7 liters of fuel at minimum. 
It can be proven that 7 is the minimum number of liters of fuel needed.

Example 3:

Input: roads = [], seats = 1
Output: 0
Explanation: No representatives need to travel to the capital city.

Constraints:

1 <= n <= 105
roads.length == n - 1
roads[i].length == 2
0 <= ai, bi < n
ai != bi
roads represents a valid tree.
1 <= seats <= 105

문제 풀이

그래프가 하나 주어지며 이 그래프는 0부터 n - 1 까지 주어진다.
그래프의 간선들이 리스트로 주어지고 자동차에 탈 수 있는 총인원의 수가 주어진다.
0이 목적지이며 각각의 숫자에서 자동차를 타고 다른 노드로 이동할때마다 1의 기름값이 사용된다.
여기서 기름값이 최소로 드는 값을 구해야한다.
자동차에 탈 수 있는 총인원의 수는 현재노드에서 다음노드로 이동시에 이전 노드에서 넘어온 사람을 그 숫자만큼 태우고 이동할 수 있다.
즉, 노드가 3개가 연결되어있고 총인원 수가 3이라면 맨 마지막에서 이동 후 한사람을 태우고 그 다음 노드에서 한사람을 태우면 각각 노드에서의 이동 기름값인 1 + 1 + 1만 소비된다.
문제 제한을 보면 10^5이며, N^2의 시간복잡도로는 풀 수 없다.
노드를 각각 한번씩만 들리고 문제를 풀 수 있다면 DFS, BFS도 가능할 것이다.
DFS로 접근해보자, 가장 중요한 포인트는 노드를 이동할때 마다 각 노드에서 출발하는 사람의 수를 중첩하여 더 해주어야한다.
그리고 나머지 연산을 이용하여 0으로 나누어 떨어지지 않으면 한 사람의 값만 추가하여 정답에 더 해야한다.
그 이유는 총 인원보다 적을때 그 그룹은 어쨋거나 한 자동차내에 탑승할 수 있기 때문이다.
마지막 노드까지 탐색한 후에 노드의 개수를 리턴해주며 더해줘야 하며, 정답을 처리할때는 차에 탑승 가능한 총 인원수와 노드에서 나온 중첩된 인원수를 사용한다.
즉 차에 수용가능한 인원수로 현재 중첩된 인원들을 나누어 몫은 바로 노드를 이동하는 소요시간으로 더해질것이다.
그리고 위에서 언급한 나머지 연산을 통해 한 그룹을 추가할지를 정한다.
마지막으로 현재 노드가 0인 노드에 도착하지 않았을때 값들을 정답에 더해줘야한다.
왜냐하면 post order, 즉 후위순회로 노드의 연료 계산이 적용되기 때문에 0에 도착했을 당시의 연료 소비는 없는 것이다.

소스 코드

class Solution:
    def __init__(self):
    	# global answer
        self.ans = 0

    def dfs(self, curr, seats, visited, graph):
    	# initiate person count
        cnt = 1
        for nxt in graph[curr]:
            if nxt not in visited:
                visited.add(curr)
                cnt += self.dfs(nxt, seats, visited, graph)
        # how many cars are from here?
        tmp = cnt // seats
        # over 0 means one more car is necessary
        if cnt % seats != 0:
            tmp += 1
        # Cause post order
        if curr != 0:
            self.ans += tmp
        return cnt
        

    def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
        graph = defaultdict(list)
        visited = set()
        for a, b in roads:
            graph[a].append(b)
            graph[b].append(a)
        self.dfs(0, seats, visited, graph)
        return self.ans

[LeetCode] 567. Permutation in String

saurus2 — Fri, 10 Feb 2023 06:23:53 +0900

567. Permutation in String

Medium

Given two strings s1 and s2, return true if s2 contains a permutation of s1, or false otherwise.

In other words, return true if one of s1's permutations is the substring of s2.

Example 1:

Input: s1 = "ab", s2 = "eidbaooo"
Output: true
Explanation: s2 contains one permutation of s1 ("ba").

Example 2:

Input: s1 = "ab", s2 = "eidboaoo"
Output: false

Constraints:

1 <= s1.length, s2.length <= 104
s1 and s2 consist of lowercase English letters.

문제 풀이

s2문장에서 s1단어가 존재하는지 확인해야한다.
s1단어가 존재할 수 있다고 판단하는 상황은 연속적으로 붙어있으며 그 단어 크기 내의 글자의 순서는 상관없다.
'acbd'에 'abc'가 존재한다. acb와 abc는 같은 크기와 같은 알파벳, 그리고 개수가 만족된다.
'abcd'에 'abd'는 존재하지 않는다. 'abd'로 만들 수 있는 하나의 단어가 'abcd'안에서 만들어질 수 없기 때문이다.

슬라이딩 윈도우

문제의 제한 조건을 보면 10^4이므로 브루투 포스로 풀 수 있다.
시간복잡도를 낮추기 위해 슬라이딩 윈도우를 사용한다.
찾을 단어 s1를 Counter를 이용하여 개수를 미리센다.
s2 문장에서 단어를 하나씩 탐색하면서 s1 단어에 있는 알파벳인지 확인하고 카운터의 갯수를 하나씩 제거한다.
슬라이딩 윈도우이니 만큼 s1의 길이 즉 윈도우가 지나간 자리는 답을 체크할때 제거해줘야하기 때문에 카운터에서 1을 더한다.
매번 슬라이딩 윈도우 프로세스가 끝날때 마다 카운터의 모든 값이 0이면 정답 True를 리턴하고, 탐색을 모두 마친후에도 결과가 나오지 않는다면 False 를 리턴한다.

소스 코드

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
        cntr, w = Counter(s1), len(s1)
        for i in range(len(s2)):
            if s2[i] in cntr:
                cntr[s2[i]] -= 1
            if i >= w and s2[i-w] in cntr:
                cntr[s2[i-w]] += 1
            
            if all([cntr[i] == 0 for i in cntr]):
                return True
        return False

[LeetCode] 6. Zigzag Conversion

saurus2 — Sat, 4 Feb 2023 09:48:02 +0900

6. Zigzag Conversion

Medium

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R

And then read line by line: "PAHNAPLSIIGYIR"

Write the code that will take a string and make this conversion given a number of rows:

string convert(string s, int numRows);

Example 1:

Input: s = "PAYPALISHIRING", numRows = 3
Output: "PAHNAPLSIIGYIR"

Example 2:

Input: s = "PAYPALISHIRING", numRows = 4
Output: "PINALSIGYAHRPI"
Explanation:
P     I    N
A   L S  I G
Y A   H R
P     I

Example 3:

Input: s = "A", numRows = 1
Output: "A"

Constraints:

1 <= s.length <= 1000
s consists of English letters (lower-case and upper-case), ',' and '.'.
1 <= numRows <= 1000

문제 풀이

문장 한개와 행의 갯수가 주어진다.
문장에서 순서대로 row갯수에 맞에 글자가 저장된다.

그리고 다음 행의 숫자로 넘어갈 때는 거꾸로 저장이된다.
예를 들어 PAYPALISHIRING, numRows가 3이면,
- 0: P
  1: A
  2: Y
위와 같이 한 행씩 문자가 들어간다.
그리고 행의 갯수만큼 글자를 배정하면 행의 숫자를 거꾸로 돌아가면서 문자를 행에 넣는다.
첫번째 행과 마지막 행은 배제해야한다.

예를 들면
- 0: P
  1: A
  2: Y
PAY 다음에는 P를 넣어야하는데 이미 2까지 문자를 배정했으니, 거꾸로 1에 저장해야한다.
- 0: P
  1: A P
  2: Y
위의 과정 다음에는 행의 번호가 시작점으로 간다.
- 0: P A
  1: A P
  2: Y
A가 첫번째 행에 저장되고 나머지 과정은 위에서 예를 든 설명과 같이 반복된다.

문제 제한을 살펴보면, 문장의 최대길이가 1000이기 때문에 브루트 포스로 문제를 풀어도 된다.
투포인터 식으로 문제를 푼다면, 기존의 인덱스 idx와 행의 번호를 조작할때 사용할 d를 선언한다.
인덱스를 늘리거나 줄이면서 해당 리스트에 문자를 넣자.
행의 번호를 조작할때 1을 더하거나 1을 빼어 행의 번호를 바꿔야한다.
맨마지막 행번호에 다다랐을때는 d를 -1로 바꿔주고 맨처음 인덱스에 다다랐을때는 1로 바꿔준다.
d 값을 계속해서 idx값에 더해주는 식으로 문제를 푼다.
if 문에서 첫번째 행의 번호와 마지막 행의 번호가 먼저 처리되고 문자를 답 리스트 문자열에 넣기 때문에 문제 없이 진행된다.

소스 코드

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows == 1:
            return s
        ans = ['' for _ in range(numRows)]
        idx, d = 0, 1
        for i in range(len(s)):
            ans[idx] += s[i]
            if idx == numRows - 1:
                d = -1
            elif idx == 0:
                d = 1
            idx += d
        return ''.join(ans)

AJAX로 3초마다 JSON파일 데이터 읽어 html 웹 페이지에 업데이트하는 방법

saurus2 — Wed, 25 Jan 2023 15:23:44 +0900

웹페이지를 만들고 새로운 데이터를 아무런 변화없이 업데이트하기 위한 방법이다.

비동기적으로 html 구성요소를 바꾸거나 업데이트하는 등의 동작을 할 수 있다.

AJAX를 이용하여 웹페이지의 새로고침 없이 데이터를 업데이트 할 수 있다.

설정해놓은 시간대로 함수를 호출하여 자바스크립트를 실행할 수 있는 함수는 setInterval() 함수이다.

// 1000 msec 마이크로세컨드, 1초마다 setInterval 안의 함수를 자동 호출할 수 있다. 
setInterval(function () {element.innerHTML += "Hello"}, 1000);

Ajax 를 사용하여 로컬의 json 파일을 불러오려고 한다.

url 에는 파일이 위치하고 있는곳을 적어준다.

원하는 파일 혹은 주소가 제대로 로딩되었다면 success 부분에서 javascript 코드들을 실행한다.

로딩에 실패했다면 error 부분에 있는 코드가 동작한다.

setInterval

<script type="text/javascript">
	$(function () {
    	timer = setInterval(function () {
            $.ajax({
            	// 파일의 위치, 이름
                url: "data.json",
                type: 'get',
                datatype: "json",
                // after loading data
                success: function( json ) {
                    alert('success');
                },
                error: function() {
                    alert('error');
                }
            });
        }, 3000);
    });
</script>

clearInterval

타이머를 해제하는 함수는 clearInterval 을 사용하여 함수로 사용했던 timer 를 정지할 수 있다.

<script type="text/javascript">
	// stop은 html 페이지의 버튼으로 사용하려고 넣었다. 
    $('#stop').click(function() {
            clearInterval(timer);
    });
</script>

전체 코드를 보면, body 안에 있는 info 라는 div 안에 json 파일의 데이터들을 모두 불러 1초마다 갱신한다.

소스 코드는 다음과 같다.

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JSON Read</title>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
</head>
<body>
    <p id="demo"></p>
    <br>
    <div id="info"></div>
    <button type="button" id='start'>start</button>
    <button type="button" id='stop'>stop</button>

    <script type="text/javascript">
        var timer;
        $('#start').click(function () {
            timer = setInterval(function () {
                $.ajax({
                    url: "data.json",
                    type: 'get',
                    datatype: "json",
                    // after loading data
                    success: function( json ) {
                        var user_info = "";
                        for(var i = 0; i < json.length; i++){
                            user_info += "<tr><td>" + (i + 1) + "</td><td>" + json[i].name + "</td><td>" + json[i].age + "</td><td>" + json[i].address +"</td><td>" + json[i].phone + "</td></tr>";
                        }
                        $('#info').html(user_info);
                    },
                    error: function() {
                        alert('error');
                    }
                });
            }, 3000);
        });
        $('#stop').click(function() {
            clearInterval(timer);
        });
    </script>
</body>
</html>

start 버튼을 누르면 3초마다 json 파일을 불러 데이터를 테이블에 뿌려준다.

만일 정상동작하는지 확인하고 싶다면 json 파일의 데이터를 바꾸고 저장하면 실시간으로 바뀌는 것을 볼 수 있다.

그리고 동작을 멈추고 싶다면 stop 버튼을 누르면 타이머가 해제된다.

data.json

[
  {
    "name": "abc",
    "age": 1,
    "address": "seoul",
    "phone": "123"
  }
]

json 파일은 소스코드와 같은 폴더안에 들어가 있으면 정상 동작한다.

[LeetCode] 1299. Replace Elements with Greatest Element on Right Side

saurus2 — Fri, 13 Jan 2023 16:09:57 +0900

1299. Replace Elements with Greatest Element on Right Side

Easy

Given an array arr, replace every element in that array with the greatest element among the elements to its right, and replace the last element with -1.

After doing so, return the array.

Example 1:

Input: arr = [17,18,5,4,6,1]
Output: [18,6,6,6,1,-1]
Explanation: 
- index 0 --> the greatest element to the right of index 0 is index 1 (18).
- index 1 --> the greatest element to the right of index 1 is index 4 (6).
- index 2 --> the greatest element to the right of index 2 is index 4 (6).
- index 3 --> the greatest element to the right of index 3 is index 4 (6).
- index 4 --> the greatest element to the right of index 4 is index 5 (1).
- index 5 --> there are no elements to the right of index 5, so we put -1.

Example 2:

Input: arr = [400]
Output: [-1]
Explanation: There are no elements to the right of index 0.

Constraints:

1 <= arr.length <= 104
1 <= arr[i] <= 105

문제 풀이

주어진 숫자 배열에서 현재 인덱스보다 오른쪽에 있는 값들 중에 최대값을 저장하는 문제이다.

맨 마지막 숫자는 무조건 -1을 답으로 넣어야한다.

Max: Time Limitation Error

현재 위치 외의 오른쪽 숫자들 중에 최대값을 찾아야한다.
만약 왼쪽에서 부터 답을 찾아가는 방법으로도 답을 구할 수 있지만, 현재 위치를 제외하고 매번 (N - i - 1)만큼의 탐색을 해야한다.
i + 1 ~ N까지의 숫자들 중에 하나의 가장 큰 숫자를 구해야하기 때문이다.
즉 최종 시간복잡도는 O(N!)이 되기 때문에 문제 제한사항인 N^4에도 맞게 풀릴 수 가 없다.
결국 시간초과 에러가 발생한다.

Swap & max

이를 간단하게 풀기 위해서는 하나의 방법을 사용한다.
현재 위치에서 오른쪽의 모든 숫자들을 확인해야한다.
하지만 반대로 생각하면 오른쪽 부터 큰 숫자를 찾아 진행하면 매번 현재 위치 오른쪽의 모든 값을 비교할 필요가 없다.
다시말해 맨 오른쪽의 값이 현재의 최대값이라고 정하고 왼쪽으로 옮기면서 숫자를 비교해본다면 오른쪽 끝자리부터 최대값은 항상 보장이 된다.
예를 들어, 1, 2, 3이 있다면 맨 마지막 숫자를 최대값으로 정하고 index 2 위치에 저장한다.
그리고 index 1로 갔을때 최대값으로 저장되어 있는 숫자는 오른쪽에서 왼쪽으로 한 자리씩 거쳐오면서 저장되는 최대값이다.
즉 index 1에서 얻는 최대값은 3이며, index 0으로 이동했을때도 최대값은 3이다.
그리고 마지막 값에 -1를 넣어주기 위해서 처음 최대값 변수의 값은 -1로 정한다.
맨 오른쪽 값부터 최대값을 갱신하면서 왼쪽으로 이동한다.
이때 최대값을 구하기 전에 temp에 넣어놨던 값을 arr 배열 현재 위치에 넣고 temp에는 현재 위치와 temp중에 최대값을 넣는다.
즉 현재 위치와 지금까지 최대값이였던 임시 변수와 크기 비교를 하여 temp에 넣고 이전에 가지고 있던 temp 즉 오른쪽의 최대값은 배열 현재 위치에 넣어준다.
다시말해 오른쪽에서 시작해서 이전 최대값은 temp 변수에 저장해놓았다가 매번 갱신하기전에 이전 최대값을 현재 위치에 저장해야 한다.

Sort

배열의 값과 인덱스를 튜플로 묶어 역순으로 정렬하는데 내림차순으로 정렬하는 거라고 봐도 무방한다.
인덱스를 같이 저장하여 정렬하면서, 최대값을 비교할때 그 최대값이 현재 인덱스보다 크다면 정답으로 가질 수 있도록 하였다.
즉 포인터를 두개 이용하여 값과 인덱스가 내림차순으로 정렬되어있는 배열을 탐색한다.
하나의 포인터는 항상 현재 위치를 나타내고, 두번째 포인터는 최대값부터 작은 값을 향해 나아간다.
현재 위치에서 그 인덱스를 이용하여 내림차순으로 정렬되어있는 값을 확인한다.
내림차순으로 정렬되어있기 때문에 오른쪽으로 갈수록 작아진다.
확인하는 방법은 단순히 인덱스만 비교하면서 포인터를 정렬된 배열 끝까지 while문으로 탐색한다.
숫자가 점점 작아지면서 현재 인덱스보다 크면 이동을 멈춘다.
이는 현재 위치보다 큰 인덱스일 경우 가장 큰 값을 찾는 논리이다.
즉 정렬된 배열안에서 항상 맨 왼쪽에 있는 숫자들은 크다는 것이 보장되어있고 현재 인덱스가 저장되어있는 인덱스보다 작다는 것은 그 숫자는 현재 위치의 오른쪽에서 가장 큰 값을 나타낸다.
그리고 정답 배열 마지막에 -1를 넣어준다.

소스 코드

Max: Time Limitation Error

class Solution:
    def replaceElements(self, arr: List[int]) -> List[int]:
        # max O(n!) TLE
        ans = [0] * len(arr)
        for i in range(len(arr) - 1):
            ans[i] = max(arr[i+1:])
        ans[-1] = -1
        return ans

Swap & max

class Solution:
    def replaceElements(self, arr: List[int]) -> List[int]:
    # swap & max O(N)
        temp = -1
        for i in range(len(arr) - 1, -1, -1):
            arr[i], temp = temp, max(temp, arr[i])
        return arr

Sort

class Solution:
    def replaceElements(self, arr: List[int]) -> List[int]:
        # sort O(nLogn)
        arr = [(num, i) for i, num in enumerate(arr)]
        arr = sorted(arr, reverse=True)
        ans = [0] * len(arr)
        pointer = 0
        for i in range(len(arr) - 1):
            while pointer < len(arr) - 1 and i >= arr[pointer][1]:
                pointer += 1
            ans[i] = arr[pointer][0]
        ans[-1] = -1
        return ans

[LeetCode] 13. Roman to Integer

saurus2 — Fri, 13 Jan 2023 15:03:26 +0900

13. Roman to Integer

Easy

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, 2 is written as II in Roman numeral, just two ones added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

I can be placed before V (5) and X (10) to make 4 and 9.
X can be placed before L (50) and C (100) to make 40 and 90.
C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer.

Example 1:

Input: s = "III"
Output: 3
Explanation: III = 3.

Example 2:

Input: s = "LVIII"
Output: 58
Explanation: L = 50, V= 5, III = 3.

Example 3:

Input: s = "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Constraints:

1 <= s.length <= 15
s contains only the characters ('I', 'V', 'X', 'L', 'C', 'D', 'M').
It is guaranteed that s is a valid roman numeral in the range [1, 3999].

문제 풀이

심볼과 숫자가 주어진다.
심볼로 이루어진 문장을 숫자로 만들어야한다.
각각의 심볼은 숫자와 짝을 이루고 있으며, 심볼에 맞게 숫자를 더해주면 된다.
문제에서 추가적으로 2글자의 심볼도 숫자로 지정하고 있다.
앞에 온 심볼이 다음 심볼보다 작은 숫자를 가지면 그것을 처리해줘도 되지만, 딕셔너리에 두글자 심볼도 모두 저장하여 풀수있다.
시간복잡도는 마찬가지로 O(N)이 걸린다.
2개씩 문자를 모두 확인한다고 해도 O(2N)이 걸리기 때문에 속도면에서 조금차이날 뿐이지만 그렇게 큰차이는 아니다.
for문을 사용하지 않는데, 이유는 인덱스를 옮기면서 값을 확인해야하기 때문이다.
0부터 인덱스를 탐색할때 s[i:i+2]로 지금 위치에서 2자리 단어를 확인한다.
만약 그 단어가 해쉬 테이블에 있다면 그 key에 해당하는 value를 답에 더해준다.
그리고 인덱스를 2칸 옮긴다.
두자리 단어가 없다면 해당 위치의 한 글자에 해당하는 value를 찾아 더해준다.
한 글자에 해당하는 값을 찾았을때는 인덱스를 1증가 시킨다.
인덱스가 문장의 갯수보다 작을때까지만 포인터를 옮기면서 탐색하고 정답을 구한다.

소스 코드

class Solution:
    def romanToInt(self, s: str) -> int:
        hash_table = {
            'I':1,
            'V':5,
            'X':10,
            'L':50,
            'C':100,
            'D':500,
            'M':1000,
            'IV':4,
            'IX':9,
            'XL':40,
            'XC':90,
            'CD':400,
            'CM':900
        }
        ans = 0
        i = 0
        while i < len(s):
            if s[i:i+2] in hash_table:
                ans += hash_table[s[i:i+2]]
                i += 2
            else:
                ans += hash_table[s[i]]
                i += 1
        return ans

[LeetCode] 504. Base 7

saurus2 — Thu, 12 Jan 2023 16:19:33 +0900

504. Base 7

Easy

Given an integer num, return a string of its base 7 representation.

Example 1:

Input: num = 100
Output: "202"

Example 2:

Input: num = -7
Output: "-10"

Constraints:

-107 <= num <= 107

문제 풀이

주어진 숫자를 이진수처럼 칠진수로 만들어 문자열로 리턴하는 문제이다.
10진수를 2진수로 변경하는 것처럼 몫과 나머지를 사용하여 문제를 풀 수 있다.
문제 제한은 최악의 경우 10^7이지만 for loop를 하나만 사용하면 되니 O(N)시간안에 풀 수 있다.
여기서 두가지 예외처리가 필요하다.
0이 나올경우 간단하게 '0'을 리턴하고, 음수가 등장했을때 플래그 변수를 만들어 저장하여 나중에 음수로 처리한다.
이러한 수학계산을 하기위해서는 기준이되는 숫자로 계속해서 주어진 숫자를 나누면서 계산한다.
0 ~ 6까지의 숫자를 사용할 수 있는데, 7은 0이라고 생각하면 된다.
처음 숫자를 7로 나눈 숫자의 나머지를 정답 끝에 넣는다.
그리고 몫을 다시 7로 나누어 반복하는 방법으로 문제를 푼다.
쉽게 10진수를 2진수로 만드는 예로 설명해보면, 10을 2진수로 만들어보자.
10은 2진수 1010 이다. 숫자위치는 순서대로 8421의 의미를 가지고 있다.
10을 2로 나누면 0으로 나누어 떨어지기 때문에 0을 맨 뒷자리에 넣는다.
10을 2로 나눈 5를 2로 나누면 1이 남기 때문에 1을 0 앞에 넣어 10을 만든다.
5를 2로 나눈 2를 2로 나누면 0이 남아서 10 앞에 0을 넣어 010을 만든다.
2를 2로 나눈 1을 2로 나누면 1이 남아서 010 앞에 1을 넣어 1010을 만든다.
7진수도 위처럼 계산하여 정답을 만들면 된다.

소스 코드

class Solution:
    def convertToBase7(self, num: int) -> str:
        # if num is zero, return '0'
        if num == 0: 
            return '0'
        # handle with negative number
        flag = 1
        ans = ''
        if num < 0:
            num *= -1
            flag = 0
        while num:
            # divide, modular
            divided = num // 7
            modular = num % 7
            ans += str(modular)
            num = divided
        # reverse string
        ans = ans[::-1]
        return str(ans) if flag else str('-') + str(ans)

[LeetCode] 326. Power of Three

saurus2 — Tue, 10 Jan 2023 23:57:32 +0900

326. Power of Three

Easy

Given an integer n, return true if it is a power of three. Otherwise, return false.

An integer n is a power of three, if there exists an integer x such that n == 3x.

Example 1:

Input: n = 27
Output: true
Explanation: 27 = 33

Example 2:

Input: n = 0
Output: false
Explanation: There is no x where 3x = 0.

Example 3:

Input: n = -1
Output: false
Explanation: There is no x where 3x = (-1).

Constraints:

-231 <= n <= 231 - 1

Follow up: Could you solve it without loops/recursion?

문제 풀이

주어진 숫자 n이 3의 제곱승의 값과 같은지 구별하는 문제이다.
n의 최대값은 2^31 - 1이고 최소값은 -2^31 이다.
문제 제한사항이 뜻하는 것은 n은 정수 범위를 넘지 않는 것이다.
하지만 음수들은 3의 제곱승이 될 수 없다.
다른 제한이 없기 때문에 숫자를 각각 직접 제곱승하면서 답을 확인하는 방법과 modular(나머지 계산)을 사용해서 풀 수 있다.

Loop

우선 임시 값으로 1을 지정한다.
그리고 while 반복문으로 임시 값이 n보다 클때까지 진행한다.
while 문 조건인 step <= n은 종료조건을 반대로 생각하면 편리하다.
즉 step <= n이 참일때는 while문은 종료가 되지않기 때문에 step > n일때 종료가 된다.
while의 다른 종료조건으로써 제곱승이 되는 step 값이 우리가 구하려는 N값과 같을때 True 를 리턴한다.
그리고 while 문이 끝나고 False를 리턴한다.
while문이 종료됬다는 것은 제곱승이 진행되면서 이미 목표 숫자를 넘어서 종료되었으며 제곱승이 될 수 없음을 의미한다.

Recursion(재귀함수)

재귀함수를 알아보자.
재귀함수는 자기 자신인 함수를 호출하여 메모리내에 스택을 쌓아나간다고 생각하는 것이 편하다.
쉽게 이해할 수 있는방법은 함수를 방이라고 생각하고 방을 열고 들어갔을때 똑같은 새로운 방이 생겨서 그방으로 이동하는 개념이라고 볼 수 있다.
그리고 이전 방으로 나가는 문을 만들어주지 않으면 계속해서 똑같은 새방을 생성하여 지구 끝까지 들어간다고 생각하자.
이전 방으로 나가는 문을 만드는 것을 종료조건(기저조건)을 만드는 것이며 이는 if문으로 생성하여 return을 해주면된다.
rec 함수안에 rec 함수를 또 호출하는 것이 재귀함수의 모양이다.
매개변수로는 제곱승을 할 n과 그 값이 주어진 n값과 같은지 확인하는 goal 이있다.
우선 재귀함수를 생성할때 가장중요한 종료조건들과 어떻게 재귀함수 내의 코드들을 작성해야한다.
종료조건을 생성하기 전에, 3의 제곱승들을 구하기 위해 재귀호출을 할때 3을 곱해서 넘겨준다.
이 코드는 지금 현재의 방에서 1을 들고 들어왔다면 재귀함수 호출시 같은 새로운방에 1 * 3으로 3을 들고 들어간다.
다음 과정도 마찬가지로 3을 들고 들어왔고 3 * 3 으로 3^2 인 9를 들고 들어간다.
매번 깊은 방으로 들어갈때마다 3으로 제곱승이 된 값을 가지고 들어간다.
여기까지 만들고 실행시킨다면 스택 오버플로우(메모리 초과 에러)가 발생한다.
재귀 호출을 멈출 수 있는 이전에 생성되었던 방으로 이동하는 출구 문(종료 조건)을 만들지 않았기 때문이다.
재귀함수 호출이 끝나도록 종료조건들을 만든다.
3을 곱하면서 다음 같은 새방으로 들어갈 것인데, 만일 제곱승이되어 들어간 숫자가 문제에서 주어진 목표보다 컸을때 False라는 값을 리턴하는 종료조건을 만든다.
그리고 답을 구하기 위해 제곱승이 되어 들고 들어가는 매개변수가 목표와 같아지면 True를 리턴하는 조건문을 만든다.
이렇게 되면 같은 새로운 방을 더 만들지 않고 이전 방으로 돌아간다.
한번만 리턴이 된다고 하더라도 함수내의 코드가 모두 끝나게되면 방은 자동으로 파괴된다.
하지만 문제에서 True, False를 알고 싶기 때문에, 재귀 호출함과 동시에 리턴을 적어준다.
이 리턴의 역할은 최종 종료조건 까지 같은 새로운 방을 만들어 깊이 들어가다가 종료가 된다면 True, False 중에 리턴을 하면서 이전방으로 들어가고 재귀 호출은 더 이상 진행되지 않는다.
그렇다면 재귀호출이 끝난 시점에서 이전 방의 위치는 호출이 끝난 위치이다.
물론 리턴을 하지 않아도 돌아와서 문을 닫는 순간 이방은 파괴가 되며, 파괴된 후 거쳐온 방들은 순차적으로 파괴된다.
하지만 종료시점에 리턴으로 전달받은 False, True는 return이 있기 때문에 파괴되기전 결과값을 가지고 전 방으로 탈출한다.
그럼 결과적으로 목표 숫자보다 커졌을때까지 가서 숫자를 확인하고 리턴해서 이전 방들을 다시 거쳐 돌아오거나 목표 숫자까지 도달하여 True를 가지고 이전 방들을 다시 거쳐 돌아올 수 있게 된다.

Math

음수는 제곱승이 될수 없기 때문에 제외해야 한다.
정수 이기 때문에 3의 제곱승 중 정수 최대값보다 작은 값을 사용한다.
그 값은 3^19이며 n이 이 값을 나눴을때 0이라면 True가 되는 간단한 수학식이다.
즉 3^19 % 3^X == 0이면 True 아니면 False가 된다.

소스 코드

Loop

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        # loop
        step = 1
        while step <= n:
            if step == n:
                return True
            step *= 3
        return False

Recursion

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        # Recursion
        def rec(n, goal):
            if n > goal:
                return False
            if n == goal:
                return True
            return rec(n * 3, goal)
        return rec(1, n)

Math

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        # math
        return n > 0 and 1162261467 % n == 0

[LeetCode] 242. Valid Anagram

saurus2 — Tue, 10 Jan 2023 23:06:52 +0900

242. Valid Anagram

Easy

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example 1:

Input: s = "anagram", t = "nagaram"
Output: true

Example 2:

Input: s = "rat", t = "car"
Output: false

Constraints:

1 <= s.length, t.length <= 5 * 104
s and t consist of lowercase English letters.

Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

문제 풀이

아나그램이란 단어의 알파벳을 재배치 했을때 같은 알파벳, 그리고 개수가 맞을때를 의미한다.
두개의 문자열이 주어지고 문자열들이 아나그램이면 True를 리턴, 아니면 False를 리턴한다.
결과적으로 알파벳의 순서는 상관없으며 각각 알파벳의 갯수들이 같은지를 알아보면 된다.
문제 제한을 보면 5 * 10^4 인데 브루트 포스로 풀면 아슬아슬 하게 통과할 것 같다.

Sorting

알파벳들의 개수를 확인하기 위해서는 직접 알파벳의 개수를 세거나 해야한다.
하지만 정렬을 이용하면 아나그램들은 같은 문자열이 되어버린다.
알파벳 각각의 개수들이 같다면 정렬을 했을때 같은 모양이 나온다.
파이썬의 정렬은 기본적으로 O(NlogN)의 시간복잡도가 걸린다.
두가지 문자열을 정렬하고 리턴을 두개의 문자열 비교 결과로 정해준다.

Hash Table (Counter)

해쉬 테이블을 사용할때 알파벳들의 개수를 각각 세어 저장해주고 그 해쉬테이블을 비교하는 방식으로 풀 수 있다.
하지만 파이썬에는 Counter 라이브러리가 있는데 이는 자동으로 각 데이터의 개수를 자동으로 세어 딕셔너리에 저장해준다.
Counter는 알파벳을 하나하나 확인하면서 알파벳을 키로 개수를 값으로 저장한다.
만약 for 문으로 푼다면 아스키코드 혹은 알파벳을 키로 저장하여 하나씩 1을 더해준다.
정렬 풀이방법 처럼 딕셔너리를 비교한 결과 값을 리턴 값으로 내보내면 된다.

소스 코드

Sorting

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        # sorting
        s1 = sorted(list(s))
        s2 = sorted(list(t))
        return s1 == s2

Hash Table (Counter)

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        # hash table
        hash_table1 = Counter(s)
        hash_table2 = Counter(t)
        return hash_table1 == hash_table2

[LeetCode] 20. Valid Parentheses

saurus2 — Fri, 6 Jan 2023 17:16:59 +0900

20. Valid Parentheses

Easy

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.
Every close bracket has a corresponding open bracket of the same type.

Example 1:

Input: s = "()"
Output: true

Example 2:

Input: s = "()[]{}"
Output: true

Example 3:

Input: s = "(]"
Output: false

Constraints:

1 <= s.length <= 104
s consists of parentheses only '()[]{}'.

문제 풀이

괄호의 짝을 찾는 문제이다.

만일 주어진 문장의 괄호들이 올바른 짝들에 맞게 구성이 되어있다면 True 아니면 False로 답을 리턴해야한다.

문제를 풀기전에 제한사항을 확인해보면 10^4 이기 때문에 브루투포스로 풀어도 된다.

하지만 이 문제는 대표적인 Stack 문제이며, 모든 것을 조건으로 짜기에는 코드가 많이 복잡해진다.

그리고 문제에서 조심해야할 것은 예외처리를 어떻게 해야할지 생각해봐야한다.

예를들어, '([)]', '({}[(]))' 이런 예제들을 예외로 생각해서 고민해봐야한다.

눈으로 보기에는 같은 괄호로 닫힐것 같이 생겼다.

하지만 'Open brackets must be closed in the correct order.' 문구를 보면 올바른 순서로 닫혀야된다.

이는 괄호가 열리고 중간에 짝이 없는 열린 괄호가 있으면 안된다.

닫히는 괄호가 한짝의 괄호안에 들어가야하는 것이라고 볼 수 있다.

다시 풀이방법으로 돌아가서, 괄호를 열고 닫는것을 확인할때 O(N)으로 풀려면 Stack을 사용해야한다.

스택에 괄호를 하나씩 모두 넣으면서 확인하되 닫힌 괄호가 나타났을때 스택에 그 짝의 열린괄호가 있는지 확인한다.

조건문으로 괄호 짝들을 구별하지 않고 딕셔너리 즉 해쉬테이블로 닫는 괄호들을 키로 열린 괄호들을 벨류로 지정한다.

for 문으로 문장을 한글자씩 탐색하면서 만약에 스택이 차있고 괄호가 닫은 괄호이면 닫힌 괄호들을 저장한 딕셔너리에 있는지 확인한다.

만일 닫힌괄호의 짝이 스택 맨앞에 있다면 스택에서 제거하고 코드를 뛰어넘는다.

만일 열린괄호거나 스택이 비어있으면 괄호를 넣는다.

이 과정을 거치면, 모든 괄호들이 닫혔을 경우 스택이 비게 된다.

결과적으로 스택이 비어있으면 문제에서 원하는 정답이며, 스택이 안비어있으면 정답이 아니게 된다.

코드를 쉽게 짜기위해서 딕셔너리와, continue를 사용하였다.

소스 코드

class Solution:
    def isValid(self, s: str) -> bool:
        parentheses = {
            ')' : '(',
            ']' : '[',
            '}' : '{'
        }
        stack = []
        for ch in s:
            if stack and ch in parentheses:
                if stack[-1] == parentheses[ch]:
                    stack.pop()
                    continue
            stack.append(ch)
        if stack:
            return False
        return True

[LeetCode] 1056. Confusing Number

saurus2 — Mon, 2 Jan 2023 17:20:54 +0900

1056. Confusing Number

Easy

A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.

We can rotate digits of a number by 180 degrees to form new digits.

When 0, 1, 6, 8, and 9 are rotated 180 degrees, they become 0, 1, 9, 8, and 6 respectively.
When 2, 3, 4, 5, and 7 are rotated 180 degrees, they become invalid.

Note that after rotating a number, we can ignore leading zeros.

For example, after rotating 8000, we have 0008 which is considered as just 8.

Given an integer n, return true if it is a confusing number, or false otherwise.

Example 1:

Input: n = 6
Output: true
Explanation: We get 9 after rotating 6, 9 is a valid number, and 9 != 6.

Example 2:

Input: n = 89
Output: true
Explanation: We get 68 after rotating 89, 68 is a valid number and 68 != 89.

Example 3:

Input: n = 11
Output: false
Explanation: We get 11 after rotating 11, 11 is a valid number but the value remains the same, thus 11 is not a confusing number

Constraints:

0 <= n <= 109

문제 풀이

정수 숫자가 주어지고 이 숫자들을 180도 뒤집어야한다.

0, 1, 6, 8, 9 들은 뒤집으면 유효한 숫자로 바꿀수 있다.

하지만 다른 2, 3, 4, 5, 7은 유효하지 않은 숫자로 바뀐다.

숫자를 180도 뒤집었을때 유효한 숫자이면서 주어진 숫자랑 다르면 True이고 아니면 False를 리턴한다.

딕셔너리에 키와 벨류로 뒤집어질 숫자를 미리 하드코딩한다.

n을 변경하면서 while을 진행하기 때문에 임시로 정답을 저장한다.

먼저 정답 숫자에 10을 곱한다.

주어진 숫자 n을 10으로 나머지를 구하고 그 숫자가 딕셔너리에 숫자가 있다면 정답 숫자에 더해준다.

그리고 n을 10으로 나누고 이 과정을 반복하여 n이 0이 될까지 반복한다.

계산한 값과 임시 정답을 비교하여 반환한다.

소스코드

class Solution:
    def confusingNumber(self, n: int) -> bool:
        rotated_dict = {
            0:0,
            1:1,
            6:9,
            8:8,
            9:6
        }
        ans = 0
        temp_n = n
        while n:
            temp = n % 10
            if temp in rotated_dict:
                ans *= 10
                ans += rotated_dict[temp]
            else:
                return False
            n //= 10
        return ans != temp_n

[LeetCode] 412. Fizz Buzz

saurus2 — Fri, 30 Dec 2022 14:55:16 +0900

412. Fizz Buzz

Easy

Given an integer n, return a string array answer (1-indexed) where:

answer[i] == "FizzBuzz" if i is divisible by 3 and 5.
answer[i] == "Fizz" if i is divisible by 3.
answer[i] == "Buzz" if i is divisible by 5.
answer[i] == i (as a string) if none of the above conditions are true.

Example 1:

Input: n = 3
Output: ["1","2","Fizz"]

Example 2:

Input: n = 5
Output: ["1","2","Fizz","4","Buzz"]

Example 3:

Input: n = 15
Output: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]

Constraints:

1 <= n <= 104

문제 풀이

n이 주어진고 1부터 n까지 숫자를 판별해 정답을 저장하는 문제이다.
해당 숫자가 3과 5의 공약수라면 'FizzBuzz' 이어야한다.
단지 3의 공약수라면 'Fizz', 5의 공약수라면 'Buzz'를 지정해야한다.
나머지는 숫자를 문자로 변경하여 저장한다.
제한사항은 10^4이기 때문에 브루투 포스로 풀어도된다.
이러한 문제들은 시뮬레이션 문제이며, 주어진 조건들로 어떻게 논리적으로 코드를 짤 수 있는지를 증명하는 문제이다.
물론 공약수 문제이기 때문에 수학공식을 사용하며 문제를 빠르게 풀수도 있지만 정석으로 풀면
for문을 사용하여 1 부터 n 까지 탐색한다.
숫자를 나눠서 각각 숫자들의 공약수에 해당하는 정답을 넣는다.

소스 코드

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        answer = []
        for i in range(1, n+1):
            if i % 3 == 0 and i % 5 == 0:
                answer.append('FizzBuzz')
            elif i % 3 == 0:
                answer.append('Fizz')
            elif i % 5 == 0:
                answer.append('Buzz')
            else:
                answer.append(str(i))
        return answer

[LeetCode] 290. Word Pattern

saurus2 — Fri, 30 Dec 2022 14:48:40 +0900

290. Word Pattern

Easy

Given a pattern and a string s, find if s follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in s.

Example 1:

Input: pattern = "abba", s = "dog cat cat dog"
Output: true

Example 2:

Input: pattern = "abba", s = "dog cat cat fish"
Output: false

Example 3:

Input: pattern = "aaaa", s = "dog cat cat dog"
Output: false

Constraints:

1 <= pattern.length <= 300
pattern contains only lower-case English letters.
1 <= s.length <= 3000
s contains only lowercase English letters and spaces ' '.
s does not contain any leading or trailing spaces.
All the words in s are separated by a single space.

문제 풀이

pattern과 s문자열이 주어진다.
패턴은 알파벳이며 s문자열은 빈공간을 포함한다.
제한 사항을 보면 문자열들의 길이는 작기 때문에 어떻게 풀어도 상관없다.
하지만 패턴과 s문자열에 들어있는 단어를 매칭시켜야한다.
이때 데이터들을 쌍으로 매칭하기 위해서는 해쉬 테이블을 사용할 수 있다.
해쉬 테이블은 키와 벨류로 데이터를 묶어 저장할 수 있기 때문이다.
각각 패턴에 맞는 단어들을 저장하기위해 패턴 딕셔너리를 선언한다.
그리고 s문자열은 어떠한 글자도 나올 수 있기 때문에 문자열 딕셔너리도 따로 선언해줘야한다.
만일 패턴이 'aaa'이고 s문자열이 'a a a' 이런 테스트 케이스가 주어진다면 어떤것이 패턴인지 모를 수 있기 때문에 해쉬 테이블을 두개 사용한다.
s는 띄어쓰기 별로 단어들을 쪼개야해서 split함수를 쓴다.
함수내에 아무것도 적지 않으면 띄어쓰기로 분리된다.
즉, pattern과 s문자열의 데이터를 각각 키와 벨류로 짝을 만들어 딕셔너리에 저장한다.
for문으로 하나씩 탐색하면서 각각의 데이터들을 묶어 저장한다.
처음 단어와 패턴이 만날때 저장된것을 그 단어에 패턴이라고 생각하면 다음에 나오는 단어와 패턴이 이미 저장된 키, 벨류와 다르다면 오답니다.
탐색 시작과 동시에 패턴을 고정하며 하나씩 틀린게 있는지 찾아나가는 것이다.

소스 코드

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        hash_table_p = dict()
        hash_table_s = dict()
        s = s.split()
        if len(s) != len(pattern): return False
        for i in range(len(pattern)):
            p = pattern[i]
            w = s[i]
            if p in hash_table_p:
                if hash_table_p[p] != w:
                    return False
            if  w in hash_table_s:
                if hash_table_s[w] != p:
                    return False
            hash_table_s[w] = p
            hash_table_p[p] = w
        return True

[LeetCode] 217. Contains Duplicate

saurus2 — Fri, 30 Dec 2022 14:18:04 +0900

217. Contains Duplicate

Easy

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

Example 1:

Input: nums = [1,2,3,1]
Output: true

Example 2:

Input: nums = [1,2,3,4]
Output: false

Example 3:

Input: nums = [1,1,1,3,3,4,3,2,4,2]
Output: true

Constraints:

1 <= nums.length <= 105
-109 <= nums[i] <= 109

문제 풀이

주어진 숫자 배열에서 숫자들이 중복되는지 확인하는 문제이다.
제한 사항을 보면 배열의 최대 길이가 10^5이다.
시간복잡도 O(N)으로 풀 수밖에 없는 조건이다.
숫자를 하나씩 보면서 중복이 각각 존재하는지 보려면 적어도 O(N^2)의 시간복잡도가 걸린다.
그래서 O(1) 시간에 데이터를 저장하고 확인해볼 수 있는 Hash Table 접근 방법을 사용한다.
미리 숫자를 set 에 저장하고 하나씩 돌아가면서 이미 있는 숫자이면 True를 리턴하는 방법이다.
set은 딕셔너리와는 달리 어떤 데이터를 중복되지 않게 저장해놓는 자료구조이다.
1, 1, 2, 2를 set에 넣으면 1, 2 만 남는다.
set은 주로 중복되지 않는 데이터를 저장하여 메모리사용을 줄여 사용하는데 쓰며, 데이터를 쓰고 읽는 속도 O(1)로 빠르다.
for 문을 돌다가 리턴을 하는 이유는 중복이 이미 존재하면 나머지 숫자를 모두 확인할 필요가 없기 때문이다.
for 문이 끝나고 false를 리턴하는 이유는 이미 배열의 숫자들을 다 확인했는데 중복이 없다는 뜻이기 때문이다.

소스 코드

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        hash_table = set()
        for num in nums:
            if num in hash_table:
                return True
            hash_table.add(num)
        return False

[LeetCode] 344. Reverse String

saurus2 — Fri, 30 Dec 2022 14:07:28 +0900

344. Reverse String

Easy

Write a function that reverses a string. The input string is given as an array of characters s.

You must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Input: s = ["h","e","l","l","o"]
Output: ["o","l","l","e","h"]

Example 2:

Input: s = ["H","a","n","n","a","h"]
Output: ["h","a","n","n","a","H"]

Constraints:

1 <= s.length <= 105
s[i] is a printable ascii character.

문제 풀이

주어진 문자열 리스트를 반대로 뒤집는 문제이다.
제한사항을 보면 문자열의 최대길이가 10^5이기 때문에 최대 O(N) 풀이법으로 문제를 풀어야한다.
배열안의 값들을 각각 접근하기 쉬운 방법은 투 포인터이다.
포인터들을 두개 생성한다, 하나는 맨앞이며 하나는 맨뒤를 가르키는 인덱스로 초기화한다.
물론 브루트 포스로 각각의 글자들을 옮기는 방법도 있겠으나, 문제 내에서 O(1) Constant(상수) 메모리 복잡도 내에 풀어야한다.
그래서 두개씩 앞뒤 글자를 교체 Swap 을 해준다.
while 문에서는 두개의 포인터가 같거나 시작 포인터와 끝 포인터의 값의 크기가 뒤바뀐다면 종료하도록 만들었다.
while 문의 조건을 작성할 때에는 언제까지 True 조건이어야하는지 신경써서 참의 조건을 적어주면 된다.
만일 조건을 생성하기 어렵다면, 배열의 포인터들을 직접 손으로 그려서 어떤 부분에서, 조건에서 끝내야하는지 확인해보자.

소스 코드

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        pointer1, pointer2 = 0, len(s) - 1
        while pointer1 < pointer2:
            s[pointer1], s[pointer2] = s[pointer2], s[pointer1]
            pointer1 += 1
            pointer2 -= 1

[LeetCode] 88. Merge Sorted Array

saurus2 — Fri, 30 Dec 2022 13:56:57 +0900

88. Merge Sorted Array

Easy

You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.

Merge nums1 and nums2 into a single array sorted in non-decreasing order.

The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.

Example 1:

Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]
Explanation: The arrays we are merging are [1,2,3] and [2,5,6].
The result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.

Example 2:

Input: nums1 = [1], m = 1, nums2 = [], n = 0
Output: [1]
Explanation: The arrays we are merging are [1] and [].
The result of the merge is [1].

Example 3:

Input: nums1 = [0], m = 0, nums2 = [1], n = 1
Output: [1]
Explanation: The arrays we are merging are [] and [1].
The result of the merge is [1].
Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.

Constraints:

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109

Follow up: Can you come up with an algorithm that runs in O(m + n) time?

문제 풀이

이미 오름차순으로 정렬되어있는 두 배열을 합쳐야한다.
합친 배열의 결과도 오름차순으로 정렬이 되어 있어야한다.
첫번째 배열을 답으로 만들어야한다.
제한 사항을 보면 두 배열의 길이가 최대 200개 이기 때문에 브루트 포스로 풀어도된다.
투포인터로 문제를 푸는 방법은 다음과 같다.
투포인터가 의미하는 것은 데이터를 가르키는 포인터 두개를 사용하여 문제를 푸는 것이다.
문제에서 nums1 배열의 크기는 nums1 + nums2 배열의 길이와 같으며 숫자가 채워질 빈공간은 0으로 표기되어있다.
nums1 배열에 중복되는 동작없이 숫자를 넣기 위해서는 맨 뒤의 인덱스부터 시작해야한다.
그 이유는 이미 숫자가 정렬되어 있기 때문에 비어있는 공간부터 채워나갈 때 가장 효율적으로 숫자들을 합칠 수 있다.
각각의 배열에서 마지막 숫자는 각각의 배열들의 가장 큰 숫자이다.
그 숫자들을 가르키는 포인터 두개를 생성하여 비교하며 빈공간이 있을 수 있는 맨 마지막 부터 쌓아나간다.
저장할 자리는 for 문으로 뒤에서 부터 시작하고 포인터 두개는 for 문 한번에 한개씩 움직인다.
즉 O(N) 시간으로써 for 문은 한번 nums1 배열을 뒤에서부터 탐색하고, 포인터 두개가 각각 숫자들을 선택하여 비교한다.

소스 코드

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        pointer1, pointer2 = m - 1, n - 1
        for i in range(len(nums1)-1, -1, -1):
            if pointer1 >= 0 and pointer2 >= 0:
                if nums1[pointer1] >= nums2[pointer2]:
                    nums1[i] = nums1[pointer1]
                    pointer1 -= 1
                else:
                    nums1[i] = nums2[pointer2]
                    pointer2 -= 1
            elif pointer1 >= 0:
                nums1[i] = nums1[pointer1]
                pointer1 -= 1
            elif pointer2 >= 0:
                nums1[i] = nums2[pointer2]
                pointer2 -= 1

[LeetCode] 834. Sum of Distances in Tree

saurus2 — Thu, 22 Dec 2022 20:00:48 +0900

834. Sum of Distances in Tree

Hard

There is an undirected connected tree with n nodes labeled from 0 to n - 1 and n - 1 edges.

You are given the integer n and the array edges where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree.

Return an array answer of length n where answer[i] is the sum of the distances between the ith node in the tree and all other nodes.

Example 1:

Input: n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
Output: [8,12,6,10,10,10]
Explanation: The tree is shown above.
We can see that dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5)
equals 1 + 1 + 2 + 2 + 2 = 8.
Hence, answer[0] = 8, and so on.

Example 2:

Input: n = 1, edges = []
Output: [0]

Example 3:

Input: n = 2, edges = [[1,0]]
Output: [1,1]

Constraints:

1 <= n <= 3 * 104
edges.length == n - 1
edges[i].length == 2
0 <= ai, bi < n
ai != bi
The given input represents a valid tree.

문제 풀이

주어진 트리에서 각 노드에 도착하는 거리들의 총합을 구해야한다.
모든 노드를 시작점으로 하고 각각의 노드에 도착하는 거리를 더한 값을 정답배열에 넣고 리턴해야한다.
모든 노드를 탐색해야하기 때문에 완전탐색 접근을 생각할 수 있으나, 문제 제한사항에서는 최악의 경우 3 * 10^4 개의 노드가 존재한다.
그렇기 때문에 완전탐색으로 모든 노드를 탐색할때 O(N)이 걸리고, 각각의 노드를 모두 시작점으로 한번씩 탐색해야하기 때문에 O(N^2) 시간복잡도로 시간초과가 난다.
부분 트리로 거리의 총합을 계산하는 방법을 사용하여 O(N)으로 시간복잡도를 줄일 수 있다.
만약 a와 b트리가 한선으로 연결되어 있고 두개의 거리 총합을 구하는 식은 다음과 같다.
a와 b가 연결된 거리 총합 = a의 거리 총합 + b의 거리 총합 + b의 총 노드 개수
a와 b노드를 연결하는 간선이 한개 존재하기 때문에 a에서 b 각각의 노드에 도달하려면 1 씩 더해줘야한다.
예를 들어 a에는 0노드가 있고 b에는 1노드와 2노드, 3노드가 일렬로 연결되어 있다고 가정해보자.
0노드의 총거리는 0이며, b노드에는 1에서 2로 가는 거리 1과 1에서 3으로 가는 거리 2가 있어 3이된다.
a의 노드 0에서 1까지 가는 길이는 개수 0개에서 1을 더해 1이고, 0에서 2까지 가려면 b노드에서 계산된 2에 간선 1을 추가하여 2가되고, 0에서 3까지 가는 거리는 1에서 3으로 가는 거리 2에 1을 더해 3이 있다.
결과적으로 0이 최상위 트리라고 했을때, b트리의 총 거리수 3 + b트리의 총 노드 개수 3을 계산하여 6이된다.
다시말해 a - b 로 연결된 트리의 정답은 a 정답 + (b의 1노드에서 2노드 + 1 + b의 1노드에서 3노드 + 1 + a에서 b 시작노드로 연결되는 간선 1) 이된다.
이를위해, dfs 후위 탐색을 사용하여 각각의 노드들이 가진 노드의 개수를 cnt 배열에 더해준다.
그리고 위식을 사용하여 정답에는 node위치와 child 위치의 정답을 구하기 위해 node의 정답 + child 정답 + child 노드의 총 개수를 더한다.
위식과 똑같이 a(node 트리)정답 + b(child 트리)정답 + b(child 트리) 노드 총 개수로 탐색을 완료한다.
dfs를 끝내면 자식 노드들을 가지고 있는 노드들의 정답들과 자식들의 개수가 저장된다.
나머지 노드들의 정답을 채우기 위해서는 위의 식을 응용하여 dfs 선위 탐색을 진행한다.
1. a - b 의 정답 = a 정답 + b 정답 + b 노드의 총 개수
2. b - a 의 정답 = b 정답 + a 정답 + a 노드의 총 개수
이 두식을 합쳐 사용하는데, 현재 자식들이 존재하는 노드들의 정답은 저장되어 있다.
1번 식은 정답이 저장되어있는, 즉 자식들이 존재하는 노드이며 2번 식은 정답이 없는 노드들이다.
이 b노드의 값을 구하기 위해 2번 식에서 1번 식을 빼서 사용한다.
계산을 하게된 결과는 다음과 같다.
b - a 의 정답 - a - b 의 정답 = a 노드의 총 개수 - b 노드의 총 개수
b - a 의 정답 = a - b 의 정답 + a 노드의 총 개수 - b 노드의 총 개수
a - b 의 정답과 b 노드의 총 개수는 미리 구해놓았기 때문에 바로 사용할 수 있다.
a 노드의 총 개수는 전체 노드 개수에서 b 노드의 총 개수를 빼면 쉽게 구할 수 있다.
즉, b - a 의 정답 = a - b 의 정답 - b 노드의 총 개수 + a - b의 총 노드 개수 - b 노드의 총 개수
이식을 이용하여 dfs를 한번더 진행하면서 위식을 사용하여 정답들을 저장한다.
선위 탐색으로 dfs를 진행하는 이유는 순차적으로 먼저 계산을 해야 다음 정답을 참고할때 사용할 수 있다.
자식들이 있는 노드들은 첫번째 dfs에서 정답을 구했고, 두번째 dfs 에서 위 공식을 사용하여 트리 모양을 변경시켜 답을 구한다고 생각하면 이해하기 쉽다.
각각의 노드들을 2번 완전 탐색 하기 때문에 O(N + N)이며 최종적으로는 O(N) 의 시간이 걸린다.

소스 코드

class Solution:
    def sumOfDistancesInTree(self, n: int, edges: List[List[int]]) -> List[int]:
        g = defaultdict(set)
        for a, b in edges:
            g[a].add(b)
            g[b].add(a)
        
        cnt = [1] * n
        ans = [0] * n

        def dfs(node, parent):
            for child in g[node]:
                if child != parent:
                    dfs(child, node)
                    cnt[node] += cnt[child]
                    ans[node] += ans[child] + cnt[child]
        
        def dfs2(node, parent):
            for child in g[node]:
                if child != parent:
                    ans[child] = ans[node] - cnt[child] + n - cnt[child]
                    dfs2(child, node)
        dfs(0, None)
        dfs2(0, None)
        return ans

[LeetCode] 886. Possible Bipartition

saurus2 — Thu, 22 Dec 2022 01:00:19 +0900

886. Possible Bipartition

Medium

We want to split a group of n people (labeled from 1 to n) into two groups of any size. Each person may dislike some other people, and they should not go into the same group.

Given the integer n and the array dislikes where dislikes[i] = [ai, bi] indicates that the person labeled ai does not like the person labeled bi, return true if it is possible to split everyone into two groups in this way.

Example 1:

Input: n = 4, dislikes = [[1,2],[1,3],[2,4]]
Output: true
Explanation: group1 [1,4] and group2 [2,3].

Example 2:

Input: n = 3, dislikes = [[1,2],[1,3],[2,3]]
Output: false

Example 3:

Input: n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
Output: false

Constraints:

1 <= n <= 2000
0 <= dislikes.length <= 104
dislikes[i].length == 2
1 <= dislikes[i][j] <= n
ai < bi
All the pairs of dislikes are unique.

문제 풀이

사람이 N개 있으며, 각각 사람들이 싫어하는 짝의 번호 두개로 이루어진 2차원 배열이 주어진다.
싫어하는 사람들끼리는 그룹으로 묶을 수 없다.
사람들을 두 그룹으로 나눌 수 있는지를 구해야한다.
모든 사람들이 두 그룹으로 나뉘었을때 그 그룹에는 싫어하는 사람이 생기면 안된다.
제한 사항은 N^4 이기 때문에 완전탐색으로 문제를 접근할 수 있으며, 간선으로써 dislike 배열을 사용하여 그룹을 만들기 때문에 유니온 파인드로 접근할 수 있다.

DFS

그룹에 싫어하는 사람이 없어야한다.
싫어하는 사람들을 나타내는 dislikes 배열은 간선을 나타내고 있기 때문에 현재 사람(노드)에서 싫어하는 사람을 연결했을때 그 사람들은 모두 현재 사람을 싫어한다.
현재 사람에서 싫어하는 사람 다음으로 연결된 노드가 있고 이 노드가 현재 사람과 연결되지 않다면, 그 노드는 앞서 언급한 현재 사람을 싫어하지 않음을 의미한다.
즉 연결될 간선들을 한번 연결해주고 0과 1을 사용하여 구분할 수 있다.
싫어하는 사람들을 저장한 dislikes를 모두 양방향 간선들로써 인접행렬을 생성한다.
그리고 col 배열을 생성하여 각 노드를 구분할 배열을 만들고 -1로 초기화한다.
초기화를 통해 노드를 탐색한 것에 대한 중복을 방지할 수 있다.
1부터 n까지 탐색하면서 만약 탐색 했던 노드가 아니면 현재 노드 번호와 구분할 매개변수를 넘겨 dfs 재귀함수를 호출한다.
첫 시작노드는 0의 구분 값을 col에 넣게 되고, 현재 노드에 연결된 노드들을 탐색한다.
탐색시 현재 노드와 다음으로 이동할 노드의 구분 값이 같다면 False를 리턴한다.
만일 구분 값이 설정되지 않은 새 노드라면 dfs를 호출하는데, 이때 1 - 구분 값 매개변수를 넣는다.
1 - 구분 값 매개변수는 다음 재귀호출시 0에서 1로 1에서 0으로 바뀌게 해준다.
만일 호출 후 리턴값이 false 라면 false를 리턴한다.
이는 한번이라도 false가 리턴되면 재귀호출을 마지막까지 리턴시키기 위함이다.
다시 본 코드로 돌아와서, 리턴값이 false면 노드들 끼리, 즉 현재 노드와 다음 노드의 구분 값이 같다면 false를 리턴한다.

Union Find

싫어하는 사람들을 그룹으로 묶는 것이 아니라, 현재 노드에서 싫어하는 사람들로 연결된 노드들을 그룹으로 묶는다.
현재 노드를 싫어하는 노드들을 그룹으로 묶는 것은 한 노드를 싫어하는 노드들은 각자 싫어하지 않을 거라는 가정에서 시작한다.
매번 위 행동을 반복하면서 이전에 형성된 한 노드를 싫어하는 그룹을 참고로 답을 가려내기 시작한다.
즉, 그 그룹은 자신들끼리 싫어하지 않는 그룹인데 다음 노드 회차에서 싫어하는 노드들을 find로 그룹이 되어있는지 확인하면 싫어하는 사람들끼리 묶였는지 알 수 있다.
두 그룹으로 나눌때 사람의 수는 상관 없기 때문에 싫어하는 사람들이 이전 그룹에서 중복되어 겹치지만 않으면 두 그룹으로 쪼갤 수 있음을 의미한다.
만약 중복되어 있다면 2개로 쪼개지는 것이 아니라 그 이상으로 쪼개질 수 있기 때문에 False를 리턴한다.
find는 재귀함수로 부모 배열에 각각 연결된 노드들을 저장한다.
최상위 부모 노드번호를 저장하기 위해 find 함수가 리턴한 값을 현재 노드의 부모 배열에 저장한다.
union 함수는 두 노드 번호의 부모를 구하고 rank에 맞게 최상위 부모를 저장시킨다.
rank를 사용하는 이유는 단지 순서에 대한 처리시간을 빠르게 하기 위해서이다.
중복되는 노드들이 생기면 자연스럽게 랭크를 증가시키고 증가시킨 노드는 자식 노드의 층을 의미한다고 볼 수 있다.
층에 맞게 부모 노드를 할당해주면 find로 노드를 탐색할때 O(1)의 속도로 최상 부모 노드를 찾을 수 있다.
양방향 인접 2차원 배열을 만들고 각각 싫어하는 노드들의 번호들을 저장한다.
사람의 번호들을 탐색하면서 그 사람의 번호를 싫어하는 사람들의 번호를 탐색한다.
만일 현재 노드와 현재 노드를 싫어하는 사람의 노드의 최상위 부모가 같다면 False 를 리턴한다.
이미 만들어진 그룹에서 부모의 중복이 발생하면 그룹은 2개 초과가 된다.
그 후, 현재 노드의 싫어하는 노드들의 첫 노드와 모든 현재 노드를 싫어하는 노드를 그룹으로 만들기 위해 Union 함수를 호출한다.

소스 코드

DFS

class Solution:
    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:
        def dfs(node, n_col):
            col[node] = n_col
            for neighbor in adj[node]:
                if col[neighbor] == col[node]:
                    return False
                if col[neighbor] == -1:
                    if not dfs(neighbor, 1 - n_col):
                        return False
            return True
        adj = [[] for _ in range(n + 1)]
        for dislike in dislikes:
            adj[dislike[0]].append(dislike[1])
            adj[dislike[1]].append(dislike[0])
        col = [-1] * (n + 1)
        for i in range(1, n + 1):
            if col[i] == -1:
                if not dfs(i, 0):
                    return False
        return True

Union find

class Solution:
    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:
        s = n + 1
        p = [i for i in range(s)]
        r = [0] * s

        def find(num):
            if p[num] != num:
                p[num] = find(p[num])
            return p[num]
        
        def union(a, b):
            ap = find(a)
            bp = find(b)

            if ap == bp: return
            if r[ap] < r[bp]:
                p[ap] = bp
            elif r[ap] > r[bp]:
                p[bp] = ap
            else:
                p[bp] = ap
                r[ap] += 1
        adj = [[] for _ in range(n + 1)]
        for lst in dislikes:
            adj[lst[0]].append(lst[1])
            adj[lst[1]].append(lst[0])
        
        for i in range(1, n + 1):
            for j in adj[i]:
                if find(i) == find(j):
                    return False
                union(adj[i][0], j)
        return True

[LeetCode] 1971. Find if Path Exists in Graph

saurus2 — Wed, 21 Dec 2022 18:33:12 +0900

1971. Find if Path Exists in Graph

Easy

There is a bi-directional graph with n vertices, where each vertex is labeled from 0 to n - 1 (inclusive). The edges in the graph are represented as a 2D integer array edges, where each edges[i] = [ui, vi] denotes a bi-directional edge between vertex ui and vertex vi. Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.

You want to determine if there is a valid path that exists from vertex source to vertex destination.

Given edges and the integers n, source, and destination, return true if there is a valid path from source to destination, or false otherwise.

Example 1:

Input: n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2
Output: true
Explanation: There are two paths from vertex 0 to vertex 2:
- 0 → 1 → 2
- 0 → 2

Example 2:

Input: n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5
Output: false
Explanation: There is no path from vertex 0 to vertex 5.

Constraints:

1 <= n <= 2 * 105
0 <= edges.length <= 2 * 105
edges[i].length == 2
0 <= ui, vi <= n - 1
ui != vi
0 <= source, destination <= n - 1
There are no duplicate edges.
There are no self edges.

문제 풀이

그래프가 주어지고, 출발점과 도착점이 주어진다.
그래프는 간선들로 이루어져있는데 양방향 그래프이다.
edges 배열은 한 노드에서 다른 노드로 연결된 간선을 의미한다.
출발점에서 도착점까지 이동할 수 있는지를 구해야한다.
그래프 문제이기 때문에 완전탐색으로 접근할 수 있으며, 문제 제한을 봤을때 최악의 경우 2 x 10^5 이다.
모든 노드를 DFS, BFS로 탐색한다면 노드 개수만큼의 O(N) 시간 복잡도일 것이다.
그리고 노드 뿐만 아니라 모든 간선을 탐색해야 연결이 어떻게 되있는지 알 수 있기 때문에 최종 시간 복잡도는 O(N + M)이다.

DFS

리스트 딕셔너리로 양방향 간선들을 모두 넣는다.
한번 방문한 노드를 처리해주기 위해 n크기의 visited 배열을 0으로 초기화한다.
재귀 함수를 만들때 종료 조건은 현재 노드 숫자가 종료번호이거나 방문 했던 노드라면 리턴을 해야한다.
목적지일 경우에는 True를 리턴한다.
visited 배열에 해당 노드에 방문한 기록을 해주며, 현재 노드에 연결되어있는 간선들을 탐색한다.
dfs 재귀함수의 종료조건에서 답으로 True가 리턴되면, 그자리에서 True를 리턴하면서 끝낸다.
한번 True가 발생하면 전 재귀함수 혹은 후 재귀함수에서 모두 리턴 처리가 된다.
반복문이 끝나고 나면 해당 노드의 간선에 대한 탐색이 끝났기 때문에 False를 리턴한다.
False가 특정 상황에서 리턴이 되면 dfs는 계속 진행된다.

Union-find

유니온 파인드를 사용하여 노드들의 그룹 여부를 알 수 있다.
이를 이용해서 같은 그룹에 시작과 도착점이 있다면 정답이다.
유니온 파인드를 개선해서 사용하면 간선 크기만큼의 m으로 모든 그룹을 만들고 나서 find 함수를 사용한다.
그때 O(a(n)) 시간복잡도인데, a(n)은 n보다 작은 숫자라고 생각하는게 편하다.
왜냐하면 완성된 그룹 자료구조에서 find 함수는 O(1)만에 부모 노드를 찾을 수 있기 때문이다.
우선, 부모 배열을 자기 자신의 번호로 초기화한다.
자기 자신이 부모라면 그 노드는 아무 그룹에도 해당되지 않음을 의미한다.
find함수는 재귀함수를 사용하는데, 만일 찾는 노드의 부모가 현재 노드가 아니라면 find 함수를 재귀호출한다.
그리고 함수가 종료될때 현재 재귀함수호출 상황의 부모노드를 리턴한다.
결과적으로 첫 노드 번호의 부모노드를 찾는데, 재귀호출시 리턴되는 부모노드를 현재 재귀호출 상태의 부모 노드 배열에 저장한다.
최종 부모 노드, 즉 최상위 부모 노드가 한 그룹의 부모로 통일되어 저장된다.
Union 함수는 매개 변수 두개를 두개의 노드를 연결하려는 의도로 만든다.
우선 각각 노드의 부모를 찾아 가져온다.
그리고 만일 노드들의 부모가 다르다면 첫 노드의 부모를 두번째 노드의 부모로 저장한다.
함수를 다 만들었다면 모든 간선들에 대해 Union 함수를 호출하여 부모 노드 배열을 채운다.
그룹이 완성되면 시작 노드번호와 도착 노드번호의 부모 노드를 find로 찾는다.
두개의 노드에 대한 부모 노드를 비교했을때, 같으면 그룹이고 다르면 그룹이아니다.
즉, 출발지와 도착지는 같은 그룹일때 연결되어있다고 볼 수 있다.

소스 코드

Union-find

class Solution:
    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
        p = [i for i in range(n)]
        def find(num):
            if p[num] != num:
                p[num] = find(p[num])
            return p[num]
        def union(a, b):
            p1 = find(a)
            p2 = find(b)
            if p1 != p2:
                p[p1] = p[p2]
        for u, v in edges:
            union(u, v)
        if find(source) == find(destination):
            return True
        return False

DFS

class Solution:
    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
        g = defaultdict(list)
        for a, b in edges:
            g[a].append(b)
            g[b].append(a)
        visited = [0] * n
        def dfs(n):
            if n == destination:
                return True
            if visited[n] == 1:
                return
            visited[n] = 1
            for nxt in g[n]:
                if dfs(nxt):
                    return True
            return False
        return dfs(source)

[LeetCode] 1066. Campus Bikes II

saurus2 — Wed, 21 Dec 2022 01:34:37 +0900

1066. Campus Bikes II

Medium

On a campus represented as a 2D grid, there are n workers and m bikes, with n <= m. Each worker and bike is a 2D coordinate on this grid.

We assign one unique bike to each worker so that the sum of the Manhattan distances between each worker and their assigned bike is minimized.

Return the minimum possible sum of Manhattan distances between each worker and their assigned bike.

The Manhattan distance between two points p1 and p2 is Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|.

Example 1:

Input: workers = [[0,0],[2,1]], bikes = [[1,2],[3,3]]
Output: 6
Explanation: 
We assign bike 0 to worker 0, bike 1 to worker 1. The Manhattan distance of both assignments is 3, so the output is 6.

Example 2:

Input: workers = [[0,0],[1,1],[2,0]], bikes = [[1,0],[2,2],[2,1]]
Output: 4
Explanation: 
We first assign bike 0 to worker 0, then assign bike 1 to worker 1 or worker 2, bike 2 to worker 2 or worker 1. Both assignments lead to sum of the Manhattan distances as 4.

Example 3:

Input: workers = [[0,0],[1,0],[2,0],[3,0],[4,0]], bikes = [[0,999],[1,999],[2,999],[3,999],[4,999]]
Output: 4995

Constraints:

n == workers.length
m == bikes.length
1 <= n <= m <= 10
workers[i].length == 2
bikes[i].length == 2
0 <= workers[i][0], workers[i][1], bikes[i][0], bikes[i][1] < 1000
All the workers and the bikes locations are unique.

문제 풀이

일하는 사람들의 2차원 좌표 배열과 자전거들의 2차원 좌표 배열이 주어진다.
각각의 사람들이 각각의 자전거를 차지한다고 했을때, 사람의 좌표부터 자전거의 거리까지의 총합의 최소값을 구해야한다.
거리는 맨하탄 거리로 자전거와 사람의 거리를 계산한다.
제한 사항을 보면 사람들과 자전거들의 최대길이가 10이다.
완전 탐색으로 가능할 것 같지만, 만일 모든 사람들이 모든 자전거를 한번씩 탐색한다면 N^N 시간복잡도가 나올 것이다.
그래서 DFS를 사용하여 완전탐색을 하되, 몇번째 사람인지와 여태 방문한 사람들 번호로 메모이제이션을 활용해야한다.
사람들 번호로 탐색을 할때 방문한 자전거들의 번호를 계속해서 저장해준다.
memo 배열에 자전거들과 사람들의 거리의 총값을 저장할때는 모든 재귀 호출이 끝나고 적어준다.
리턴 조건에서 사람의 번호가 일하는 사람들의 길이를 넘었을때 종료해주도록 설계했기 때문이다.
즉, dfs 함수를 호출할때마다 사람의 번호가 1씩 추가가되고 마지막 사람까지의 자전거들의 거리를 계산하고 난 뒤에 그 값을 memo에 저장한다.
저장할때는 사람의 번호와 현재 확인한 자전거들의 번호를 튜플로 넣어 중복을 피한다.
for 문으로 모든 자전거를 탐색하기 때문에 이러한 작업이 필요하다.
그리고 확인한 자전거의 visited 체크는 풀어줘야한다.
만일 풀지 않으면 모든 자전거들을 확인할 수 없기 때문이다.

소스 코드

class Solution:
    def assignBikes(self, workers: List[List[int]], bikes: List[List[int]]) -> int:
        w_n = len(workers)
        b_n = len(bikes)
        def dis(w, b):
            return abs(b[0] - w[0]) + abs(b[1] - w[1])

        def dfs(w, visited, memo):
            if w >= w_n:
                return 0
            if (w, tuple(visited)) in memo:
                return memo[(w, tuple(visited))]
            
            ans = float('inf')
            for i in range(b_n):
                if i in visited: continue
                visited.add(i)
                ret = dfs(w + 1, visited, memo)
                visited.remove(i)
                ret += dis(workers[w], bikes[i])
                ans = min(ans, ret)
            memo[(w, tuple(visited))] = ans
            return ans
        return dfs(0, set(), dict())

[LeetCode] 841. Keys and Rooms

saurus2 — Tue, 20 Dec 2022 20:33:06 +0900

841. Keys and Rooms

Medium

There are n rooms labeled from 0 to n - 1 and all the rooms are locked except for room 0. Your goal is to visit all the rooms. However, you cannot enter a locked room without having its key.

When you visit a room, you may find a set of distinct keys in it. Each key has a number on it, denoting which room it unlocks, and you can take all of them with you to unlock the other rooms.

Given an array rooms where rooms[i] is the set of keys that you can obtain if you visited room i, return true if you can visit all the rooms, or false otherwise.

Example 1:

Input: rooms = [[1],[2],[3],[]]
Output: true
Explanation: 
We visit room 0 and pick up key 1.
We then visit room 1 and pick up key 2.
We then visit room 2 and pick up key 3.
We then visit room 3.
Since we were able to visit every room, we return true.

Example 2:

Input: rooms = [[1,3],[3,0,1],[2],[0]]
Output: false
Explanation: We can not enter room number 2 since the only key that unlocks it is in that room.

Constraints:

n == rooms.length
2 <= n <= 1000
0 <= rooms[i].length <= 1000
1 <= sum(rooms[i].length) <= 3000
0 <= rooms[i][j] < n
All the values of rooms[i] are unique.

문제 풀이

방의 열쇠가 들어가있는 방의 배열이 주어진다.
2차원 배열이며 각각의 배열에는 번호들이 들어있는데, 이 번호는 그 번호의 방으로 들어갈 수 있는 키이다.
0번인 첫번째 방은 열쇠없이도 들어갈 수 있지만 다른방은 열쇠가 있어야한다.
첫번째 방으로 들어가서 열쇠를 얻고 들어갈 수 있는 모든 방을 탐색하여 주어진 rooms에 들어갈 수 있는지를 구해야한다.
제한 조건을 보면 방의 개수가 최대 1000 이기 때문에 완전탐색 접근을 시도해도 된다.
DFS, BFS를 사용할 수 있으며, 모든 방의 열쇠를 모든 방이 가지고 있을 때도 있기 때문에 BFS가 성능면에서는 조금 빠를것이라고 예상된다.
방의 개수를 구하고 BFS를 구축한다.
큐에 현재 방번호와 그 방에 들어있는 열쇠들의 배열을 넣는다.
한번 들어갔던 방은 피하기위해 visited 배열을 사용하여 막는다.
방의 개수에서 0번 방의 개수를 뺀 n을 사용하여, 새로운 방문을 열었을때마다 개수를 제거한다.
결과적으로 n값이 0이되면 모든 방을 들어갔다 온것이다.
큐가 바닥 날때까지 n의 개수가 0이되지 않으면 들어가지 못한 방이 존재하는 것이다.

소스 코드

class Solution:
    def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:
        n = len(rooms) - 1
        visited = [0] * (n + 1)
        visited[0] = 1
        que = []
        que.append((0, rooms[0]))
        while que:
            curr_n, rs = que.pop(0)
            for i in range(len(rs)):
                if visited[rs[i]] == 1: 
                    continue
                visited[rs[i]] = 1
                n -= 1
                if n == 0:
                    return True
                que.append((rs[i], rooms[rs[i]]))
        return False

[LeetCode] 739. Daily Temperatures

saurus2 — Tue, 20 Dec 2022 20:17:08 +0900

739. Daily Temperatures

Medium

Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.

Example 1:

Input: temperatures = [73,74,75,71,69,72,76,73]
Output: [1,1,4,2,1,1,0,0]

Example 2:

Input: temperatures = [30,40,50,60]
Output: [1,1,1,0]

Example 3:

Input: temperatures = [30,60,90]
Output: [1,1,0]

Constraints:

1 <= temperatures.length <= 105
30 <= temperatures[i] <= 100

문제 풀이

온도 배열이 주어진다.

각 온도의 숫자가 자신의 위치에서 자신보다 높은 온도 위치의 거리 차이를 구해야한다.

높은 온도 위치의 거리를 구할때는 자신의 위치에서 가장 가까운 온도 위치로 계산한다.

처음 정답 배열에는 온도 배열 크기만큼 0을 할당하고, 각 온도를 탐색하면서 스택에 온도를 저장한다.

값을 탐색하면서 큰 숫자가 나오지 않으면 답으로 0을 저장해야 하기 때문이다.

저장 되는 온도 값은 앞으로 탐색하게 되는 온도 값과 비교하여, 큰 값이 있다면 현재 탐색 위치인 인덱스에서 스텍의 인덱스 값을 빼어 답으로 저장하고 처리된 온도 값은 스텍에서 제거한다.

위 과정은 스텍이 빌때까지 진행된다.

참고로 스택에 들어가는 값은 인덱스이며 온도 값을 확인할때도 인덱스를 사용한다.

소스 코드

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        ans = [0] * len(temperatures)
        st = []
        for i, n in enumerate(temperatures):
            while st and temperatures[st[-1]] < n:
                ans[st[-1]] = i - st[-1]
                st.pop()
            st.append(i)
        return ans

[LeetCode] 2272. Substring With Largest Variance

saurus2 — Fri, 9 Dec 2022 10:45:37 +0900

2272. Substring With Largest Variance

Hard

The variance of a string is defined as the largest difference between the number of occurrences of any 2 characters present in the string. Note the two characters may or may not be the same.

Given a string s consisting of lowercase English letters only, return the largest variance possible among all substrings of s.

A substring is a contiguous sequence of characters within a string.

Example 1:

Input: s = "aababbb"
Output: 3
Explanation:
All possible variances along with their respective substrings are listed below:
- Variance 0 for substrings "a", "aa", "ab", "abab", "aababb", "ba", "b", "bb", and "bbb".
- Variance 1 for substrings "aab", "aba", "abb", "aabab", "ababb", "aababbb", and "bab".
- Variance 2 for substrings "aaba", "ababbb", "abbb", and "babb".
- Variance 3 for substring "babbb".
Since the largest possible variance is 3, we return it.

Example 2:

Input: s = "abcde"
Output: 0
Explanation:
No letter occurs more than once in s, so the variance of every substring is 0.

Constraints:

1 <= s.length <= 10^4
s consists of lowercase English letters.

문제 풀이

Kadane 알고리즘

주어진 문장에서 두 개의 알파벳을 선택하여 알파벳의 개수 차이의 최대값을 구해야한다.
알파벳 두개가 포함되는 배열은 부분 연속 배열로 답으로 선택될 수 있는 배열의 범위는 연속적으로 연결되어 있어야한다.
문제 제한은 10^4라 브루트 포스로도 풀릴 것 같지만 for문을 사용하면 3중포문을 사용해야해서 시간 제한에 걸린다.
부분합의 최대 값을 구하는 문제에서 사용하는 알고리즘은 Kadane 알고리즘 '카데인'이다.
이 알고리즘을 사용하여 푸는 문제중 easy 문제는 아래 첨부하였다.

https://leetcode.com/problems/maximum-subarray

Maximum Subarray - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

최대 값을 가진 부분 배열 합을 구할때 음수 값이 있기 때문에 조금 복잡하다.
하지만 이 알고리즘을 사용하면 선형 시간내에 풀 수 있다.
우선 최대값을 저장할 변수를 두개 만든다.
하나는 부분합의 값이 계속 바뀌기 때문에 그에 대한 최대 값이며, 나머지 하나는 리턴할 최대 값이다.
-1, 2, -6, 3, 7 배열이 있다고 가정했을때 최대 합 값은 10이다.
배열의 첫자리부터 더해 나가며 값을 비교하는데, 현재 값과 이전까지 더했던 값과의 합과 비교한다.
2 값에 도착했을때, 이전 값과의 합은 1이고 현재 값은 2이다.
최대값을 2로 바꿔주고, 이 값을 반환할 값과 비교하여 최대값으로 만들어준다.
이렇게 하는 이유는 -1은 도움이 되지 않기 때문이다.
3에 도착했을때도 마찬가지고 수행되고, 마지막에 3, 7을 더했을때 최대값이 된다.

Kadane 알고리즘 응용

주어진 문장의 알파벳 개수를 Counter로 구해준다.
그리고 Permutations을 이용하여 두개의 알파벳을 구성한다.
a는 시작 알파벳이고 b는 최대 합 값 계산시에 개수를 빼줄 알파벳이다.
두 글자를 순열(선택)로 만들어 문장에서 부분 수열 최대 합을 구한다.
글자가 a, b 둘 중 하나도 포함되지 않는다면 무시하고, a일때는 a의 개수를 b일때는 b의 개수를 올린다.
b의 남은 개수를 줄여나가는 이유는 조금 전의 카데인 알고리즘을 응용한 부분이다.
만일 b의 개수가 a의 개수보다 많고 b의 전체 개수가 1개 이상이면 이 말은 시작지점부터 끝까지 탐색을 해도 현재 부분 배열에서는 a의 개수가 b의 개수보다 월등히 높아질 수 없기 때문에 a, b의 개수 값을 초기화하여 다음 알파벳부터 다시 부분 배열이 시작된다.
그리고 최대 값을 취할때 b의 개수를 확인하는 이유는 문제에서 두 알파벳이 꼭 함께 있어야 Variance를 계산할 수 있기 때문이다.

소스 코드

class Solution:
    def largestVariance(self, s: str) -> int:
        counter = Counter(s)
        res = 0
        for a, b in permutations(counter, 2):
            count_a, count_b = 0, 0
            remain_b = counter[b]
            for c in s:
                if c != a and c != b:
                    continue
                if c == a:
                    count_a += 1
                elif c == b:
                    count_b += 1
                    remain_b -= 1
                if count_a < count_b and remain_b > 0:
                    count_a, count_b = 0, 0
                if count_b > 0:
                    res = max(res, count_a - count_b)
        return res

[LeetCode] 323. Number of Connected Components in an Undirected Graph

saurus2 — Thu, 8 Dec 2022 11:09:49 +0900

323. Number of Connected Components in an Undirected Graph

Medium

You have a graph of n nodes. You are given an integer n and an array edges where edges[i] = [ai, bi] indicates that there is an edge between ai and bi in the graph.

Return the number of connected components in the graph.

Example 1:

Input: n = 5, edges = [[0,1],[1,2],[3,4]]
Output: 2

Example 2:

Input: n = 5, edges = [[0,1],[1,2],[2,3],[3,4]]
Output: 1

Constraints:

1 <= n <= 2000
1 <= edges.length <= 5000
edges[i].length == 2
0 <= ai <= bi < n
ai != bi
There are no repeated edges.

문제 풀이

노드의 개수와 간선들의 정보가 주어진다.
간선들의 정보를 이용하여 연결되어 있는 그룹의 개수를 구해야한다.
간선들은 방향을 갖지 않기 때문에 a에서 b로 b에서 a로 이동할 수도 있다.
만약 간선이 없는 노드라면 그 노드는 다른 그룹이다.
양방향 간선들을 딕셔너리로 만든다.
재귀함수를 사용하여 0부터 n-1 까지 탐색해야한다.
만일 간선이 없다면 정답 그룹 개수를 1개 늘리고, 간선이 존재한다면 재귀함수를 이용하여 탐색해야한다.
탐색하면서 이미 방문한 노드는 visited 배열로 처리해주자.

참고로, Union-Find를 활용하여 그룹의 개수를 구하는 방법도 있지만 생략한다.

소스 코드

class Solution:
    def countComponents(self, n: int, edges: List[List[int]]) -> int:
        cnt = 0
        visited = [0] * (n + 1)
        mp = defaultdict(list)
        for y, x in edges:
            mp[y].append(x)
            mp[x].append(y)
        def rec(num):
            for x in mp[num]:
                if visited[x] == 1: continue
                visited[x] = 1
                rec(x)
        for i in range(0, n):
            if i not in mp: 
                cnt += 1
                continue
            if visited[i] == 1: continue
            visited[i] = 1
            rec(i)
            cnt += 1
        return cnt

[LeetCode] 2256. Minimum Average Difference

saurus2 — Wed, 7 Dec 2022 04:23:02 +0900

2256. Minimum Average Difference

Medium

You are given a 0-indexed integer array nums of length n.

The average difference of the index i is the absolute difference between the average of the first i + 1 elements of nums and the average of the last n - i - 1 elements. Both averages should be rounded down to the nearest integer.

Return the index with the minimum average difference. If there are multiple such indices, return the smallest one.

Note:

The absolute difference of two numbers is the absolute value of their difference.
The average of n elements is the sum of the n elements divided (integer division) by n.
The average of 0 elements is considered to be 0.

Example 1:

Input: nums = [2,5,3,9,5,3]
Output: 3
Explanation:
- The average difference of index 0 is: |2 / 1 - (5 + 3 + 9 + 5 + 3) / 5| = |2 / 1 - 25 / 5| = |2 - 5| = 3.
- The average difference of index 1 is: |(2 + 5) / 2 - (3 + 9 + 5 + 3) / 4| = |7 / 2 - 20 / 4| = |3 - 5| = 2.
- The average difference of index 2 is: |(2 + 5 + 3) / 3 - (9 + 5 + 3) / 3| = |10 / 3 - 17 / 3| = |3 - 5| = 2.
- The average difference of index 3 is: |(2 + 5 + 3 + 9) / 4 - (5 + 3) / 2| = |19 / 4 - 8 / 2| = |4 - 4| = 0.
- The average difference of index 4 is: |(2 + 5 + 3 + 9 + 5) / 5 - 3 / 1| = |24 / 5 - 3 / 1| = |4 - 3| = 1.
- The average difference of index 5 is: |(2 + 5 + 3 + 9 + 5 + 3) / 6 - 0| = |27 / 6 - 0| = |4 - 0| = 4.
The average difference of index 3 is the minimum average difference so return 3.

Example 2:

Input: nums = [0]
Output: 0
Explanation:
The only index is 0 so return 0.
The average difference of index 0 is: |0 / 1 - 0| = |0 - 0| = 0.

Constraints:

1 <= nums.length <= 105
0 <= nums[i] <= 105

문제 풀이

숫자 배열이 주어진다.
0부터 i 까지의 숫자 합 평균(i+1로 합을 나눈다.)과 i+1 부터 끝까지의 합 평균(n - i - 1로 합을 나눈다.)의 차가 가장 작은 값을 구해야한다.
가장 작은 값을 가지는 위치를 리턴하면 된다.
만약 다수의 정답이 있다면 인덱스는 가장 작은 값이어야하며, n개의 숫자의 합 평균은 전체 합 나누기 n이다.
그리고 0의 평균은 0이다.
제한 사항을 보면 10^5 이기 때문에 O(N)으로 풀어야한다.
prefix sum을 활용하여 풀어야한다.
처음 index 1자리 부터 끝까지 숫자들을 더하여 시작한다.
첫번째 정답은 미리 구하는데 인덱스 0 위치의 숫자 한개와 1부터 n(배열의 끝)까지의 합 평균으로 절대값을 계산한다.
이후, 인덱스 1부터 진행하여 왼쪽 파트에는 인덱스 i의 값을 빼고 평균을 구하고, 오른쪽 파트에는 인덱스 i의 값을 더해 평균을 계산한다.
주의할 점은 평균을 구할때 0이 들어갈 수 있기 때문에 이를 예외 처리해주어야 한다.

소스 코드

class Solution:
    def minimumAverageDifference(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return 0
        total1 = nums[0]
        total2 = sum(nums[1:])
        ans = abs(total1 - total2//(n - 1))
        ans_i = 0
        for i in range(1, n):
            total1 += nums[i]
            total2 -= nums[i]
            l = total1 // (i + 1) if total1 > 0 else 0
            r = total2 // (n - i - 1) if total2 > 0 else 0
            if ans > abs(l - r):
                ans = abs(l - r)
                ans_i = i
        return ans_i

[LeetCode] 328. Odd Even Linked List

saurus2 — Wed, 7 Dec 2022 03:41:02 +0900

328. Odd Even Linked List

Medium

Given the head of a singly linked list, group all the nodes with odd indices together followed by the nodes with even indices, and return the reordered list.

The first node is considered odd, and the second node is even, and so on.

Note that the relative order inside both the even and odd groups should remain as it was in the input.

You must solve the problem in O(1) extra space complexity and O(n) time complexity.

Example 1:

Input: head = [1,2,3,4,5]
Output: [1,3,5,2,4]

Example 2:

Input: head = [2,1,3,5,6,4,7]
Output: [2,3,6,7,1,5,4]

Constraints:

The number of nodes in the linked list is in the range [0, 104].
-106 <= Node.val <= 106

문제 풀이

링크드 리스트가 주어진다.
짝수 번째의 노드들을 모두 연결하고 홀수 번째의 노드들을 모두 연결한다.
맨앞에 홀수 번째로 구성된 링크드리스트가 있어야하며 그 뒤에는 짝수 번째의 노드들이 연결되어야한다.
공간 복잡도는 O(1) 상수 크기 만큼만 사용하고 시간 복잡도는 O(n)로 풀라고 나와있다.
홀수 번째 노드들을 각각 연결해나가면서, 짝수 번째 노드들도 연결한다.
마지막에 짝수 번째의 헤드를 모든 과정이 끝나고 홀수 번째 노드 끝에 연결한다.

소스 코드

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def oddEvenList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head == None: return head
        odd = head
        even = head.next
        evenhead = even
        while even != None and even.next != None:
            odd.next = even.next
            odd = odd.next
            even.next = odd.next
            even = even.next
        odd.next = evenhead
        return head

[LeetCode] 1165. Single-Row Keyboard

saurus2 — Fri, 2 Dec 2022 03:54:26 +0900

1165. Single-Row Keyboard

Easy

There is a special keyboard with all keys in a single row.

Given a string keyboard of length 26 indicating the layout of the keyboard (indexed from 0 to 25). Initially, your finger is at index 0. To type a character, you have to move your finger to the index of the desired character. The time taken to move your finger from index i to index j is |i - j|.

You want to type a string word. Write a function to calculate how much time it takes to type it with one finger.

Example 1:

Input: keyboard = "abcdefghijklmnopqrstuvwxyz", word = "cba"
Output: 4
Explanation: The index moves from 0 to 2 to write 'c' then to 1 to write 'b' then to 0 again to write 'a'.
Total time = 2 + 1 + 1 = 4.

Example 2:

Input: keyboard = "pqrstuvwxyzabcdefghijklmno", word = "leetcode"
Output: 73

Constraints:

keyboard.length == 26
keyboard contains each English lowercase letter exactly once in some order.
1 <= word.length <= 104
word[i] is an English lowercase letter.

문제 풀이

키보드 배열과 단어하나가 주어진다.
주어진 단어를 키보드 하나하나 입력할때 주어진 키보드 배열에서 인덱스를 옮기면서 얼마나 걸리는지 구해야한다.
키보드 배열은 임의로 주어지기 때문에 딕셔너리에 인덱스와 함께 저장한다.
그리고 첫 글자는 인덱스를 바로 더하고 현재 인덱스로 저장한다.
그리고 다음 인덱스부터 현재 위치에서 다음 알파벳의 위치의 거리 차이를 계산하여 정답에 더한다.
이때도 마찬가지로 현재 위치를 갱신한다.

소스 코드

class Solution:
    def calculateTime(self, keyboard: str, word: str) -> int:
        ans = 0
        d = dict()
        cur = 0
        for i, k in enumerate(keyboard):
            d[k] = i
        ans += d[word[0]]
        cur = d[word[0]]
        for i in range(1, len(word)):
            ans += abs(cur - d[word[i]])
            cur = d[word[i]]
        return ans

[LeetCode] 1099. Two Sum Less Than K

saurus2 — Fri, 2 Dec 2022 03:38:15 +0900

1099. Two Sum Less Than K

Easy

Given an array nums of integers and integer k, return the maximum sum such that there exists i < j with nums[i] + nums[j] = sum and sum < k. If no i, j exist satisfying this equation, return -1.

Example 1:

Input: nums = [34,23,1,24,75,33,54,8], k = 60
Output: 58
Explanation: We can use 34 and 24 to sum 58 which is less than 60.

Example 2:

Input: nums = [10,20,30], k = 15
Output: -1
Explanation: In this case it is not possible to get a pair sum less that 15.

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 1000
1 <= k <= 2000

문제 풀이

주어진 배열에서 숫자 두개를 더한 값이 K보다 작을때 가장 큰 값을 구해야한다.

부루트 포스

배열을 각각 더해보면서 K 값보다 작을때 최대값을 저장한다.
정렬 + 투포인터
배열을 정렬하고 배열의 양끝에서 인덱스를 옮기면서 값을 계산한다.
만약 두개의 숫자를 더한 값이 K보다 작다면 최대값을 구하고 왼쪽 포인터를 하나 올린다.
정렬이 되어있기 때문에 왼쪽 포인터를 오른쪽으로 옮기면 숫자가 커져서 합도 증가할 것이다.

바이너리 서치

투포인터와 비슷한 로직이다.
배열을 먼저 정렬한다.
가장 작은 값부터 진행하는데, 값을 K에서 뺀것을 Lower boundery 바이너리 서치로 위치를 검색한다.
bisect_left를 사용하면되는데, K에서 현재 위치의 값을 뺀것에 가장 가까우면서 왼쪽 위치의 값을 찾는다, 즉, K - nums[i] 보다 작은 값을 찾게 된다.
(bisect_right는 반대이다.)
만약 j 가 i 보다 크면 최대값을 구해준다.
(이진 탐색의 시작 위치를 정해주었어도 i 보다 작은 인덱스를 결과로 가져올 수 있기 때문이다.)

카운팅 소트

숫자의 최대값인 1000까지 빈 배열을 만든다.
이 배열은 숫자의 개수를 저장할 배열이다.
1부터 최대 값인 1000까지 진행을 하는데 투포인터처럼 양끝에서 시작한다.
만일 두개의 값의 합이 K보다 같거나 크면 오른쪽 포인터를 하나 줄여준다.
혹은 오른쪽 포인터의 값이 배열에 존재하지 않으면 오른쪽 포인터를 하나 줄여준다.
만일 두 값의 합이 K보다 작을때, l이 r보다 작고 배열에 l 숫자가 존재하면 맥스 값을 설정한다.
반대로 l 과 r 값이 같을때는 l의 개수가 1개 초과이어야한다.

소스 코드

브루트 포스 O(N^2)

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        m = -1
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                t = nums[i] + nums[j]
                if t < k:
                    m = max(m, t)
        return m

정렬 + 투포인터 O(NlogN)

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        nums.sort()
        m = -1
        l, r = 0, len(nums) - 1
        while l < r:
            total = nums[l] + nums[r]
            if total < k:
                m = max(m, total)
                l += 1
            else:
                r -= 1
        return m

바이너리 서치 O(NlogN)

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        m = -1
        nums.sort()
        for i in range(len(nums)):
        # nums은 배열, k - nums[i]는 찾을 값, i + 1은 시작점
            j = bisect_left(nums, k - nums[i], i + 1) - 1
            if j > i:
                m = max(m, nums[i] + nums[j])
        return m

카운팅 소트 O(N + M) M은 입력으로 들어온 배열의 길이이다.

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        m = -1
        cnt = [0] * 1001
        for num in nums:
            cnt[num] += 1
        l, r = 1, 1000
        while l <= r:
            if l + r >= k or cnt[r] == 0:
                r -= 1
            else:
                if l < r and cnt[l] > 0 or l == r and cnt[l] > 1:
                    m = max(m, l + r)
                l += 1
        return m