+
+
+
+ Posts by difficulty:
+
+
+ - {title} - → -
-- {body} -
- -
+
+
+
+
+
+
diff --git a/src/components/analytics/CounterAnalytics.astro b/src/components/analytics/CounterAnalytics.astro
new file mode 100644
index 00000000..a9d20727
--- /dev/null
+++ b/src/components/analytics/CounterAnalytics.astro
@@ -0,0 +1,15 @@
+---
+interface Props {
+ projectId: string
+ utcOffset: number
+}
+
+const { projectId, utcOffset } = Astro.props
+---
+
+
diff --git a/src/components/analytics/GoogleAnalytics.astro b/src/components/analytics/GoogleAnalytics.astro
new file mode 100644
index 00000000..8b8b0bed
--- /dev/null
+++ b/src/components/analytics/GoogleAnalytics.astro
@@ -0,0 +1,24 @@
+---
+interface Props {
+ projectId: string
+}
+
+const { projectId } = Astro.props
+---
+
+
+
+
diff --git a/src/components/analytics/Swetrix.astro b/src/components/analytics/Swetrix.astro
new file mode 100644
index 00000000..74d0b1c0
--- /dev/null
+++ b/src/components/analytics/Swetrix.astro
@@ -0,0 +1,15 @@
+---
+interface Props {
+ projectId: string
+}
+
+const { projectId } = Astro.props
+---
+
+
+
diff --git a/src/components/post/PostHeader.astro b/src/components/post/PostHeader.astro
new file mode 100644
index 00000000..dad33c76
--- /dev/null
+++ b/src/components/post/PostHeader.astro
@@ -0,0 +1,54 @@
+---
+import type { CollectionEntry } from 'astro:content'
+import kebabCase from 'lodash.kebabcase'
+
+import LeetCodeDifficulty from '@/components/LeetCodeDifficulty.astro'
+import siteConfig from '@/configs/site'
+import { formatDate } from '@/utils/date'
+
+type Props = CollectionEntry<'leetcode-solutions'>['data']
+
+const { author: siteAuthor } = siteConfig
+const { title, author, pubDate, tags = [], difficulty } = Astro.props
+
+const formattedDate = formatDate(pubDate)
+---
+
+
+
+
+
+ {
+ Object.keys(themes).map((themeId: string) => (
+
+
+
+
+
+
diff --git a/src/components/post/PostItem.astro b/src/components/post/PostItem.astro
new file mode 100644
index 00000000..24088da8
--- /dev/null
+++ b/src/components/post/PostItem.astro
@@ -0,0 +1,36 @@
+---
+import Icon from '@/components/Icon.astro'
+import LeetCodeDifficulty from '@/components/LeetCodeDifficulty.astro'
+
+export interface Props {
+ title: string
+ href: string
+ difficulty: string
+}
+
+const { title, href, difficulty } = Astro.props
+---
+
+{title}
+
+
+ {difficulty}
+
+
+
+ {
+ tags.map((tag) => (
+
+
+ {tag}
+
+
+ ))
+ }
+
+
+ 
+
+
+ {author}
+ Posted on {formattedDate}
+
+
+
+
+
+ {title}
+
+ {
+ posts.map((p) => (
+
diff --git a/src/configs/site.ts b/src/configs/site.ts
new file mode 100644
index 00000000..efc33aa2
--- /dev/null
+++ b/src/configs/site.ts
@@ -0,0 +1,53 @@
+const env = process.env
+
+export default {
+ title: 'LeetCode Blog',
+ description: 'Solutions for LeetCode problems - Written by ansidev',
+ author: {
+ name: 'Le Minh Tri',
+ nickname: 'ansidev',
+ email: 'ansidev@gmail.com',
+ avatar: '/ansidev.png',
+ homepage: 'https://ansidev.xyz',
+ github: 'https://github.com/ansidev',
+ twitter: 'https://twitter.com/ansidev',
+ telegram: 'https://t.me/ansidev',
+ reddit: 'https://reddit.com/u/ansidev',
+ },
+ favicon: '/favicon.ico',
+ faviconMimeType: 'image/x-icon',
+ themes: {
+ 'leetcode-light': {
+ name: 'LeetCode Light',
+ icon: 'bi:sun-fill',
+ },
+ 'leetcode-dark': {
+ name: 'LeetCode Dark',
+ icon: 'bi:moon-fill',
+ },
+ google: {
+ name: 'Google',
+ icon: 'bi:sun-fill',
+ },
+ microsoft: {
+ name: 'Microsoft',
+ icon: 'bi:sun-fill',
+ },
+ twitter: {
+ name: 'Twitter',
+ icon: 'bi:sun-fill',
+ },
+ },
+ plugins: {
+ counterAnalytics: {
+ projectId: env.COUNTER_ANALYTICS_ID,
+ utcOffset: 7,
+ },
+ googleAnalytics: {
+ projectId: env.GA_ID,
+ },
+ swetrix: {
+ projectId: env.SWETRIX_ID,
+ },
+ }
+}
diff --git a/src/content/config.ts b/src/content/config.ts
new file mode 100644
index 00000000..71663c22
--- /dev/null
+++ b/src/content/config.ts
@@ -0,0 +1,16 @@
+import { defineCollection, z } from 'astro:content'
+
+const leetcodeSolutionCollection = defineCollection({
+ schema: z.object({
+ title: z.string(),
+ keywords: z.array(z.string()),
+ author: z.string(),
+ pubDate: z.string(),
+ difficulty: z.string(),
+ tags: z.array(z.string()),
+ }),
+})
+
+export const collections = {
+ 'leetcode-solutions': leetcodeSolutionCollection,
+}
diff --git a/src/content/leetcode-solutions/0003-longest-substring-without-repeating-characters.md b/src/content/leetcode-solutions/0003-longest-substring-without-repeating-characters.md
new file mode 100644
index 00000000..62b442b5
--- /dev/null
+++ b/src/content/leetcode-solutions/0003-longest-substring-without-repeating-characters.md
@@ -0,0 +1,120 @@
+---
+title: "3. Longest Substring Without Repeating Characters"
+slug: "0003-longest-substring-without-repeating-characters"
+keywords:
+- "longest"
+- "substring"
+- "without"
+- "repeating"
+- "characters"
+author: "ansidev"
+pubDate: "2022-10-31T19:46:49+07:00"
+difficulty: "Medium"
+tags:
+- "Hash Table"
+- "String"
+- "Sliding Window"
+---
+## Problem
+
+Given a string `s`, find the length of the **longest substring** 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.
+
+## Analysis
+
+| Abbreviation | Stands for |
+| ------------ | ------------------------------------------------ |
+| `CSWRC` | `current substring without repeating characters` |
+| `LSWRC` | `longest substring without repeating characters` |
+
+- If `s` is an empty string, the LSWRC is `0`.
+- If the length of string `s` is 1, the LSWRC is `1`.
+
+## Approaches
+
+### Approach 1
+
+#### Approach
+
+- If the length of string `s` is greater than 1, because we need to determine the LSWRC, while iterating over the string, we have to check whether the character at a specific index is repeating or not. We can consider using a hashmap.
+
+ - Assume the `LSWRC` is `s[0]`.
+
+ | Initial value | Note |
+ | --------------------- | ---------------------------------------------------------------------- |
+ | `left = 0` | Left index of the LSWRC |
+ | `result = 1` | Length of the LSWRC |
+ | `lastIndex = { a=0 }` | This hashmap saves the last index of a specific character of the array |
+
+ - Start traversing the array from index `1`. For each step:
+ - Check whether the current character is repeating: `lastIndex` has the key `s[right]`.
+ - If yes, update `left = lastIndex[s[right]] + 1` if `left < lastIndex[s[right]] + 1`.
+ - Update the last index of `s[right]` to the current index.
+ - Calculate the new length of the `CSWRC`. (`right - left + 1`).
+ - Update `result` if it is less than the new length of the `CSWRC`.
+ - Finally, return `result`. It is the `LSWRC`.
+
+#### Solutions
+
+```go
+func lengthOfLongestSubstring(s string) int {
+ l := len(s)
+ if l == 0 || l == 1 {
+ return l
+ }
+
+ result, left := 1, 0
+ lastIndex := map[byte]int{}
+ lastIndex[s[0]] = 0
+ for right := 1; right < l; right++ {
+ if v, ok := lastIndex[s[right]]; ok {
+ if left < v+1 {
+ left = v + 1
+ }
+ }
+ lastIndex[s[right]] = right
+ if result < right-left+1 {
+ result = right - left + 1
+ }
+ }
+
+ return result
+}
+```
+
+#### Complexity
+
+- Time complexity: `O(n)` because we just traverse the string once.
+- Space complexity:
+ - We use four extra variables `l`, `result`, `left`, `right`, no matter what value will, they will take fixed bytes. So the space complexity is `O(1)`.
+ - The space complexity of the map `lastIndex` is `O(n)`.
+ - So the final space complexity is `O(n)`.
diff --git a/src/content/leetcode-solutions/0008-string-to-integer-atoi.md b/src/content/leetcode-solutions/0008-string-to-integer-atoi.md
new file mode 100644
index 00000000..f850c048
--- /dev/null
+++ b/src/content/leetcode-solutions/0008-string-to-integer-atoi.md
@@ -0,0 +1,179 @@
+---
+title: "8. String to Integer (atoi)"
+slug: "0008-string-to-integer-atoi"
+keywords:
+- "string"
+- "to"
+- "integer"
+- "atoi"
+author: "ansidev"
+pubDate: "2022-10-26T13:11:00+07:00"
+difficulty: "Medium"
+tags:
+- "String"
+---
+## Problem
+
+Implement the `myAtoi(string s)` function, which converts a string to a 32-bit signed integer (similar to C/C++'s `atoi` function).
+
+The algorithm for `myAtoi(string s)` is as follows:
+
+1. Read in and ignore any leading whitespace.
+2. Check if the next character (if not already at the end of the string) is `'-'` or `'+'`. Read this character in if it is either. This determines if the final result is negative or positive respectively. Assume the result is positive if neither is present.
+3. Read in next the characters until the next non-digit character or the end of the input is reached. The rest of the string is ignored.
+4. Convert these digits into an integer (i.e. `"123" -> 123`, `"0032" -> 32`). If no digits were read, then the integer is 0. Change the sign as necessary (from step 2).
+5. If the integer is out of the 32-bit signed integer range [-231, 231 - 1], then clamp the integer so that it remains in the range. Specifically, integers less than -231 should be clamped to -231, and integers greater than 231-1 should be clamped to 231-1.
+Return the integer as the final result.
+
+**Note:**
+
+- Only the space character `' '` is considered a whitespace character.
+- **Do not ignore** any characters other than the leading whitespace or the rest of the string after the digits.
+
+**Example 1:**
+
+```
+Input: s = "42"
+Output: 42
+Explanation: The underlined characters are what is read in, the caret is the current reader position.
+Step 1: "42" (no characters read because there is no leading whitespace)
+ ^
+Step 2: "42" (no characters read because there is neither a `'-'` nor `'+'`)
+ ^
+Step 3: "42" ("42" is read in)
+ ^
+The parsed integer is 42.
+Since 42 is in the range [-2^31, 2^31 - 1], the final result is 42.
+```
+
+**Example 2:**
+
+```
+Input: s = " -42"
+Output: -42
+Explanation:
+Step 1: " -42" (leading whitespace is read and ignored)
+ ^
+Step 2: " -42" (`'-'` is read, so the result should be negative)
+ ^
+Step 3: " -42" ("42" is read in)
+ ^
+The parsed integer is -42.
+Since -42 is in the range [-2^31, 2^31 - 1], the final result is -42.
+```
+
+**Example 3:**
+
+```
+Input: s = "4193 with words"
+Output: 4193
+Explanation:
+Step 1: "4193 with words" (no characters read because there is no leading whitespace)
+ ^
+Step 2: "4193 with words" (no characters read because there is neither a `'-'` nor `'+'`)
+ ^
+Step 3: "4193 with words" ("4193" is read in; reading stops because the next character is a non-digit)
+ ^
+The parsed integer is 4193.
+Since 4193 is in the range [-2^31, 2^31 - 1], the final result is 4193.
+```
+
+**Constraints:**
+
+- `0 <= s.length <= 200`.
+- `s` consists of English letters (lower-case and upper-case), digits (`0-9`), `' '`, `'+'`, `'-'`, and `'.'`.
+
+## Analysis
+
+I don't have any special analysis since the problem is so clearly.
+
+## Approaches
+
+### Approach 1
+
+#### Approach
+
+1. Check whether the input is null (depends on programming language) or empty. If it is, return `0`.
+2. Use a pointer `i` to traverse the input string, always remember checking whether i less than length of `s`.
+ - While `s[i]` is a whitespace, keep increasing i by 1.
+ - Check whether the next character (`s[i]`) is one of `-`, `+`, or digit (`0-9`):
+ - If not, return `0`.
+ - Otherwise, check whether `s[i]` is one of `-` or `+`, save the result to a boolean variable and increase i by 1.
+ - Note that if `s[i]` is not one of `-` or `+`, this means that it is a digit, and `i` will not be increased.
+ - Check whether the current character is a sign, if it is, return `0` because it is an invalid input.
+ - Create new 64 bit float number `n` to save the result.
+ - While `s[i]` is a digit, `n = n x 10 + integer value of s[i]`, then increasing `i` by `1`.
+ - If the sign is `-`, `n = -n`.
+ - Check the range of `n`:
+ - If n < -231, return -231.
+ - If n > 231-1, return 231-1.
+ - Otherwise, convert n to integer and return.
+
+- Notes: `MinInt32 = -1 << 31` (-231) and `MaxInt32 = 1<<31 - 1` (231-1).
+
+#### Solutions
+
+```go
+func myAtoi(s string) int {
+ l := len(s)
+ if l == 0 {
+ return 0
+ }
+
+ i := 0
+ for i < l && s[i] == ' ' {
+ i++
+ }
+
+ if i < l && s[i] != '+' &&
+ s[i] != '-' &&
+ s[i] != '0' &&
+ s[i] != '1' &&
+ s[i] != '2' &&
+ s[i] != '3' &&
+ s[i] != '4' &&
+ s[i] != '5' &&
+ s[i] != '6' &&
+ s[i] != '7' &&
+ s[i] != '8' &&
+ s[i] != '9' {
+ return 0
+ }
+
+ isNegative := false
+ if i < l && s[i] == '-' {
+ isNegative = true
+ i++
+ } else if i < l && s[i] == '+' {
+ i++
+ }
+
+ if i < l && (s[i] == '+' || s[i] == '-') {
+ return 0
+ }
+
+ var n float64 = 0
+ for i < l && s[i] >= '0' && s[i] <= '9' {
+ n = n*10 + float64(s[i]-'0')
+ i++
+ }
+
+ if isNegative {
+ n = -n
+ }
+
+ if n < math.MinInt32 {
+ return math.MinInt32
+ }
+ if n > math.MaxInt32 {
+ return math.MaxInt32
+ }
+
+ return int(n)
+}
+```
+
+#### Complexity
+
+- Time complexity: `O(n)` because we just traverse the string once.
+- Space complexity: We use three extra variable `l`, `isNegative`, `n`, no matter what value will, they will take a fixed bytes. So the space complexity is `O(1)`.
diff --git a/src/content/leetcode-solutions/0053-maximum-subarray.md b/src/content/leetcode-solutions/0053-maximum-subarray.md
new file mode 100644
index 00000000..df43a86b
--- /dev/null
+++ b/src/content/leetcode-solutions/0053-maximum-subarray.md
@@ -0,0 +1,106 @@
+---
+title: "53. Maximum Subarray"
+slug: "0053-maximum-subarray"
+keywords:
+- "maximum"
+- "subarray"
+- "kadane"
+author: "ansidev"
+pubDate: "2022-10-26T13:11:00+07:00"
+difficulty: "Medium"
+tags:
+- "Array"
+- "Divide and Conquer"
+- "Dynamic Programming"
+---
+## Problem
+
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return `its sum`.
+
+A `subarray` is a `contiguous` part of an array.
+
+**Example 1:**
+
+```
+Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+```
+
+**Example 2:**
+
+```
+Input: nums = [1]
+Output: 1
+```
+
+**Example 3:**
+
+```
+Input: nums = [5,4,-1,7,8]
+Output: 23
+```
+
+**Constraints:**
+
+- 1 <= nums.length <= 105
+- -104 <= nums[i] <= 104
+
+**Follow up:** If you have figured out the `O(n)` solution, try coding another solution using the **divide and conquer** approach, which is more subtle.
+
+## Analysis
+
+## Approaches
+
+### Approach 1
+
+#### Approach
+
+Technique: Dynamic Programming
+
+Original author: [Kadane](https://www.cmu.edu/dietrich/statistics-datascience/people/faculty/joseph-kadane.html).
+
+Assume we have `dp[i]`: maximum sum of subarray that ends at index `i`.
+
+`dp[i] = max(dp[i - 1] + nums[i], nums[i])`
+
+Initial state `dp[0] = nums[0]`.
+
+From the above formula, we just need to access its previous element at each step, so we can use 2 variables:
+
+- `currentMaxSum`: maximum sum of subarray that ends at the current index `i`.
+ - `currentMaxSum = max(currentMaxSum + nums[i], nums[i]`.
+- `globalSum`: global maximum subarray sum
+ - `globalSum = max(currentMaxSum, globalSum)`.
+
+#### Solutions
+
+```go
+func maxSubArray(nums []int) int {
+ currentMaxSum := nums[0]
+ globalSum := nums[0]
+
+ for _, x := range nums[1:] {
+ if currentMaxSum+x > x {
+ currentMaxSum += x
+ } else {
+ currentMaxSum = x
+ }
+
+ if globalSum < currentMaxSum {
+ globalSum = currentMaxSum
+ }
+ }
+
+ return globalSum
+}
+```
+
+#### Complexity
+
+- **Time Complexity**: `O(n)` because we just iterate over the array once.
+- **Space Complexity**: `O(1)`. We just use 2 integer variables for extra spaces.
+
+## References
+
+- https://en.wikipedia.org/wiki/Maximum_subarray_problem
diff --git a/src/content/leetcode-solutions/0231-power-of-two.md b/src/content/leetcode-solutions/0231-power-of-two.md
new file mode 100644
index 00000000..f178f245
--- /dev/null
+++ b/src/content/leetcode-solutions/0231-power-of-two.md
@@ -0,0 +1,152 @@
+---
+title: "231. Power of Two"
+slug: "0231-power-of-two"
+keywords:
+- "power of two"
+author: "ansidev"
+pubDate: "2022-10-27T15:23:12+07:00"
+difficulty: "Easy"
+tags:
+- "Math"
+- "Bit Manipulation"
+- "Recursion"
+---
+## Problem
+
+Given an integer `n`, return `true` *if it is a power of two. Otherwise, return* `false`.
+
+An integer `n` is a power of two, if there exists an integer `x` such that n == 2x.
+
+**Example 1:**
+
+```
+Input: n = 1
+Output: true
+Explanation: 20 = 1
+```
+**Example 2:**
+
+```
+Input: n = 16
+Output: true
+Explanation: 24 = 16
+```
+**Example 3:**
+
+```
+Input: n = 3
+Output: false
+```
+
+**Constraints:**
+
+- -231 <= n <= 231 - 1.
+
+**Follow up:** Could you solve it without loops/recursion?
+
+## Analysis
+
+1. If `n` is a power of two:
+
+++ +`=>` **If `n < 0`, `n` is not a power of two**. + +2. If `n` is a power of two: + +The binary form of everyn = 2i(`i ≥ 0`) +≥ 20 = 1+
2i (`i` is a non-negative number):
+
+++ +2.1. If `i = 0`: +2010=110=12+ +2110=210=102+ +2210=410=1002+ +2310=810=10002+ +...+ +2i10=100...002(only one 1-digit at the first position and followed by total `i` 0-digit numbers) + |__i__| +
+n = 20 = 1 > 0
+n & (n-1) = 1 & 0 = 0
+
+
+
+2.2. If `i > 0`:
+
+The binary form of every 2i - 1:
+
+++ +For `i > 0`, we have: + +2110 - 1=110=012+ +2210 - 1=310=0112+ +2310 - 1=710=01112+ +...+ +2i10 - 1=011...112(total `i` 1-digit numbers) + |__i__| +
+n - 1 =+ +``` +If n is a power of two: n & (n-1) = 0. +``` + +3. If `n` is not an power of two, we have: +2i10 - 1≥ 0 +n & (n-1) =2i10&2i10 - 1=100...002&011...112= 0 + |__i__| |__i__| +
++ +- `j ≥ 2` => `j-1 ≥ 1`. So `x` has at least one 1-digit number => `x > 0`. + +``` +If n is not a power of two: n & (n-1) > 0. +``` + +``` +As result, n is a power of two if and only if n > 0 and n & (n-1) = 0. +``` +## Approaches + +### Approach 1 + +#### Approach + +- `n` is a power of two if and only if `n > 0` and `n & (n-1) = 0`. + +#### Solutions + +```go +func isPowerOfTwo(n int) bool { + return n > 0 && n&(n-1) == 0 +} +``` + +#### Complexity + +- **Time Complexity**: `O(1)`. diff --git a/src/content/leetcode-solutions/0628-maximum-product-of-three-numbers.md b/src/content/leetcode-solutions/0628-maximum-product-of-three-numbers.md new file mode 100644 index 00000000..12bb03c0 --- /dev/null +++ b/src/content/leetcode-solutions/0628-maximum-product-of-three-numbers.md @@ -0,0 +1,142 @@ +--- +title: "628. Maximum Product of Three Numbers" +slug: "0628-maximum-product-of-three-numbers" +keywords: +- "maximum" +- "product" +- "of" +- "three" +- "numbers" +author: "ansidev" +pubDate: "2022-11-18T08:58:46+07:00" +difficulty: "Easy" +tags: +- "Array" +- "Math" +- "Sorting" +--- +## Problem + +Given an integer array `nums`, *find three numbers whose product is maximum and return the maximum product*. + +**Example 1:** + +``` +Input: nums = [1,2,3] +Output: 6 +``` + +**Example 2:** + +``` +Input: nums = [1,2,3,4] +Output: 24 +``` + +**Example 3:** + +``` +Input: nums = [-1,-2,-3] +Output: -6 + ``` + +**Constraints:** + +- `3 <= nums.length <= 104`. +- `-1000 <= nums[i] <= 1000`. + +## Analysis + +If length of `nums` is 3, maximum product is `nums[0] x nums[1] x nums[2]`. + +## Approaches + +### Approach 1 + +``` +Notes: +- l: length of nums. +- nums[i:j]: sub array of nums from index i to j (includes nums[i], nums[j]). +``` +#### Approach + +- If length of `nums` is 3, maximum product is `nums[0] x nums[1] x nums[2]`. +- If length of `nums` is greater than 3: + - Step 1: Sort the input array (ascending). + - For the sorted array, there are following possible cases: + - Case 1: All element are positive numbers. + - `maxProduct = nums[l-3] x nums[l-2] x nums[l-1]`. + - Case 2: All element are negative numbers. + - Product of two random elements will be a positive number. + - Product of three random elements will be a negative number. + - If `n1 > 0`, `n2 < n3 < 0`: `n1 x n2 < n1 x n3 < 0`. + - If `m1 < 0`, `0 < m2 < n3`: `m1 x m3 < m1 x m2 < 0`. + - So to find the maximum product of three numbers in this case, we need to find two negative numbers `a`, `b` that `a x b` has max value (note that `a x b > 0`), then find the third number which is the maximum value of remaining ones. + - `nums[0]` & `nums[1]` are two smallest negative numbers. So their product will be the maximum product of two numbers. `nums[l-1]` is the maximum one of [`nums[2]`, `nums[3]`,..., `nums[l-1]`]. + - Finally, the maximum product of three numbers in this case is 👉 `nums[0] x nums[1] x nums[l-1]`. + - Other cases. + - `nums` has at least 4 elements. + - If `nums` contains zero: + - If `nums[0] = 0`, all remaining elements are positive numbers (similar to case 1) + - 👉 `maxProduct = nums[l-3] x nums[l-2] x nums[l-1]`. + - If `nums[l-1] = 0`, all remaining elements are negative numbers (similar to case 2) + - `maxProduct` of three numbers of sub array `nums[0:l-2]` is a negative number, it less than product of `nums[l-1]` (`= 0`) and two random numbers of sub array `nums[0:l-2]`. So in this case, we can pick three numbers `nums[l-3]`, `nums[l-2]`, `nums[l-1]`. + - 👉 `maxProduct = nums[l-3] x nums[l-2] x nums[l-1] = 0`. + - If `nums[i] = 0` (`0 < i < l-1`), because `nums` has at least 4 elements, so there are possible cases: + - `nums` has at least there positive numbers, similar to case 1. + - `nums` has two positive numbers: + - If `l = 4`: + - `nums` = [`nums[0]`, `0`, `num[2]`, `nums[3]`]. + - `nums[0] x nums[2] x nums[3] < 0 x num[2] x nums[3] = 0`. + - 👉 `maxProduct` must contains zero so `maxProduct = 0 = nums[l-3] x nums[l-2] x nums[l-1]` + - If `l > 4`: + - `nums` = [`nums[0]`, `nums[1]`, ..., `nums[l-4]` ,`0`, `num[l-2]`, `nums[l-1]`]. + - If one of three numbers of `maxProduct` is zero, `maxProduct = 0`. + - Otherwise, if two of three numbers of `maxProduct` is `num[l-2]`, `nums[l-1]`, `maxProduct < 0`. + - Otherwise, two of three numbers of `maxProduct` is negative numbers, max product of two negative numbers of sub array `nums[0:l-4]` is `nums[0] x nums[1] > 0`. + - `maxProduct = nums[0] x nums[1] x nums[l-1] > 0` + - 👉 `maxProduct = nums[0] x nums[1] x nums[l-1] > 0` + - 👉 `maxProduct = nums[0] x nums[1] x nums[l-1]` + - `nums` has one positive numbers: + - `nums` = [`nums[0]`, `nums[1]`, ..., `nums[l-3]` ,`0`, `nums[l-1]`]. + - We have cases: + - `maxProduct` contains zero: `0 x nums[i] x nums[j] = 0` + - `maxProduct` does not contain zero: + - `nums[i] x nums[j] x nums[k] < 0` (`i < j < k < 0`) + - `nums[i] x nums[j] x nums[l-1] > 0` (`i < j < 0`) + - So `maxProduct` is product of two negative numbers and one positive number (`nums[l-1]`) + - 👉 `maxProduct = max(nums[j] x num[j]) x nums[l-1] = nums[0] x nums[1] x nums[l-1]`. + - The maximum product of three numbers in every cases (`l > 3`) is one of two: + - `nums[0] x nums[1] x nums[l-1]` + - `nums[l-3] x nums[l-2] x nums[l-1]` + - Conclusion, 👉 `maxProduct = max(nums[0] x nums[1] x nums[l-1], nums[l-3] x nums[l-2] x nums[l-1])`. + +#### Solutions + +```go +import "sort" + +func maximumProduct(nums []int) int { + l := len(nums) + + if l == 3 { + return nums[0] * nums[1] * nums[2] + } + + sort.Ints(nums) + + return max(nums[0]*nums[1]*nums[l-1], nums[l-3]*nums[l-2]*nums[l-1]) +} + +func max(x int, y int) int { + if x > y { + return x + } + + return y +} +``` + +#### Complexity + +- **Time Complexity**: Time complexity of the sort algorithm. diff --git a/src/content/leetcode-solutions/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.md b/src/content/leetcode-solutions/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.md new file mode 100644 index 00000000..70efb523 --- /dev/null +++ b/src/content/leetcode-solutions/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.md @@ -0,0 +1,119 @@ +--- +title: "2400. Number of Ways to Reach a Position After Exactly k Steps" +slug: "2400-number-of-ways-to-reach-a-position-after-exactly-k-steps" +keywords: +- "number" +- "of" +- "ways" +- "to" +- "reach" +- "a" +- "position" +- "after" +- "exactly" +- "k" +- "steps" +author: "ansidev" +pubDate: "2022-10-24T23:49:00+07:00" +difficulty: "Medium" +tags: +- "Math" +- "Dynamic Programming" +- "Combinatorics" +--- +## Problem + +You are given two **positive** integers `startPos` and `endPos`. Initially, you are standing at position startPos on an **infinite** number line. With one step, you can move either one position to the left, or one position to the right. + +Given a positive integer `k`, return the number of **different** ways to reach the position `endPos` starting from `startPos`, such that you perform **exactly** `k` steps. Since the answer may be very large, return it **modulo**n10=[0....0][1....1][0....0]2(i ≥ 0, j ≥ 2, k ≥ 1) + |__i__| |__j__| |__k__| + +(n-1)10=[0....0][1....1]0[1....1]2+ |__i__| |_j-1_| |__k__| + +x =n10 & (n-1)10=[0....0][1.....][0....0]2+ |__i__| |_j-1_| |_k+1_| +
109 + 7.
+
+Two ways are considered different if the order of the steps made is not exactly the same.
+
+**Note** that the number line includes negative integers.
+
+**Example 1:**
+
+```
+Input: startPos = 1, endPos = 2, k = 3
+Output: 3
+Explanation: We can reach position 2 from 1 in exactly 3 steps in three ways:
+- 1 -> 2 -> 3 -> 2.
+- 1 -> 2 -> 1 -> 2.
+- 1 -> 0 -> 1 -> 2.
+It can be proven that no other way is possible, so we return 3.
+```
+**Example 2:**
+
+```
+Input: startPos = 2, endPos = 5, k = 10
+Output: 0
+Explanation: It is impossible to reach position 5 from position 2 in exactly 10 steps.
+```
+
+**Constraints:**
+
+- `1 <= startPos, endPos, k <= 1000`
+
+## Analysis
+
+Assuming `d` is the **distance** between `startPos` and `endPos` => `d = abs(startPos - endPos)`.
+
+- `1 <= startPos <= 1000`
+- `-1000 <= -endPos <= -1`
+
+=> `-999 <= startPos - endPos <= 999`
+
+=> `0 <= d = abs(startPos - endPos) <= 999`
+
+For `k` is the **numbers of steps** and `d` is the **distance** between `startPos` and `endPos`, the number of ways is:
+- `dfs(k, d) = dfs(k-1, abs(d-1)) + dfs(k-1, d+1)`.
+
+For k steps, the maximum distance is k.
+- **d > k**: `dfs(k, d) = 0`.
+- **d = k**: `dfs(k, d) = dfs(k, k) = 1`.
+- **d = 0**: `dfs(k, 0) = dfs(k-1, 1) + dfs(k-1, 1) = 2 x dfs(k-1, 1)`.
+
+
+Example values:
+- `dfs(0,0) = 1`.
+- `dfs(1, 0) = 2 x dfs(0, 1) = 0`.
+- `dfs(1, 1) = 1`.
+- `dfs(2, 0) = 2 x dfs(1, 1) = 2 x 1 = 2`.
+- `dfs(2, 1) = dfs(1, 0) + dfs(1, 2) = 0 + 0 = 0`.
+- `dfs(2, 2) = 1`.
+
+## Approaches
+
+### Approach 1
+
+#### Approach
+
+- From the above analysis, we can use the bottom-up approach to calculate the next values of the `dfs` function from each prior values. Then, we can get the number of ways.
+
+#### Solutions
+
+```go
+func numberOfWays(startPos int, endPos int, k int) int {
+ const mod = 1e9 + 7
+ dp := [1001][1001]int{}
+ for i := 1; i <= 1000; i++ {
+ dp[i][i] = 1
+ for j := 0; j < i; j++ {
+ dp[i][j] = (dp[i-1][abs(j-1)] + dp[i-1][j+1]) % mod
+ }
+ }
+
+ return dp[k][abs(startPos-endPos)]
+}
+
+func abs(x int) int {
+ if x >= 0 {
+ return x
+ }
+
+ return -x
+}
+```
+
+## References
+- dfs: [[deep-first-search|Deep First Search]]
diff --git a/src/env.d.ts b/src/env.d.ts
index f964fe0c..6811d7c2 100644
--- a/src/env.d.ts
+++ b/src/env.d.ts
@@ -1 +1,3 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// {title}
+{description}
+ Go Home +Welcome to Astro
-
- To get started, open the directory src/pages in your project.
-
- Code Challenge: Tweak the "Welcome to Astro" message above.
-
-
-
+
+ Easy
+
+
+ Medium
+
+
+ Hard
+
+
+
+
+