add leetcode posts

Author: benthecoder

posts/250325.md

@@ -0,0 +1,37 @@
+---
+title: 'leetcode @ class'
+tags: 'journal'
+date: 'Mar 25, 2025'
+---
+
+in between listening to the lectures i was leetcoding. my deep learning class taught about cnn. cnn is a type of neural network architecture that can learn spatial patterns through heirarchical feature extractions, mimicking human visual processing.
+
+core components:
+
+- convolutional layer: apply filters to detect features (edge -> shape -> object)
+- filters/kernels: matrices (3x3 or 5x5) that slide across images
+- output dim: (input size - filter size) / stride + 1.
+- padding. add border elements to preserve spatial dimensions
+  - optimal padding: (filter size - 1) / 2
+
+example:
+
+Padding = (filter size - 1) / 2
+For 3x3 filter: Padding = (3 - 1) / 2 = 1
+
+Input: 5x5 image
+Add 1-pixel border around image → 7x7
+Filter: 3x3
+Output size = (7 - 3) / 1 + 1 = 5x5
+
+this helps maintain output size to match input size.
+
+what do 1x1 filters do?
+
+- dimensionality reduction (reduce channels but preserve spatial dim)
+- computational efficiency
+
+GoogleNet/inception networks popularized this
+
+- reduce parameters
+- control network depth

posts/260325.md

@@ -0,0 +1,7 @@
+---
+title: 'leetcode everywhere'
+tags: 'journal'
+date: 'Mar 26, 2025'
+---
+
+took meeting with USF professor. i shared about my interview and my professor mentioned DP is fun. learning about DP and seeing how elegant the solutions are can be fun, but thinking about how i only have 25 min to solve a DP question is highly stress-inducing. my stomach squeezes into a knot everytime it think about it. i have not solved enough questinos to have a clear thought process. my pattern matching algorithm has not seen enough data. went to capitol one cafe to do some more leetcode. got my hair cut because the edges 'have been poking on my eye. the rest of the night was more interview prep. my life has been consumed by this interview.

posts/270325.md

@@ -0,0 +1,138 @@
+---
+title: 'dynamic programming 101'
+tags: 'journal'
+date: 'Mar 27, 2025'
+---
+
+took the time to learn the framework for dp. below are some notes from the leetcode explore for DP.
+
+characteristics of dp:
+
+- break down into **overlapping** subproblems
+- an optimal solution can be formed
+
+what dp is not:
+
+- **greedy** problems have optimal substructure, but not overlapping subproblems
+- **divide and conquer** breaks a problem into subprobelms, but they are not overlapping
+
+why it helps?
+
+- it improves time complexity compared to brute force
+- ex: fib(n) has exponential time complexity for brute force, while linear with DP, as it reuses results of subproblems raather than recalculating results for previously seen subproblems
+
+top-down vs bottom up
+
+- top down (tabulation)
+
+  - **iteration** and starts with a basecase
+  - order matters
+  - usually faster, no recursion overhead
+
+    ```py
+    # fibonacci
+    F = [0] * (n+1)
+    F[0] = 1
+    F[1] = 1
+    for i in range(2, n):
+        F[i] = F[i-1] + F[i-2]
+    ```
+
+- bottom-up (memoization)
+
+  - **recursion** and made efficient with memoization
+  - easier to write, order does not matter
+  - slower
+
+    ```py
+    memo = {}
+    def f(i):
+        if i < 2:
+            return i
+
+        if i not in memo:
+            memo[i] = f(i-1) + f(i-2)
+
+        return memo[i]
+    ```
+
+when to use it?
+
+1. problem asks for optimum value (max/min) of something
+   - min cost of doing ... , how many ways are there to ... , longest possible ...
+   - not enough by itself, could be greedy
+2. future "decisions" depends on earlier decisions
+   - ex: house robber
+     - nums = [2,7,9,3,1]
+     - greedy solution is to rob 7, but you miss out on 9 (your early decision affects future decisions)
+   - ex: longest increasing subsequence
+     - nums = [1,2,6,3,5]
+     - important decision is choosing 6 or not, this affects the future (whether you can take 3 and 5)
+
+framework
+
+1. a function that computes answer to problem for every given state
+   - ex: climbing stairs, we have dp(i) which returns number of ways to climb ith step.
+2. a recurrence relation to transition between states
+   - to climb the 10th stair, we need to climb from the 8th or 9th
+   - so # ways to climb 10th stair is # ways to climb 8th + # ways to climb 9th stair
+     - dp(i) = dp(i-1) + dp(i-2)
+   - finding this is the most difficult part
+3. base cases (to prevent it going infinitely)
+   - ask yourself: what state can you find answer without using DP?
+   - there is one way to climb first stair, and two ways to climb two stairs,
+   - base case = dp(1) = 1 and dp(2) = 2
+
+recurrence -> O(2^n)
+
+```py
+def climbStairs(self, n: int) -> int:
+    def dp(i):
+        """A function that returns the answer to the problem for a given state."""
+        # Base cases: when i is  3 there are i ways to reach the ith stair.
+        if i <= 2:
+            return i
+
+        # If i is not a base case, then use the recurrence relation.
+        return dp(i - 1) + dp(i - 2)
+
+    return dp(n)
+```
+
+add memoization -> O(n)
+
+```py
+def climbStairs(self, n: int) -> int:
+    def dp(i):
+        if i <= 2:
+            return i
+        if i not in memo:
+            # Instead of just returning dp(i - 1) + dp(i - 2), calculate it once and then
+            # store the result inside a hashmap to refer to in the future.
+            memo[i] = dp(i - 1) + dp(i - 2)
+
+        return memo[i]
+
+    memo = {}
+    return dp(n)
+```
+
+bottom up approach
+
+```py
+def climbStairs(self, n: int) -> int:
+    if n == 1:
+        return 1
+
+    # An array that represents the answer to the problem for a given state
+    dp = [0] * (n + 1)
+
+    # base case
+    dp[1] = 1
+    dp[2] = 2
+
+    for i in range(3, n + 1):
+        dp[i] = dp[i - 1] + dp[i - 2] # Recurrence relation
+
+    return dp[n]
+```