LeetCode Word Search with DFS and Backtracking

🧠 Day 37 / 100 – DSA Practice Solved Multiply Strings on LeetCode ✖️🔢✅ 🔹 Problem: Multiply two non-negative numbers given as strings without using built-in big integer libraries. 🔹 Approach: Simulated the manual multiplication method: Multiply each digit of num1 with each digit of num2 Store results in an array Handle carry properly Build final string while skipping leading zeros 🔍 Key Insight: Using an array of size m + n helps manage positions just like pen-and-paper multiplication 🔹 Complexity: ⏱ Time → O(m × n) 📦 Space → O(m + n) 💯 Result: ✔️ All test cases passed ⚡ Runtime: 3 ms (Beats 85%) Loved implementing this classic math-based approach without using built-in shortcuts 🚀 #Day37 #100DaysOfCode #LeetCode #Java #DSA #Strings #Algorithms #CodingJourney #ProblemSolving

🧠 Day 41 / 100 – DSA Practice Solved Count and Say on LeetCode 🔢🗣️✅ 🔹 Problem: Generate the nth term of the count-and-say sequence, where each term is derived by describing the previous term. 🔹 Approach: Used an iterative + string building approach: Start with base case "1" For each iteration, read the previous string Count consecutive characters Append count + character to form next term 🔍 Key Insight: This problem is essentially Run-Length Encoding (RLE) applied repeatedly on strings 🔹 Complexity: ⏱ Time → O(n × m) (m = length of generated string) 📦 Space → O(m) 💯 Result: ✔️ All test cases passed ⚡ Runtime: 8 ms (Beats 62%) Great problem to improve string manipulation & pattern recognition 🚀 #Day41 #100DaysOfCode #LeetCode #Java #DSA #Strings #RLE #Algorithms #CodingJourney

#CodeEveryday — My DSA Journey | Day 4 🧩 Problem Solved: Word Search (LeetCode #79) 💭 What I Learned: Used DFS + backtracking to search for a word in a 2D grid by exploring all possible paths. At each step: ✔️ Checked boundary conditions and character match ✔️ Explored all 4 directions (up, down, left, right) ✔️ Marked the current cell as visited to avoid revisiting ✔️ Backtracked by unmarking the cell after exploration Ensured correctness by stopping early when a mismatch occurs or when the full word is found. This strengthened my understanding of grid traversal with constraints and path tracking. ⏱ Time Complexity: O(m × n × 4^L) (L = length of word) 🧠 Space Complexity: O(L) (recursion stack) ⚡ Key Takeaways: ✔️ Backtracking is essential for path-based problems in grids ✔️ Marking visited cells prevents cycles ✔️ Early stopping improves performance significantly 💻 Language Used: Java ☕ 📘 Concepts: DFS · Backtracking · Matrix Traversal · Recursion #CodeEveryday #DSA #LeetCode #Java #Backtracking #DFS #ProblemSolving #Algorithms #CodingJourney #Consistency 🚀

Day 45 of Daily DSA 🚀 Solved LeetCode 867: Transpose Matrix ✅ Problem: Given a 2D matrix, return its transpose (rows become columns and columns become rows). Approach: Created a new matrix and swapped indices while traversing. Steps: Get number of rows and columns Create a new matrix of size cols x rows Traverse original matrix Assign: trans[j][i] = matrix[i][j] Return the new matrix ⏱ Complexity: • Time: O(n × m) • Space: O(n × m) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 46.46 MB Simple transformations like transpose build strong fundamentals for matrix-based problems 💡 #DSA #LeetCode #Java #Arrays #Matrix #CodingJourney #ProblemSolving

🧠 Day 40 / 100 – DSA Practice Solved String to Integer (atoi) on LeetCode 🔢➡️🧮✅ 🔹 Problem: Convert a string into a 32-bit signed integer while handling whitespace, signs, non-digit characters, and overflow conditions. 🔹 Approach: Followed a step-by-step simulation: Ignore leading whitespaces Handle optional + / - sign Convert digits while checking for overflow Stop at first non-digit character 🔍 Key Insight: Careful handling of edge cases like overflow and invalid input is crucial in this problem 🔹 Complexity: ⏱ Time → O(n) 📦 Space → O(1) 💯 Result: ✔️ All test cases passed ⚡ Runtime: 1 ms (Beats 100%) One of the best problems to master string parsing & edge case handling 🚀 #Day40 #100DaysOfCode #LeetCode #Java #DSA #Strings #Algorithms #CodingJourney

Day 48 of Daily DSA 🚀 Solved LeetCode 48: Rotate Image ✅ Problem: Given an n x n matrix, rotate the image by 90° clockwise — in-place (without using extra space). Approach: Used a two-step transformation: Transpose the matrix Reverse each row Steps: Traverse upper triangle and swap → matrix[i][j] ↔ matrix[j][i] For each row: Use two pointers (left, right) Swap elements to reverse the row Matrix gets rotated in-place ⏱ Complexity: • Time: O(n²) • Space: O(1) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 43.56 MB In-place transformations are powerful — no extra space, just smart manipulation 💡 #DSA #LeetCode #Java #Matrix #Arrays #CodingJourney #ProblemSolving

🚀 Day 574 of #750DaysOfCode 🚀 🔍 Problem Solved: Detect Cycles in 2D Grid Today’s problem was a great example of how graph concepts show up in grids 👀 💡 Key Insight: A grid can be treated as a graph where: Each cell = node Adjacent same-value cells = edges 👉 The task is to detect a cycle of same characters with length ≥ 4 🧠 Approach (DFS + Parent Tracking): Traverse each cell Start DFS if not visited While exploring: Move only to same character cells Track previous (parent) cell If we visit an already visited cell (not parent) → ✅ cycle found 📈 Complexity: Time: O(m × n) Space: O(m × n) ✨ Takeaway: 👉 Many grid problems are just graph problems in disguise 👉 Cycle detection becomes easy with DFS + parent tracking Another solid concept added to the toolkit 💪 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Graphs #DFS #Algorithms #LearningEveryday

🚀 Day 566 of #750DaysOfCode 🚀 🔍 Problem Solved: Mirror Distance of an Integer Today’s problem was simple but a great reminder of how powerful basic number manipulation can be. 💡 Problem Insight: We define the mirror distance of a number as: 👉 abs(n - reverse(n)) So the task is: Reverse the digits of the number Compute the absolute difference 🧠 Approach: Extract digits using % 10 Build the reversed number Compute absolute difference 📊 Complexity: Time: O(d) → where d = number of digits Space: O(1) 🔥 Key Takeaway: Even the easiest problems reinforce fundamentals like digit extraction, reversal, and absolute difference — building blocks for more complex algorithms. #Day566 #750DaysOfCode #LeetCode #Java #CodingJourney #ProblemSolving #Algorithms #BeginnerFriendly

Day 2/30 — DSA Challenge 🚀 Problem: Lowest Common Ancestor of Deepest Leaves Topic: Tree + DFS Difficulty: Medium Approach: Used DFS to calculate depth of left and right subtrees At each node, compared depths: If equal → current node is LCA Else → return deeper subtree result Mistake / Challenge: Initially overcomplicated thinking about storing all deepest nodes Realized we don’t need to track nodes explicitly, depth comparison is enough Fix: Returned a Pair (node, depth) from recursion Handled everything in one DFS traversal Key Learning: Tree problems often look complex but can be simplified with recursion Focus on what needs to be returned from each call Time Taken: 60 minutes Consistency check ✅ See you on Day 3. GitHub Repo: https://lnkd.in/g87geK_g #DSA #LeetCode #Java #Trees #Recursion #LearningInPublic

📘 DSA Journey — Day 32 Today’s focus: Binary Search for mathematical validation. Problem solved: • Valid Perfect Square (LeetCode 367) Concepts used: • Binary Search • Search space reduction • Avoiding overflow Key takeaway: The goal is to determine whether a number is a perfect square without using built-in square root functions. Using binary search, we search in the range [1, num]: • Compute mid • Check if mid * mid == num → perfect square • If mid * mid < num, move right • Else move left This reduces the complexity to O(log n). Important detail: To avoid overflow when computing mid * mid, we can use: mid <= num / mid This ensures safe comparison even for large numbers. Continuing to strengthen binary search intuition and consistency in problem solving. #DSA #Java #LeetCode #CodingJourney