Container With Most Water Problem Solution

🔥 DSA Challenge – Day 127/360 🚀 📌 Topic: Backtracking 🧩 Problem: Subsets II Problem Statement: Given an integer array that may contain duplicates, return all possible subsets such that the solution set does not contain duplicate subsets. 🔍 Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] 💡 Approach: Backtracking + Sorting 1️⃣ Step 1 – Sort the array to group duplicate elements together 2️⃣ Step 2 – Use recursion to generate all subsets 3️⃣ Step 3 – Skip duplicate elements using condition (i != ind && nums[i] == nums[i-1]) ⏱ Complexity: Time: O(2^n) Space: O(n) (recursion stack + subset storage) 📚 Key Learning: Sorting + smart skipping of duplicates helps avoid repeated subsets in backtracking problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking

Day 1 of becoming DSA consistent (no excuses) Problem name : Minimum Distance Between Three Equal Elements II Difficulty : Medium Topic : Hash Table Most people would brute-force this problem… but there’s a smarter way using grouping. 🧠 Approach : 👉 Instead of comparing all triplets (which is slow), we optimize using a HashMap. Step 1: Store indices Traverse the array For each number, store all its indices in a map number → list of positions Step 2: Filter useful candidates Only consider numbers that appear at least 3 times Others cannot form a valid triplet Step 3: Check consecutive triplets For each list of indices: Pick 3 consecutive indices → (i, i+1, i+2) Since indices are sorted, this ensures minimum distance. Step 4: Compute distance, Distance is calculated between the 3 positions. Simplifies to: 2 × (last index − first index); Step 5: Track minimum. Keep updating the smallest distance found. If no valid triplet → return -1; Key Learning : When dealing with repeated elements: Use HashMap for grouping, Work on indices instead of values, Look for patterns (like consecutive grouping) to reduce complexity. IF YOU GUYS USED DIFFERENT LOGIC , Drop your logic below 👇... #leetcode #dsa #coding #softwareengineering #programming #interviewprep #java #grow #innovation #LetsConnect

🔥 Day 352 – Daily DSA Challenge! 🔥 Problem: 📦 Subarray Product Less Than K Given an array nums and an integer k, return the number of contiguous subarrays where the product of all elements is strictly less than k. 💡 Key Insight — Sliding Window (Two Pointers) Brute force would check all subarrays → O(n²) ❌ Instead, we use a sliding window to maintain a valid product. Core idea: 🧠 How It Works 🔹 Expand the window by moving right 🔹 Multiply current element into prod 🔹 If product ≥ k → shrink window from left 🔹 Once valid, all subarrays ending at right are valid 👉 Count added: right - left + 1 ⚡ Optimized Plan ✅ Initialize: left = 0, prod = 1, count = 0 ✅ For each right: Multiply nums[right] While product ≥ k: divide by nums[left] move left Add (right - left + 1) to count ⚙️ Complexity ✅ Time Complexity: O(n) (each element enters and exits window once) ✅ Space Complexity: O(1) 💬 Challenge for you 1️⃣ Why does this approach fail if negative numbers are allowed? 2️⃣ How would you modify this for sum < k instead of product? 3️⃣ Can you solve this using log transformation + prefix sum? #DSA #Day352 #LeetCode #SlidingWindow #TwoPointers #Arrays #Java #ProblemSolving #KeepCoding

🔥 Day 349 – Daily DSA Challenge! 🔥 Problem: 🧱 Pyramid Transition Matrix You are stacking blocks to form a pyramid. Each block is represented by a letter. Given a bottom row and a list of allowed triples "ABC" meaning: A B → C Return true if you can build the pyramid to the top. 💡 Key Insight — Bitmask + DFS Instead of storing allowed transitions as lists, we encode them using bitmasks. For each pair (A, B) we store possible top blocks using a bitmask. Conceptually: Example: ABC ABD mask[A][B] = {C, D} stored as bits. 🧠 Recursive Construction We build the pyramid row by row: 1️⃣ Current row → cur 2️⃣ Generate next row → next 3️⃣ For each adjacent pair (cur[i], cur[i+1]) check all possible blocks above 4️⃣ Recursively continue until: length = 1 → pyramid complete ⚡ Optimization Trick To extract possible blocks from bitmask: bit = m & -m This isolates the lowest set bit, letting us iterate through candidates efficiently. ⚙️ Complexity Let n be bottom length. ✅ Time Complexity: ~ O(7ⁿ) worst-case (pruned heavily) ✅ Space Complexity: O(n) recursion stack But pruning via allowed transitions keeps it practical. 💬 Challenge for you 1️⃣ Why does using bitmasks make transitions faster than lists? 2️⃣ How would you add memoization to avoid recomputing rows? 3️⃣ Can you solve this using DP with states instead of DFS? #DSA #Day349 #LeetCode #DFS #Bitmask #Backtracking #Java #ProblemSolving #KeepCoding

🔥 DSA Challenge – Day 125/360 🚀 📌 Topic: Recursion 🧩 Problem: Combination Sum Problem Statement: Given an array of distinct integers and a target, return all unique combinations where numbers sum up to the target. Same element can be used multiple times. 🔍 Example: Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3],[7]] 💡 Approach: Backtracking 1️⃣ Step 1 – Start from index 0 and try picking each element 2️⃣ Step 2 – If element ≤ target, include it and reduce target 3️⃣ Step 3 – Backtrack (remove element) and move to next index ✔ Use recursion to explore all possibilities ✔ Reuse same element (stay on same index) ✔ Stop when target becomes 0 (valid answer) ✔ Skip when index reaches end ⏱ Complexity: Time: O(2^n * k) (k = avg length of combination) Space: O(k * x) (x = number of combinations) 📚 Key Learning: Backtracking is all about making choices, exploring, and undoing them efficiently. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking 🚀

🚀 Day 8/100 — #100DaysOfLeetCode Another day, another concept unlocked 💻🔥 ✅ Problem Solved: 🔹 LeetCode 73 — Set Matrix Zeroes 💡 Problem Idea: If any element in a matrix is 0, its entire row and column must be converted to 0 — and the challenge is to do this in-place without using extra space. 🧠 Algorithm & Tricks Learned: Instead of using extra arrays, we can use the first row and first column as markers. First pass → mark rows and columns that should become zero. Second pass → update the matrix based on those markers. Carefully handle the first row and first column separately to avoid losing information. ⚡ Key Insight: The matrix itself can act as storage, reducing extra memory usage. 📊 Complexity Analysis: Time Complexity: O(m × n) → traverse matrix twice Space Complexity: O(1) → solved in-place without extra data structures This problem taught me how small optimizations can significantly improve space efficiency. Learning to think beyond brute force every day 🚀 #100DaysOfLeetCode #LeetCode #DSA #MatrixProblems #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic

#Day362 of #1001DaysOfCode 📘 LeetCode Daily Challenge Problem: XOR After Queries 💡 Approach: Optimized the brute-force simulation using sqrt decomposition. Large step queries were processed directly Small step queries were grouped and batch-processed efficiently Used modular exponentiation + grouped progression updates to reduce time complexity significantly. ⏱ Optimized Time Complexity: ~O(q√n + n√n log MOD) 🧠 Space Complexity: O(n + q) A great problem for learning advanced optimization techniques 🚀 #DSA #Java #LeetCode #ProblemSolving #Algorithms #Coding

🧠 Day 38 / 100 – DSA Practice Solved Word Search on LeetCode 🔍✅ 🔹 Problem: Given a 2D grid of characters and a word, check if the word exists in the grid by traversing adjacent cells (horizontally or vertically). 🔹 Approach: Used DFS + Backtracking: Start from each cell Explore all 4 directions (up, down, left, right) Mark visited cells to avoid reuse Backtrack if the path doesn’t match 🔍 Key Insight: Backtracking helps explore all possible paths while ensuring each cell is used only once per path 🔹 Complexity: ⏱ Time → O(m × n × 4^L) 📦 Space → O(L) recursion stack 💯 Result: ✔️ All test cases passed ⚡ Runtime: 130 ms (Beats 73%) Great problem to strengthen DFS & Backtracking concepts 🚀 #Day38 #100DaysOfCode #LeetCode #Java #DSA #Backtracking #DFS #Algorithms #CodingJourney

📘 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

Day 65/100 | #100DaysOfDSA 🧩🚀 Today’s problem: N-Queens A classic hard backtracking problem. Problem idea: Place N queens on an N×N chessboard such that no two queens attack each other. Key idea: Use backtracking with efficient conflict checking. Why? • We must explore all valid board configurations • Reject placements that cause conflicts • Continue building only valid states How it works: • Place one queen per row • Track columns, diagonals, anti-diagonals • Use bit masking for faster checks ⚡ • Try placing → recurse → backtrack Optimization: Using bitmasks drastically reduces time compared to naive checking. Time Complexity: Exponential (but optimized with pruning) Space Complexity: O(n) recursion depth Big takeaway: Efficient state tracking (cols + diagonals) turns a brute-force problem into a much faster solution. 🔥 One of the most important backtracking problems to master! Day 65 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #Backtracking #Recursion #BitManipulation #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity