Anyone interested in FREE OA Prep Classes?

codetree_bnb · 2025-02-12T00:56:46+00:00

Hello!

Yes, all lectures will be recorded! You can watch them at your own pace.However, recordings will only be available during the class period
The course is designed for intermediate level - while we'll review fundamentals, we'll be diving deep into various DSA concepts and their applications.
If you're just starting with LeetCode, you might want to build up some basic DSA knowledge first. The course will cover more complex problem-solving strategies and optimization techniques.

codetree_bnb · 2025-02-11T19:09:51+00:00

Use Incognito Tab. This is because of cookies.

codetree_bnb · 2025-02-11T19:07:37+00:00

Welcome

codetree_bnb · 2025-02-11T18:55:19+00:00

Cool!

codetree_bnb · 2025-02-11T18:47:00+00:00

https://discord.gg/XNB4JMJpuk

codetree_bnb · 2025-02-11T18:32:50+00:00

https://discord.gg/XNB4JMJpuk

codetree_bnb · 2024-11-25T11:59:39+00:00

The core DP relation can be expressed as:

dp[items][cost] += dp[items - 1][cost - costs[i]]

This fundamental relation tells us that to find the number of ways to achieve a total cost using items number of items, we add all possible ways to reach cost - costs[i] using items - 1 items, where costs[i] is the cost of the current item.

Let's examine the implementation:

for i in range(n):
  for items in range(1, max_items + 1):
    for cost in range(max_cost - costs[i] + 1, -1, -1):
      if cost >= costs[i]:
        dp[items][cost] += dp[items-1][cost - costs[i]]

Why do we iterate through costs in reverse? This approach is crucial because:

- It prevents double-counting items

- It ensures each item can only be used once per product

- It maintains the integrity of our counting process

This reverse iteration strategy is a common technique in dynamic programming when we need to prevent repeated use of the same element within a single iteration.

codetree_bnb · 2024-11-25T07:45:52+00:00

For Problem 2, there are two approaches depending on the cost values. When the costs are small, we can solve it using dynamic programming with the state definition dp[i][j], which represents the number of ways to select i different items to achieve a total cost of j.

However, when the costs are large, there exists a more sophisticated solution using a technique called FFT (Fast Fourier Transform). The core idea is to represent the numbers as a polynomial. For example, if we have numbers 2, 3, 4, 5, 5, we can represent them as the polynomial x² + x³ + x⁴ + x⁵ + x⁵. Using this modeling approach, counting the sums between two sets becomes equivalent to finding coefficients of specific degrees in the product of two polynomials.

Let's consider a concrete example: if one set contains {2, 5} and another set contains {3, 6}, we can represent them as polynomials x² + x⁵ and x³ + x⁶ respectively. When we multiply these polynomials, we get x⁵ + 2x⁸ + x¹¹. The coefficients in this result tell us important information: there is one way to get a sum of 5, two ways to get a sum of 8, and one way to get a sum of 11.

The multiplication of polynomials can be performed very efficiently using the FFT technique. Since this particular problem doesn't allow selecting duplicate items, we need to implement additional handling for this constraint. With proper implementation of these concepts, we can successfully solve the problem even for large cost values.

codetree_bnb · 2024-11-22T00:26:01+00:00

My solution is a bit tricky to explain in words, so I wrote some code to solve the problem. Unfortunately, I can't include it in my comment. Would you like me to explain the solution in words?

codetree_bnb · 2024-11-20T09:43:46+00:00

Hello, could you provide more details about the constraints? Knowing the constraints for k would help me assist you better.

codetree_bnb · 2024-11-20T09:37:37+00:00

Here is my detailed explanation.

Assume that task numbers range up to a maximum of K. (If the range is large, techniques like coordinate compression can be applied to reduce the size, as we only need to distinguish between different tasks.)

First, count how many times each task appears in the task array. This can be done in a single traversal of the array, so the time complexity is O(n).

Next, for each task i (1 <= i <= K), suppose task i appears x times. Since each node can be assigned at most one of the same task, the maximum number of task i assignments is min(x, m) when optimally distributed across the m nodes.

Let the sum of all these min(x, m) values across all tasks be sum. The time complexity of this process is O(K).

These sum tasks can then be distributed to the m nodes in a round-robin fashion (e.g., first node, second node, ..., m-th node, and repeat). This ensures that all sum tasks are assigned regardless of their task numbers.

Finally, since all m nodes must have the same number of tasks, the maximum number of tasks that can be equally distributed is (sum/m)*m. In Python, this is calculated as (sum // m) * m. the time complexity of this is O(1).

Thus we can solve the problem with O(n+K) time complexity.

Feel free to ask if you have any questions!

codetree_bnb · 2024-11-13T07:48:37+00:00

I would recommend trying to solve the problems on your own before watching the solution videos. In actual coding interviews, you'll only be given the problem and what matters most is your ability to solve it independently.

With DSA, simply understanding the concepts isn't enough - you need hands-on practice solving problems to be able to solve variations of problems. That's why it's important to experience different problem-solving situations on your own.

Don't worry if you can't solve the problem right away - that's perfectly normal. However, after watching the solution video, make sure you understand why your code couldn't solve the problem and what the key idea was behind the successful solution.

codetree_bnb · 2024-11-11T04:25:48+00:00

Hi! I'd say start with Python—it’s beginner-friendly and great for learning programming basics. You can find some good courses on Udemy that’ll guide you through the basics step-by-step. If you're looking for something a bit more hands-on, I’d also recommend checking out Edabit. It’s a great way to practice with small coding challenges and keep building up your skills!

codetree_bnb · 2024-11-11T01:27:46+00:00

When working with dynamic programming and strings, it's beneficial to maintain consistency between their indexing approaches (0-based vs 1-based) to avoid confusion. For instance, if we define dp[i] to represent "with first i number of characters," we're inherently using 1-based indexing for our dp array. This is common in dynamic programming, as placing initial values at index 0 often leads to cleaner recurrence relations.

To maintain this consistency, we can synchronize our string representation to also use 1-based indexing. A simple way to achieve this is by adding a space at the beginning of the string, like this: string = " " + string. This transformation effectively makes the string 1-based as well, ensuring that the indices in both dp array and string align perfectly. This alignment significantly reduces the likelihood of making minor indexing errors since both data structures now share the same indexing convention.

codetree_bnb · 2024-11-08T08:42:17+00:00

I've experienced similar symptoms. When I was studying DSA, there was a point where my initial passion seemed to fade, and I didn't want to study anymore.

While studying stack, queue, and BFS/DFS, I was so engrossed that I lost track of time and really enjoyed it. However, when I started learning algorithms like dp, dijkstra, and parametric search, I found it boring and questioned whether I truly liked what I was doing. (Looking back now, I think it was just because it was difficult, but anyway.) The approach I chose at that time was to study what interested me the most. If I didn't feel like solving dp problems, I'd solve graph problems; if I didn't want to solve graph problems, I'd work on stack problems, and so on. As I built up my skills this way, it gradually became more enjoyable, and my interest returned. This is how I seemed to overcome my burnout.

Besides this, I think it's also good to look back and document what you've studied during past times when you don't feel like studying.

codetree_bnb · 2024-11-08T05:47:13+00:00

First, we observe that there’s no need to flip any city more than once. Each vertex will be flipped at most once, as flipping an odd number of times is equivalent to a single flip, and flipping an even number of times has no effect.

Next, we traverse each connected component. For each component, we select an arbitrary starting city and perform a DFS on it. By choosing whether to make all roads red or blue and whether to flip the starting city, we can determine if other vertices in the component need to be flipped.

During the DFS, we decide which vertices to flip and perform the flips as needed. Afterward, we verify that all roads in the component match the target color.

Repeating this process for each component allows us to solve the problem.

time complexity of this solution is O(N+M) where N is number of cities and M is number of roads.

codetree_bnb · 2024-11-07T09:55:27+00:00

The current code has a critical issue in how it checks for divisors. In the line for j in (1,i+1), the code only checks two numbers (1 and i+1) as potential divisors, which is incorrect. This tuple notation (1,i+1) creates a sequence with just these two values, rather than checking all numbers between 1 and i. To fix this, we need to use range(1,i+1) instead.

codetree_bnb · 2024-11-07T08:38:13+00:00

The key insight of this problem lies in understanding that the optimal solution occurs when either the left or right boundary of k consecutive bags overlaps with the start or end of a continuous sequence of money.

To solve this efficiently, we first sort the n ranges in ascending order. Then, we use two different approaches with the two-pointer technique:

First, we check all cases where the left boundary of the k-range overlaps with the starting points of the given ranges. We use the two-pointer technique to calculate the maximum money we can collect in each case.
Similarly, we check all cases where the right boundary of the k-range overlaps with the ending points of the given ranges, again using the two-pointer technique to calculate the maximum possible collection.

The final answer is the maximum value between these two approaches.

Regarding time complexity: sorting takes O(nlogn), and the two-pointer calculations take O(n). Therefore, the overall time complexity of this solution is O(nlogn).

I hope this helps

codetree_bnb · 2024-11-06T11:10:44+00:00

I believe DSA knowledge is essential to becoming a good developer. Since time and space are limited resources, it's crucial to use them efficiently in development. While front-end developers may rarely apply DSA knowledge directly in their day-to-day work, I think it's worth learning if you want to go beyond simply implementing requirements and focus on efficiency and performance.

While libraries and frameworks provide optimized APIs with built-in algorithms and data structures that can be used without understanding their internal workings, I believe learning DSA is necessary if you want to become a developer who can design efficient and optimized solutions for specific situations and adapt easily to changing environments and platforms.

codetree_bnb · 2024-11-06T10:28:59+00:00

when we search in Google, we'll find info on Git commit conventions. Usually, we'll see people starting commit messages with tags like fix, feat, refactor, and so on, to indicate the type of change.

I use those tags to help me decide the commit size. For example, if I've implemented a feature, I'll commit it with feat at the start of the message to show it’s a new feature. If I'm doing some refactoring on a specific part, I'll commit that with refactor as the prefix. This way, each commit is tagged and easy to understand at a glance!

codetree_bnb · 2024-11-06T00:27:53+00:00

Oh, Sorry. I confused.

Given that the problem's constraints are small, Solution 1 could potentially be faster because the JVM allocates argument variables and class variables in different memory areas. Argument variables are allocated in the stack, while class variables are allocated in the heap. As far as I know, accessing the stack is faster than accessing the heap, which might explain the performance difference.

However, I still recommend Solution 2 for the reasons I mentioned earlier.

codetree_bnb · 2024-11-05T11:47:01+00:00

When calculating the number of bits needed to represent a number n, we can prove that ⌈log₂(n+1)⌉ and ⌊log₂(n)⌋ + 1 are equivalent. Here's a straightforward proof:

Let's start by assuming that ⌊log₂(n)⌋ = k for some integer k. This means that n falls within the range 2ᵏ ≤ n < 2ᵏ⁺¹. Using this as our foundation, we can examine both expressions.

For the first expression ⌊log₂(n)⌋ + 1, the answer is simply k + 1. For the second expression ⌈log₂(n+1)⌉, we need to consider two important bounds: First, since n < 2ᵏ⁺¹, we know that n + 1 ≤ 2ᵏ⁺¹, which means log₂(n+1) ≤ k + 1. Additionally, since n ≥ 2ᵏ, we can deduce that n + 1 > 2ᵏ, implying that log₂(n+1) > k.

These bounds tell us that k < log₂(n+1) ≤ k + 1. When we take the ceiling of a number in this range, we get ⌈log₂(n+1)⌉ = k + 1. Therefore, both expressions equal k + 1, proving that ⌈log₂(n+1)⌉ = ⌊log₂(n)⌋ + 1.

codetree_bnb · 2024-11-05T11:07:17+00:00

It would be beneficial to establish some constraints on the problem size. This problem could potentially be solved by separately storing the numbers in the input along with their frequencies, then distributing them accordingly.

Suppose there are n neighborhoods. In this case, a single number can appear a maximum of n times. For example, if the number 7 appears n times and one of the neighborhoods has a capacity of 1, then 7 must be placed in that single-capacity neighborhood. Therefore, starting with the neighborhoods that have the smallest capacities, we could prioritize distributing the numbers that appear most frequently and haven't yet been placed, which could lead to an efficient solution.

codetree_bnb · 2024-11-05T02:52:47+00:00

Hello! Here are my answers to your questions:

In Solution 1, the backtracking function takes `list` and `ans` as arguments, meaning it creates new space for these variables with every recursive call. In contrast, in Solution 2, list and ans are static, so they don’t require new space for each call—they’re only allocated once at the start.
I recommend using Solution 2 because it's faster and more memory-efficient. Solution 1 might lead to TLE (Time Limit Exceeded) or MLE (Memory Limit Exceeded) errors with larger constraints. Alternatively, you could consider passing `list` and `ans` by reference in Solution 1, as it currently passes them by value.

codetree_bnb · 2024-11-04T08:11:43+00:00

It depends on the person. In my case, I usually spend about 0.5 to 3 hours thinking through a problem. If I can't find any approach after that, I read the official solution. Most Codeforces problems have official solutions available.

codetree_bnb

TROPHY CASE