Added tasks 392-918

Author: javadev

LeetCodeNet/G0301_0400/S0392_is_subsequence/readme.md

@@ -0,0 +1,56 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 392\. Is Subsequence
+
+Easy
+
+Given two strings `s` and `t`, return `true` _if_ `s` _is a **subsequence** of_ `t`_, or_ `false` _otherwise_.
+
+A **subsequence** of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of `"abcde"` while `"aec"` is not).
+
+**Example 1:**
+
+**Input:** s = "abc", t = "ahbgdc"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "axc", t = "ahbgdc"
+
+**Output:** false
+
+**Constraints:**
+
+*   `0 <= s.length <= 100`
+*   <code>0 <= t.length <= 10<sup>4</sup></code>
+*   `s` and `t` consist only of lowercase English letters.
+
+**Follow up:** Suppose there are lots of incoming `s`, say <code>s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub></code> where <code>k >= 10<sup>9</sup></code>, and you want to check one by one to see if `t` has its subsequence. In this scenario, how would you change your code?
+
+## Solution
+
+```csharp
+public class Solution {
+    public bool IsSubsequence(string s, string t) {
+        int i = 0;
+        int j = 0;
+        int n = t.Length;
+        int m = s.Length;
+        if (m == 0) {
+            return true;
+        }
+        while (j < n) {
+            if (s[i] == t[j]) {
+                i++;
+                if (i == m) {
+                    return true;
+                }
+            }
+            j++;
+        }
+        return false;
+    }
+}
+```

LeetCodeNet/G0301_0400/S0399_evaluate_division/readme.md

@@ -0,0 +1,115 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 399\. Evaluate Division
+
+Medium
+
+You are given an array of variable pairs `equations` and an array of real numbers `values`, where <code>equations[i] = [A<sub>i</sub>, B<sub>i</sub>]</code> and `values[i]` represent the equation <code>A<sub>i</sub> / B<sub>i</sub> = values[i]</code>. Each <code>A<sub>i</sub></code> or <code>B<sub>i</sub></code> is a string that represents a single variable.
+
+You are also given some `queries`, where <code>queries[j] = [C<sub>j</sub>, D<sub>j</sub>]</code> represents the <code>j<sup>th</sup></code> query where you must find the answer for <code>C<sub>j</sub> / D<sub>j</sub> = ?</code>.
+
+Return _the answers to all queries_. If a single answer cannot be determined, return `-1.0`.
+
+**Note:** The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.
+
+**Example 1:**
+
+**Input:** equations = \[\["a","b"],["b","c"]], values = [2.0,3.0], queries = \[\["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
+
+**Output:** [6.00000,0.50000,-1.00000,1.00000,-1.00000]
+
+**Explanation:**
+
+Given: _a / b = 2.0_, _b / c = 3.0_
+
+queries are: _a / c = ?_, _b / a = ?_, _a / e = ?_, _a / a = ?_, _x / x = ?_
+
+return: [6.0, 0.5, -1.0, 1.0, -1.0 ]
+
+**Example 2:**
+
+**Input:** equations = \[\["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = \[\["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
+
+**Output:** [3.75000,0.40000,5.00000,0.20000]
+
+**Example 3:**
+
+**Input:** equations = \[\["a","b"]], values = [0.5], queries = \[\["a","b"],["b","a"],["a","c"],["x","y"]]
+
+**Output:** [0.50000,2.00000,-1.00000,-1.00000]
+
+**Constraints:**
+
+*   `1 <= equations.length <= 20`
+*   `equations[i].length == 2`
+*   <code>1 <= A<sub>i</sub>.length, B<sub>i</sub>.length <= 5</code>
+*   `values.length == equations.length`
+*   `0.0 < values[i] <= 20.0`
+*   `1 <= queries.length <= 20`
+*   `queries[i].length == 2`
+*   <code>1 <= C<sub>j</sub>.length, D<sub>j</sub>.length <= 5</code>
+*   <code>A<sub>i</sub>, B<sub>i</sub>, C<sub>j</sub>, D<sub>j</sub></code> consist of lower case English letters and digits.
+
+## Solution
+
+```csharp
+using System;
+using System.Collections.Generic;
+
+public class Solution {
+    private Dictionary<string, string> root;
+    private Dictionary<string, double> rate;
+
+    public double[] CalcEquation(
+            IList<IList<string>> equations, double[] values, IList<IList<string>> queries) {
+        root = new Dictionary<string, string>();
+        rate = new Dictionary<string, double>();
+        int n = equations.Count;
+        foreach (var equation in equations) {
+            string x = equation[0];
+            string y = equation[1];
+            root[x] = x;
+            root[y] = y;
+            rate[x] = 1.0;
+            rate[y] = 1.0;
+        }
+        for (int i = 0; i < n; ++i) {
+            string x = equations[i][0];
+            string y = equations[i][1];
+            union(x, y, values[i]);
+        }
+        double[] result = new double[queries.Count];
+        for (int i = 0; i < queries.Count; ++i) {
+            string x = queries[i][0];
+            string y = queries[i][1];
+            if (!root.ContainsKey(x) || !root.ContainsKey(y)) {
+                result[i] = -1;
+                continue;
+            }
+            string rootX = findRoot(x, x, 1.0);
+            string rootY = findRoot(y, y, 1.0);
+            result[i] = rootX.Equals(rootY) ? rate[x] / rate[y] : -1.0; 
+        }
+        return result;
+    }
+
+    private void union(string x, string y, double v) {
+        string rootX = findRoot(x, x, 1.0);
+        string rootY = findRoot(y, y, 1.0);
+        root[rootX] = rootY;
+        double r1 = rate[x];
+        double r2 = rate[y];
+        rate[rootX] = v * r2 / r1;
+    }
+
+    private string findRoot(string originalX, string x, double r) {
+        if (root[x].Equals(x)) {
+            root[originalX] = x;
+            rate[originalX] = r * rate[x];
+            return x;
+        }
+        return findRoot(originalX, root[x], r * rate[x]);
+    }
+}
+```

LeetCodeNet/G0401_0500/S0427_construct_quad_tree/readme.md

@@ -0,0 +1,218 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 427\. Construct Quad Tree
+
+Medium
+
+Given a `n * n` matrix `grid` of `0's` and `1's` only. We want to represent the `grid` with a Quad-Tree.
+
+Return _the root of the Quad-Tree_ representing the `grid`.
+
+Notice that you can assign the value of a node to **True** or **False** when `isLeaf` is **False**, and both are **accepted** in the answer.
+
+A Quad-Tree is a tree data structure in which each internal node has exactly four children. Besides, each node has two attributes:
+
+*   `val`: True if the node represents a grid of 1's or False if the node represents a grid of 0's.
+*   `isLeaf`: True if the node is leaf node on the tree or False if the node has the four children.
+```
+    class Node {
+        public boolean val;
+        public boolean isLeaf;
+        public Node topLeft;
+        public Node topRight;
+        public Node bottomLeft;
+        public Node bottomRight;
+    }
+```
+We can construct a Quad-Tree from a two-dimensional area using the following steps:
+
+1.  If the current grid has the same value (i.e all `1's` or all `0's`) set `isLeaf` True and set `val` to the value of the grid and set the four children to Null and stop.
+2.  If the current grid has different values, set `isLeaf` to False and set `val` to any value and divide the current grid into four sub-grids as shown in the photo.
+3.  Recurse for each of the children with the proper sub-grid.
+
+![](https://assets.leetcode.com/uploads/2020/02/11/new_top.png)
+
+If you want to know more about the Quad-Tree, you can refer to the [wiki](https://en.wikipedia.org/wiki/Quadtree).
+
+**Quad-Tree format:**
+
+The output represents the serialized format of a Quad-Tree using level order traversal, where `null` signifies a path terminator where no node exists below.
+
+It is very similar to the serialization of the binary tree. The only difference is that the node is represented as a list `[isLeaf, val]`.
+
+If the value of `isLeaf` or `val` is True we represent it as **1** in the list `[isLeaf, val]` and if the value of `isLeaf` or `val` is False we represent it as **0**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/02/11/grid1.png)
+
+**Input:** grid = \[\[0,1],[1,0]]
+
+**Output:** [[0,1],[1,0],[1,1],[1,1],[1,0]]
+
+**Explanation:**
+
+    The explanation of this example is shown below:
+    Notice that 0 represnts False and 1 represents True in the photo representing the Quad-Tree.
+
+![](https://assets.leetcode.com/uploads/2020/02/12/e1tree.png) 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/02/12/e2mat.png)
+
+**Input:** grid = \[\[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]]
+
+**Output:** [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
+
+**Explanation:**
+
+    All values in the grid are not the same. We divide the grid into four sub-grids.
+    The topLeft, bottomLeft and bottomRight each has the same value.
+    The topRight have different values so we divide it into 4 sub-grids where each has the same value.
+    Explanation is shown in the photo below:
+    
+![](https://assets.leetcode.com/uploads/2020/02/12/e2tree.png) 
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   <code>n == 2<sup>x</sup></code> where `0 <= x <= 6`
+
+## Solution
+
+```csharp
+using System.Text;
+
+public class Node {
+    public bool val;
+    public bool isLeaf;
+    public Node? topLeft;
+    public Node? topRight;
+    public Node? bottomLeft;
+    public Node? bottomRight;
+
+    public Node(bool val, bool isLeaf) {
+        this.val = val;
+        this.isLeaf = isLeaf;
+        this.topLeft = null;
+        this.topRight = null;
+        this.bottomLeft = null;
+        this.bottomRight = null;
+    }
+
+    public Node(
+        bool val,
+        bool isLeaf,
+        Node? topLeft,
+        Node? topRight,
+        Node? bottomLeft,
+        Node? bottomRight) {
+        this.val = val;
+        this.isLeaf = isLeaf;
+        this.topLeft = topLeft;
+        this.topRight = topRight;
+        this.bottomLeft = bottomLeft;
+        this.bottomRight = bottomRight;
+    }
+
+    public override string ToString() {
+        StringBuilder sb = new StringBuilder();
+        sb.Append(GetNodeString(this));
+        sb.Append(GetNodeString(topLeft));
+        sb.Append(GetNodeString(topRight));
+        sb.Append(GetNodeString(bottomLeft));
+        sb.Append(GetNodeString(bottomRight));
+        return sb.ToString();
+    }
+
+    private string GetNodeString(Node? node) {
+        if (node == null) {
+            return "[]";
+        }
+        return $"[{(node.isLeaf ? "1" : "0")},{(node.val ? "1" : "0")}]";
+    }
+}
+
+/*
+// Definition for a QuadTree node.
+public class Node {
+    public bool val;
+    public bool isLeaf;
+    public Node topLeft;
+    public Node topRight;
+    public Node bottomLeft;
+    public Node bottomRight;
+
+    public Node() {
+        val = false;
+        isLeaf = false;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val, bool _isLeaf) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val,bool _isLeaf,Node _topLeft,Node _topRight,Node _bottomLeft,Node _bottomRight) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = _topLeft;
+        topRight = _topRight;
+        bottomLeft = _bottomLeft;
+        bottomRight = _bottomRight;
+    }
+}
+*/
+public class Solution {
+    public Node Construct(int[][] grid) {
+        return OptimizedDfs(grid, 0, 0, grid.Length);
+    }
+
+    private Node OptimizedDfs(int[][] grid, int rowStart, int colStart, int len) {
+        int zeroCount = 0;
+        int oneCount = 0;
+        for (int row = rowStart; row < rowStart + len; row++) {
+            bool isBreak = false;
+            for (int col = colStart; col < colStart + len; col++) {
+                if (grid[row][col] == 0) {
+                    zeroCount++;
+                } else {
+                    oneCount++;
+                }
+                if (oneCount > 0 && zeroCount > 0) {
+                    // We really no need to scan all.
+                    // Once we know there are both 0 and 1 then we can break.
+                    isBreak = true;
+                    break;
+                }
+            }
+            if (isBreak) {
+                break;
+            }
+        }
+        if (oneCount > 0 && zeroCount > 0) {
+            int midLen = len / 2;
+            Node topLeft = OptimizedDfs(grid, rowStart, colStart, midLen);
+            Node topRight = OptimizedDfs(grid, rowStart, colStart + midLen, midLen);
+            Node bottomLeft = OptimizedDfs(grid, rowStart + midLen, colStart, midLen);
+            Node bottomRight = OptimizedDfs(grid, rowStart + midLen, colStart + midLen, midLen);
+            bool isLeaf = false;
+            return new Node(true, isLeaf, topLeft, topRight, bottomLeft, bottomRight);
+        } else {
+            bool resultVal = oneCount > 0;
+            bool isLeaf = true;
+            return new Node(resultVal, isLeaf);
+        }
+    }
+}
+```