🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gxntCVfP 💡 My thought process: I used Dijkstra’s algorithm to find the minimum cost path because all edge weights are non-negative. To manage edge reversals, I modeled the graph by adding: - the original directed edge with cost w - a reverse edge with cost 2w, which represents the reversal operation This converts the problem into a standard shortest-path graph, eliminating the need for extra state handling. An adjacency list and a min-heap priority queue make traversal efficient, while a visited array tracks the minimum cost to reach each node. This method is straightforward, efficient, and works well for large graphs. 👉 My Solution: https://lnkd.in/gBkufJ5G If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

1000 problems on LeetCode. 456-day streak. Here's what I've learned along the way. Solving problems at scale doesn't just make you faster; it fundamentally changes how you see problems. You stop thinking in terms of individual questions and start recognizing the deeper structures underneath. A few things that clicked after 1000: → Hard problems are rarely about one technique. They're about composing 2-3 ideas together, Binary Search + Segment Tree, BFS + Bitmask DP. That composition skill is what actually matters. → Advanced data structures make sense when you understand what query they're optimizing for. Segment Trees, Fenwick Trees, Tries, Monotonic Stacks, each one answers a specific question efficiently. → Consistency compounds. 456 active days of solving POTD, 1,422 submissions this past year. Some days it was 5 problems, some days it was one problem for 3 hours. Both count. Concepts I enjoy working with the most: Segment Trees (with lazy propagation), Binary Lifting, DSU, Digit DP, Bitmask DP, and String Hashing. #LeetCode #DSA #SoftwareEngineering #NewGrad #Algorithms #CompetitiveProgramming

LeetCode 90 — Subsets II Worked on generating all possible subsets of an array that may contain duplicates. This is an extension of the Subsets problem, but duplicates add a small twist. If handled carelessly, duplicate subsets get generated. Approach — Backtracking + Duplicate Skipping - Sorted the array first to group duplicates together - At each index, made the usual include / exclude decision - While skipping (not taking), moved the index forward past duplicate values - Ensured that identical elements don’t start identical branches Core idea :- Instead of filtering duplicates at the end, avoid creating them during recursion itself. Key learning: - Handling duplicates is usually about controlling the starting point of recursion branches. - Small adjustments in index movement can prevent large amounts of redundant work. This felt like a refined version of the basic subsets pattern. #leetcode #recursion #backtracking #dsa #algorithms #problemSolving #codingjourney

Day 12 and 13– DSA Progress Update Focused on recursion, backtracking, string patterns, and dynamic programming through LeetCode practice. Problems Solved: 1221. Split a String in Balanced Strings (Easy) Improved understanding of counting techniques and balanced string logic. 46. Permutations (Medium) Strengthened backtracking skills and recursive tree exploration. 78. Subsets (Medium) Practiced recursion and decision-making patterns for generating combinations. 5. Longest Palindromic Substring (Medium) Enhanced string manipulation and center-expansion / DP thinking. 38. Count and Say (Medium) Improved pattern recognition and iterative string construction. 97. Interleaving String (Medium) Practiced dynamic programming with 2D state transitions and string merging logic. Key Takeaways: Stronger grasp of recursion and backtracking patterns Improved dynamic programming intuition Better string handling and pattern recognition Increased confidence solving medium-level problems #DSA #LeetCode #ProblemSolving #Algorithms #Consistency #LearningInPublic

15 LeetCode patterns Instead of memorizing hundreds of problems, focus on patterns. Once a pattern clicks, the solution often reveals itself naturally. These patterns reshape how you think, not just what you solve. Some of the most high-impact ones: • Prefix Sum. • Sliding Window. • Two Pointers. • Fast & Slow Pointers. • Monotonic Stack. • Modified Binary Search. • DFS & BFS. • Backtracking. • Dynamic Programming. #LeetCode #DataStructures #Algorithms #DSA

LeetCode 1011 — Capacity To Ship Packages Within D Days Worked on determining the minimum ship capacity required to transport all packages within a fixed number of days while preserving the given order. Approach — Binary Search on Capacity + Feasibility Check - Observed that ship capacity must lie between: - Maximum single package weight (lower bound) - Sum of all weights (upper bound) - Applied binary search within this capacity range - For each candidate capacity: - Simulated the shipping process day by day - Counted how many days were required without exceeding capacity - If shipping finished within the allowed days → tried a smaller capacity - Otherwise → increased the capacity This reduced the problem to O(n log(sum of weights)), a classic example of binary search on the answer space rather than the array itself. A strong reminder that many optimization problems are really about searching the minimum feasible value, not brute-forcing combinations. #leetcode #binarysearch #dsa #algorithms #codingjourney #problemsolving #javaprogramming #learninpublic #techskills #placements #codingpractice

LeetCode 70 — Climbing Stairs Worked on finding the number of distinct ways to reach the top when you can climb either 1 or 2 steps at a time. Initially, it looks like a simple counting problem. But structurally, it follows a clear recurrence pattern. Approach — Recurrence Relation - If n ≤ 1 → only one possible way - From step n, you can: - Take 1 step → reduce to (n - 1) - Take 2 steps → reduce to (n - 2) - Total ways = ways(n - 1) + ways(n - 2) This is essentially the Fibonacci pattern in a different form. While testing with small inputs, the recursive solution worked correctly. However, on submission it resulted in Time Limit Exceeded for larger inputs. That made one thing very clear :- The logic is correct, but overlapping subproblems make the pure recursive approach inefficient. Key learning :- Correct logic is not enough. Efficiency matters. Recognizing when recursion needs optimization (memoization / DP) is just as important as writing it. #leetcode #recursion #dynamicprogramming #dsa #algorithms #problemSolving #codingjourney

LeetCode 2643 — Row With Maximum Ones Worked on identifying the row containing the highest number of 1s in a binary matrix, along with the total count of ones in that row. Approach — Row-wise Counting with Maximum Tracking - Traversed each row of the matrix sequentially - Counted the number of 1s present in the current row - Maintained two variables to track: - The maximum count of ones seen so far - The row index where this maximum occurs - Updated the result whenever a row exceeded the previous maximum - Returned both the row index and the corresponding count This straightforward traversal runs in O(m × n) time and reinforces a key idea - not every problem needs complex optimization, sometimes a clear linear scan with proper state tracking is the most reliable solution. A reminder that strong problem solving is about choosing the simplest correct approach first, then optimizing only if required. #leetcode #arrays #matrix #dsa #algorithms #codingjourney #problemsolving #javaprogramming #learninpublic #techskills #placements #codingpractice

DSA Practice – Day 11 | Difficulty-Balanced Set Solved on LeetCode and GFG, focusing on backtracking, recursion, combinatorics, and dynamic programming: Medium • LC 40 – Combination Sum II — Backtracking, Duplicate Handling • LC 46 – Permutations — Backtracking • LC 78 – Subsets — Backtracking, Bit Manipulation • LC 377 – Combination Sum IV — Dynamic Programming GFG • Rat Maze With Multiple Jumps — Backtracking, Matrix Traversal, Recursion Core topics covered: Backtracking, Recursion, Dynamic Programming, Combinatorics, Matrix Traversal #DSA #LeetCode #GeeksforGeeks #Algorithms #DataStructures #ProblemSolving

📌 Problem: 3379. Transformed Array 📊 Difficulty: Easy Today’s problem was a fun warm-up based on circular arrays and index shifting. 🧩 Problem Summary We are given a circular array nums. For every index i, we need to jump: Right if nums[i] > 0 Left if nums[i] < 0 Stay if nums[i] == 0 …and store the value at the landing position in the result array. 💡 Approach The main idea is to compute the new index using modulo arithmetic: [ j = (i + nums[i]) % n ] But in C++, modulo with negative values can give a negative result, so we must normalize it back into [0, n-1]. Instead of using an if condition, I used a compact bitwise adjustment: ans[i] = nums[j + (-(j < 0) & n)]; This ensures the index always stays valid. ⚡ Key Insight ✅ Circular movement problems become easy once you treat indices with modulo. ⚠️ Always handle negative modulo carefully in C++. ⏱️ Complexity Time: O(n) Space: O(n) Solving these small problems consistently is what builds speed and confidence for harder ones 💪🔥 #LeetCode #DSA #Cplusplus #Programming #ProblemSolving #Coding #Algorithms #LearningInPublic #CompetitiveProgramming