Max Dot Product of Two Subsequences on LeetCode

🔥 Day 305 – Daily DSA Challenge! 🔥 Problem: 📦 Subsets (Power Set) Given an integer array nums of unique elements, return all possible subsets (the power set). 💡 Key Insights: 🔹 Every element has two choices → include it or exclude it. 🔹 The total number of subsets for n elements is 2ⁿ. 🔹 Backtracking helps explore all possibilities in a clean, structured way. 🔹 Add the current subset to the result at every recursion level. 🔹 Move forward using i + 1 to avoid reusing elements. ⚡ Optimized Plan: ✅ Start with an empty subset ✅ Use backtracking to build subsets incrementally ✅ Add the current subset to results before branching further ✅ Try including each remaining element one by one ✅ Backtrack after exploring each choice ✅ Time Complexity: O(2ⁿ) ✅ Space Complexity: O(n) (recursion depth) 💬 Challenge for you: 1️⃣ How would this change if nums contained duplicate elements? 2️⃣ Can you solve this using bit masking instead of recursion? 3️⃣ How would you generate subsets of exactly k elements? #DSA #Day305 #LeetCode #Backtracking #Recursion #PowerSet #Java #ProblemSolving #KeepCoding #100DaysOfCode

🚀 Day 97/100 - Problem of the day :- Miniy ASCII Delete Sum for Two Strings. 🎯 Goal Find the minimum ASCII delete sum to make two strings equal. 💡 Core Idea Use Dynamic Programming to compute the maximum ASCII sum of the Longest Common Subsequence (LCS). Answer = (Total ASCII of both strings) − 2 × (LCS ASCII sum). 📌 Key Takeaway •Sometimes minimizing cost = maximizing what you keep. •Transforming problems smartly (Min → Max) simplifies the solution. 📄 Space Complexity : O(n × m) — DP table of two strings. ⏱️ Time Complexity : O(n × m) — Filling the DP matrix. #DSA #DynamicProgramming #LeetCode #Java #CodingJourney #ProblemSolving #Algorithms #TechSkills #100DaysChallenge

Day 33/100 – LeetCode Challenge ✅ Problem: #1292 Maximum Side Length of a Square with Sum Less than or Equal to Threshold Difficulty: Medium Language: Java Approach: Prefix Sum + Binary Search on Square Size Time Complexity: O(m × n × log(min(m, n))) Space Complexity: O(m × n) Key Insight: Use 2D prefix sum to quickly compute sum of any square submatrix in O(1). For each cell, binary search the maximum square side length starting at that cell with sum ≤ threshold. Solution Brief: Built prefix sum matrix psum for O(1) submatrix sum queries. For each possible starting cell, used binary search to find largest valid square. Tracked global maximum side length across all positions. Optimizing submatrix queries with prefix sum. #LeetCode #Day33 #100DaysOfCode #BinarySearch #Java #Algorithm #CodingChallenge #ProblemSolving #MaxSquareSide #MediumProblem #PrefixSum #Matrix #Optimization #DSA

LeetCode Practice - 944. Delete Columns to Make Sorted 🧠 Problem Idea ✅ You are given n strings, all of the same length. ✅ Imagine them written one below another like a grid. Example: cba daf ghi We check column by column. Column 0 → c d g → sorted ✅ Column 1 → b a h → NOT sorted ❌ Column 2 → a f i → sorted ✅ So we delete column 1 → answer = 1 🛠️ Key Observation ✅ A column is sorted if characters do not decrease from top to bottom. That means: 📌 strs[0][col] <= strs[1][col] <= strs[2][col] <= ... ✅ If any pair breaks this rule, that column must be deleted. 🚀 Algorithm 🔷 Take number of rows n 🔷 Take the n strings 🔷 For each column 🔷 Compare every row with the next row 🔷 If upperRowChar > lowerRowChar, mark it as invalid 🔷 Count how many columns are invalid #LeetCode #Java #StringHandling #CodingPractice #ProblemSolving #DSA #DeveloperJourney #TechLearning

Day 18 / 50 – LeetCode Challenge Find Kth Missing Positive Number Problem Description: You are given a sorted array of distinct positive integers arr and an integer k. The objective is to determine the k-th missing positive integer that does not appear in the array. Conceptual Insight: For any index i in the array, if no numbers were missing, the value should ideally be i + 1. Therefore, the number of missing positive integers up to index i is calculated as: ini Copy code missing = arr[i] − (i + 1) This observation enables an efficient binary search–based solution. Algorithm (Binary Search Approach): Initialize two pointers: low = 0 and high = n − 1. Perform binary search on the array: Compute mid. Calculate the count of missing numbers up to mid. If the missing count is less than k, shift the search to the right. Otherwise, shift the search to the left. After termination, the k-th missing number is computed as: k + (high + 1) // equivalent to k + low Complexity Analysis: Time Complexity: O(log n) Space Complexity: O(1) #Day18 #LeetCode #50DaysOfLeetCode #BinarySearch #DataStructures #Algorithms #Java #ProblemSolving #CodingPractice #TechnicalInterview #DSA #CompetitiveProgramming

🔹 Day 95 – LeetCode Practice 📌 Problem: Maximum Depth of Binary Tree (LeetCode #104) 📊 Difficulty: Easy 🧠 Problem Overview: Given the root of a binary tree, the task is to determine its maximum depth. The maximum depth is defined as the number of nodes along the longest path from the root node down to the farthest leaf node. ✅ Approach Used: Traversed the binary tree using depth-first search. At each node, tracked the current depth. Updated the maximum depth whenever a deeper level was reached. Recursively explored both left and right subtrees. 📈 Complexity Analysis: Time Complexity: O(n), where n is the number of nodes Space Complexity: O(h), where h is the height of the tree 🚀 Submission Results: Status: Accepted ✅ Runtime: 0 ms (Beats 100%) Memory: 44.51 MB (Beats 27.65%) 💡 Reflection: This problem reinforces the fundamentals of tree traversal and recursion. A simple yet important exercise to strengthen understanding of binary tree depth calculations. #LeetCode #DSA #BinaryTree #DFS #ProblemSolving #Java #CodingPractice #Learning

Day 56 of #100DaysOfCode 🚀 Today’s DSA problem: Maximum Nesting Depth of the Parentheses 📌 Problem idea: Given a valid parentheses string, find the maximum depth of nested ( and ). 🧠 Key insight: Increase depth when ( appears Decrease depth when ) appears Track the maximum depth reached at any moment ✅ Why this matters: This problem sharpens: Stack / counter intuition Understanding of nested structures Real-world parsing concepts (expressions, compilers) 📌 Approach: Use a counter instead of a stack Update max depth while traversing the string Time Complexity: O(n) Space Complexity: O(1) Small problems, strong fundamentals 💪 Onward to the next one! #100DaysOfCode #Day56 #DSA #CodingJourney #ProblemSolving #LeetCode #Java #Consistency #dsawithkunal

Algorithm: Count and Say (No Code) Start with the base value "1" for the first term. For every next term: Read the previous term from left to right. Group consecutive identical digits together. For each group: Count how many times the digit appears. Say it as “count followed by the digit”. Combine all such groups to form the next term. Repeat the process until the required nth term is generated. Key Idea Each term is a verbal description of the previous term. Example "1" → one 1 → "11" "11" → two 1s → "21" "21" → one 2, one 1 → "1211" Complexity Insight Time: Proportional to the length of the generated sequence Space: Proportional to the length of the current term #LeetCode #CountAndSay #DSA #Algorithms #ProblemSolving #Java #Recursion #TwoPointers #CompetitiveProgramming #CodingPractice

#200DaysOfCode – Day 111 Word Search Problem: Given a 2D grid of characters and a word, determine whether the word exists in the grid. The word must be formed using adjacent cells (up, down, left, right), and each cell can be used only once. Example: Input: board = [[A, B, C, E], [S, F, C, S], [A, D, E, E]] word = "ABCCED" Output: true My Approach: Used DFS (Depth First Search) starting from every cell. Matched characters step-by-step with the given word. Marked cells as visited during the path to avoid reuse. Applied backtracking to explore all possible directions safely. Time Complexity: O(m × n × 4^L) Space Complexity: O(L) (recursion stack) Grid problems often look complex, but breaking them down with DFS + backtracking makes the logic clear and manageable. Patience and careful state handling are the real keys here #takeUforward #100DaysOfCode #Java #LeetCode #ProblemSolving #Backtracking #DFS #DataStructures #Algorithms #CodeNewbie #Consistency

🔥 Day 82 of #100DaysOfLeetCode ✅ Problem: Number of Longest Increasing Subsequence ✅ Difficulty: Medium 💡 Key Insight: Instead of tracking only the LIS length, we also maintain the number of ways each LIS can be formed. For every element, we check all previous smaller elements and update both length and count dynamically. 🛠 Approach: Use two arrays: dp[i] → Length of LIS ending at index i cnt[i] → Number of LIS ending at index i If a longer subsequence is found → update length and copy count. If another subsequence of the same length is found → add the counts. Finally, sum counts for indices having the maximum LIS length. ⏱ Complexity: Time: O(n²) Space: O(n) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday