4-LeetCodeQs

Author: Abhishek-Mallick

1048-LeetCode/1048-longest-string-chain.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int longestStrChain(String[] words) {
+        Map<String,Integer> map = new HashMap<>();
+        Arrays.sort(words, (a,b)->a.length() - b.length());
+        int res = 0;
+        for(String word : words)
+        {
+            int best = 0;
+            for(int i=0;i<word.length();i++)
+            {
+                String prev = word.substring(0,i) + word.substring(i+1);
+                best = Math.max(best,map.getOrDefault(prev,0)+1);
+            }
+            map.put(word,best);
+            res = Math.max(res,best);
+        }
+        return res;
+    }
+}

1048-LeetCode/README.md

@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/longest-string-chain/">1048. Longest String Chain</a></h2><h3>Medium</h3><hr><div><p>You are given an array of <code>words</code> where each word consists of lowercase English letters.</p>
+
+<p><code>word<sub>A</sub></code> is a <strong>predecessor</strong> of <code>word<sub>B</sub></code> if and only if we can insert <strong>exactly one</strong> letter anywhere in <code>word<sub>A</sub></code> <strong>without changing the order of the other characters</strong> to make it equal to <code>word<sub>B</sub></code>.</p>
+
+<ul>
+	<li>For example, <code>"abc"</code> is a <strong>predecessor</strong> of <code>"ab<u>a</u>c"</code>, while <code>"cba"</code> is not a <strong>predecessor</strong> of <code>"bcad"</code>.</li>
+</ul>
+
+<p>A <strong>word chain</strong><em> </em>is a sequence of words <code>[word<sub>1</sub>, word<sub>2</sub>, ..., word<sub>k</sub>]</code> with <code>k &gt;= 1</code>, where <code>word<sub>1</sub></code> is a <strong>predecessor</strong> of <code>word<sub>2</sub></code>, <code>word<sub>2</sub></code> is a <strong>predecessor</strong> of <code>word<sub>3</sub></code>, and so on. A single word is trivially a <strong>word chain</strong> with <code>k == 1</code>.</p>
+
+<p>Return <em>the <strong>length</strong> of the <strong>longest possible word chain</strong> with words chosen from the given list of </em><code>words</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["a","b","ba","bca","bda","bdca"]
+<strong>Output:</strong> 4
+<strong>Explanation</strong>: One of the longest word chains is ["a","<u>b</u>a","b<u>d</u>a","bd<u>c</u>a"].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["xbc","pcxbcf","xb","cxbc","pcxbc"]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> All the words can be put in a word chain ["xb", "xb<u>c</u>", "<u>c</u>xbc", "<u>p</u>cxbc", "pcxbc<u>f</u>"].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> words = ["abcd","dbqca"]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The trivial word chain ["abcd"] is one of the longest word chains.
+["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 16</code></li>
+	<li><code>words[i]</code> only consists of lowercase English letters.</li>
+</ul>
+</div>

304-range-sum-query-2d-immutable/304-range-sum-query-2d-immutable.java

@@ -0,0 +1,25 @@
+class NumMatrix {
+    private int[][] dp;
+    public NumMatrix(int[][] matrix) {
+        if(matrix == null || matrix.length == 0 || matrix[0].length == 0)
+            return;
+        int m = matrix.length;
+        int n = matrix[0].length;
+        
+        dp = new int[m+1][n+1];
+        
+        for(int i=1;i<=m;i++)
+            for(int j=1;j<=n;j++)
+                dp[i][j] = dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + matrix[i-1][j-1];
+    }
+    
+    public int sumRegion(int row1, int col1, int row2, int col2) {
+        return dp[row2+1][col2+1] - dp[row1][col2+1] - dp[row2+1][col1] + dp[row1][col1];
+    }
+}
+
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * NumMatrix obj = new NumMatrix(matrix);
+ * int param_1 = obj.sumRegion(row1,col1,row2,col2);
+ */

304-range-sum-query-2d-immutable/NOTES.md

@@ -0,0 +1 @@
+​

304-range-sum-query-2d-immutable/README.md

@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/range-sum-query-2d-immutable/">304. Range Sum Query 2D - Immutable</a></h2><h3>Medium</h3><hr><div><p>Given a 2D matrix <code>matrix</code>, handle multiple queries of the following type:</p>
+
+<ul>
+	<li>Calculate the <strong>sum</strong> of the elements of <code>matrix</code> inside the rectangle defined by its <strong>upper left corner</strong> <code>(row1, col1)</code> and <strong>lower right corner</strong> <code>(row2, col2)</code>.</li>
+</ul>
+
+<p>Implement the NumMatrix class:</p>
+
+<ul>
+	<li><code>NumMatrix(int[][] matrix)</code> Initializes the object with the integer matrix <code>matrix</code>.</li>
+	<li><code>int sumRegion(int row1, int col1, int row2, int col2)</code> Returns the <strong>sum</strong> of the elements of <code>matrix</code> inside the rectangle defined by its <strong>upper left corner</strong> <code>(row1, col1)</code> and <strong>lower right corner</strong> <code>(row2, col2)</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/sum-grid.jpg" style="width: 415px; height: 415px;">
+<pre><strong>Input</strong>
+["NumMatrix", "sumRegion", "sumRegion", "sumRegion"]
+[[[[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]], [2, 1, 4, 3], [1, 1, 2, 2], [1, 2, 2, 4]]
+<strong>Output</strong>
+[null, 8, 11, 12]
+
+<strong>Explanation</strong>
+NumMatrix numMatrix = new NumMatrix([[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]);
+numMatrix.sumRegion(2, 1, 4, 3); // return 8 (i.e sum of the red rectangle)
+numMatrix.sumRegion(1, 1, 2, 2); // return 11 (i.e sum of the green rectangle)
+numMatrix.sumRegion(1, 2, 2, 4); // return 12 (i.e sum of the blue rectangle)
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 200</code></li>
+	<li><code>-10<sup>5</sup> &lt;= matrix[i][j] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= row1 &lt;= row2 &lt; m</code></li>
+	<li><code>0 &lt;= col1 &lt;= col2 &lt; n</code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>sumRegion</code>.</li>
+</ul>
+</div>

462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int minMoves2(vector<int>& nums) {
+        sort(nums.begin(),nums.end());
+        int i=0,j=nums.size()-1;
+        int ans = 0;
+        while(i<j)
+        {
+            ans += nums[j]-nums[i];
+            i++;
+            j--;
+        }
+        return ans;
+    }
+};

462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.java

@@ -0,0 +1,11 @@
+class Solution {
+    public int minMoves2(int[] nums) {
+        int mean = 0;
+        int ans = 0;
+        Arrays.sort(nums);
+        mean = nums[nums.length/2];
+        for(int num : nums)
+            ans+=Math.abs(mean-num);
+        return ans;
+    }
+}

462-minimum-moves-to-equal-array-elements-ii/NOTES.md

@@ -0,0 +1 @@
+​

462-minimum-moves-to-equal-array-elements-ii/README.md

@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/">462. Minimum Moves to Equal Array Elements II</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> of size <code>n</code>, return <em>the minimum number of moves required to make all array elements equal</em>.</p>
+
+<p>In one move, you can increment or decrement an element of the array by <code>1</code>.</p>
+
+<p>Test cases are designed so that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+Only two moves are needed (remember each move increments or decrements one element):
+[<u>1</u>,2,3]  =&gt;  [2,2,<u>3</u>]  =&gt;  [2,2,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,10,2,9]
+<strong>Output:</strong> 16
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>

968-binary-tree-cameras/968-binary-tree-cameras.java

@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int minCameraCover(TreeNode root) {
+        int ans[] = solve(root);
+        return Math.min(ans[1],ans[2]);
+    }
+    
+    public int[] solve(TreeNode node)
+    {
+        if(node == null)
+            return new int[]{0,0,9999};
+        int l[] = solve(node.left);
+        int r[] = solve(node.right);
+        
+        int ml = Math.min(l[1],l[2]);
+        int mr = Math.min(r[1],r[2]);
+        
+        int d0 = l[1]+r[1];
+        int d1 = Math.min(l[2]+mr , r[2]+ml);
+        int d2 = 1+Math.min(l[0],ml) + Math.min(r[0],mr);
+        
+        return new int[]{d0,d1,d2};
+    }
+}