Dsa on Vijay Pagare

The Pattern Behind Kadane's Algorithm

Sun, 12 Apr 2026 00:04:00 +0530

Kadane’s Algorithm is a classic dynamic programming technique used to find the Maximum Subarray Sum within a one-dimensional array of numbers. It’s famous for its efficiency, turning what could be a brute-force $O(N^2)$ problem into a sleek $O(N)$ linear scan.

1. What is Kadane’s Algorithm?

The algorithm iterates through an array, keeping track of the maximum sum ending at the current position. It makes a simple choice at every element:

DSA - 2 new, 1 revision (Greedy, Kadane, Linked List)

Sat, 11 Apr 2026 23:24:56 +0530

New Problems

435. Non-overlapping Intervals

Concept: Greedy
Insight:
Sort intervals based on start. Iterate and compare adjacent intervals while maintaining prevEnd.
- If no overlap → update prevEnd
- If overlap → increment count and update prevEnd = min(prevEnd, currEnd)
Comment:
Solved partial conditions independently. Needed a hint to unlock the core greedy idea, then implemented successfully.

53. Maximum Subarray

Concept: Kadane’s Algorithm
Insight:
At each step, track max of:
- current element
- sum till now + current
  Maintain a global maximum.
Comment:
Recognized the pattern after hint. Execution was straightforward once direction was clear.

Revision

23. Merge K Sorted Lists

DSA - 1 new, 2 revision (Hashing, Linked List, Strings)

Fri, 10 Apr 2026 21:00:00 +0530

📌 Today’s Progress

1 New • 2 Revisions

New Problem

49. Group Anagrams
Insight: Sort characters of each word and use it as a key in a hashmap to group anagrams.
Comment: Easy overall, but needed a hint to recall the sorting trick.

Observation (JS Quirk):

arr.sort() sorts alphabetically (case-sensitive) by default
For numbers → (a, b) => a - b works
For alphabets → direct sort works, comparator logic differs

Revisions

21. Merge Two Sorted Lists
Insight:
Used standard linked list template:

DSA - 1 new, 3 revision (Matrix, DFS, Sliding Window, Binary Search)

Thu, 09 Apr 2026 20:18:55 +0530

Tackled a mix of new challenges and critical revisions, focusing on the philosophy that core patterns—Arrays, Strings, and DFS—must become second nature.

48. Rotate Image (Medium)

Approach

Transpose matrix → swap (i, j) with (j, i)
Reverse each row

Reflection

Came up with a half-baked approach
Missed the transpose + reverse pattern
Made silly mistakes:
- Incorrect transpose logic (didn’t limit swaps correctly)
- Reverse logic not optimized (can use 2-pointer technique → O(n))
Need to slow down and think clearly before coding

Revisions

297. Serialize and Deserialize Binary Tree (Hard)

Approach

Use DFS traversal
Serialize:
- Store values using delimiter ","
- Use "N" for null nodes
Deserialize:
- Rebuild using DFS
- Maintain pointer/index across recursion

Reflection

Solved in <25 mins
Minor confusion:
- Pointer increment in deserialization
- Must pass pointer by reference
- Avoid loops; rely purely on DFS flow

3. Longest Substring Without Repeating Characters (Medium)

Approach

Sliding Window + Two Pointers
- Expand window when valid
- Shrink when duplicate found
Use Set / HashMap for tracking characters

Reflection

Felt easy this time
Stayed calm and executed step-by-step
No unnecessary panic → big improvement

33. Search in Rotated Sorted Array (Medium)

Approach

Modified Binary Search
Identify sorted half and move accordingly

Reflection

Took time to internalize edge/else cases
Once understood → logic felt clear
Key idea: always move towards the sorted side

🧩 Insights / Learnings

Core topics must become muscle memory:

DSA: 1 new, 2 revision (DP, Backtracking, Graph)

Wed, 08 Apr 2026 21:02:17 +0530

Today’s session was a mix of one new challenge and two deep-dive revisions. The focus remains on identifying the “core pattern” rather than just memorizing the syntax.

New Challenge: 300. Longest Increasing Subsequence

The Insight: The key here is building a dp array where dp[i] represents the length of the longest increasing subsequence ending at index i.

The Process: To find dp[i], we look back at all elements j (where j < i). If nums[i] > nums[j], then nums[i] can extend the subsequence ending at j. The recurrence relation becomes:
dp[i] = max(dp[i], dp[j] + 1).

DSA: 1 new, 3 revision (Sliding Window, DP, LL, Graph)

Tue, 07 Apr 2026 23:38:42 +0530

Today was about strengthening the foundations and reflecting upon the mastery strategy. While the original plan was two new problems daily, the reality of high-level prep is teaching me that revision and depth often outweigh raw volume.

🧠 DSA Summary

1. Longest Repeating Character Replacement (LC 424)

The Pivot: Shifting from a Brute Force approach (checking every possible substring) to a refined Sliding Window.
The Insight: The window is valid as long as the number of replacements needed doesn’t exceed k.
Core Logic: Window Length - Max Frequency of a Character <= k
Reflection: I managed to hack together a partial solution, but the “aha!” moment came from maintaining the character count hash to dynamically expand the right pointer and shrink the left. Though an even better solution with keep count of maxFrequency exists.

2. Pacific Atlantic Water Flow (LC 417)

The Insight: Treat the 2D matrix as a graph. The key is defining a solid base condition: boundaries + visited sets + the “main business logic” (water height). Working backward from the oceans often simplifies the flow.

3. Remove Nth Node From End of List (LC 19)

The Insight: The “Two-Pointer Gap” strategy. By advancing the first pointer n steps ahead and then pointing the second to the head, they can hop together. When the first hits the end, the second points exactly to the node that needs removal. One pass, O(n) efficiency.

4. Maximum Product Subarray (LC 152)

The Insight: Negative numbers are the wildcards—they can turn a minimum into a maximum instantly.
The Fix: It is vital to track both the current min and max. When introducing a new element, consider three cases:
1. Starting a new subarray.
2. Multiplying with the previous max.
3. Multiplying with the previous min.
Note: Encountering a zero resets the running product.

🏗️ Strategy Shift: Quality > Quantity

I couldn’t accommodate a System Design (SD) question today due to time constraints, which sparked a realization about ROI (Return on Investment). Moving forward, I’m adjusting the daily goal: