Added tasks 129-162

Author: javadev

LeetCodeNet/G0101_0200/S0129_sum_root_to_leaf_numbers/readme.md

@@ -0,0 +1,83 @@
+[![](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)
+
+## 129\. Sum Root to Leaf Numbers
+
+Medium
+
+You are given the `root` of a binary tree containing digits from `0` to `9` only.
+
+Each root-to-leaf path in the tree represents a number.
+
+*   For example, the root-to-leaf path `1 -> 2 -> 3` represents the number `123`.
+
+Return _the total sum of all root-to-leaf numbers_. Test cases are generated so that the answer will fit in a **32-bit** integer.
+
+A **leaf** node is a node with no children.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 25
+
+**Explanation:** The root-to-leaf path `1->2` represents the number `12`. The root-to-leaf path `1->3` represents the number `13`. Therefore, sum = 12 + 13 = `25`. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg)
+
+**Input:** root = [4,9,0,5,1]
+
+**Output:** 1026
+
+**Explanation:** The root-to-leaf path `4->9->5` represents the number 495. The root-to-leaf path `4->9->1` represents the number 491. The root-to-leaf path `4->0` represents the number 40. Therefore, sum = 495 + 491 + 40 = `1026`. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `0 <= Node.val <= 9`
+*   The depth of the tree will not exceed `10`.
+
+## Solution
+
+```csharp
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    private int sum = 0;
+
+    public int SumNumbers(TreeNode root) {
+        RecurseSum(root, 0);
+        return sum;
+    }
+
+    private void RecurseSum(TreeNode node, int curNum) {
+        if (node.left == null && node.right == null) {
+            sum += 10 * curNum + node.val.Value;
+        } else {
+            if (node.left != null) {
+                RecurseSum(node.left, 10 * curNum + node.val.Value);
+            }
+            if (node.right != null) {
+                RecurseSum(node.right, 10 * curNum + node.val.Value);
+            }
+        }
+    }
+}
+```

LeetCodeNet/G0101_0200/S0130_surrounded_regions/readme.md

@@ -0,0 +1,82 @@
+[![](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)
+
+## 130\. Surrounded Regions
+
+Medium
+
+Given an `m x n` matrix `board` containing `'X'` and `'O'`, _capture all regions that are 4-directionally surrounded by_ `'X'`.
+
+A region is **captured** by flipping all `'O'`s into `'X'`s in that surrounded region.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/xogrid.jpg)
+
+**Input:** board = \[\["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
+
+**Output:** [["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
+
+**Explanation:** Surrounded regions should not be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically. 
+
+**Example 2:**
+
+**Input:** board = \[\["X"]]
+
+**Output:** [["X"]] 
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 200`
+*   `board[i][j]` is `'X'` or `'O'`.
+
+## Solution
+
+```csharp
+public class Solution {
+    public void Solve(char[][] board) {
+        if (board.Length == 0) {
+            return;
+        }
+        for (int i = 0; i < board[0].Length; i++) {
+            if (board[0][i] == 'O') {
+                Dfs(board, 0, i);
+            }
+            if (board[board.Length - 1][i] == 'O') {
+                Dfs(board, board.Length - 1, i);
+            }
+        }
+        for (int i = 0; i < board.Length; i++) {
+            if (board[i][0] == 'O') {
+                Dfs(board, i, 0);
+            }
+            if (board[i][board[0].Length - 1] == 'O') {
+                Dfs(board, i, board[0].Length - 1);
+            }
+        }
+        for (int i = 0; i < board.Length; i++) {
+            for (int j = 0; j < board[0].Length; j++) {
+                if (board[i][j] == 'O') {
+                    board[i][j] = 'X';
+                }
+                if (board[i][j] == '#') {
+                    board[i][j] = 'O';
+                }
+            }
+        }
+    }
+
+    private void Dfs(char[][] board, int row, int column) {
+        if (row < 0 || row >= board.Length || column < 0 || column >= board[0].Length || board[row][column] != 'O') {
+            return;
+        }
+        board[row][column] = '#';
+        Dfs(board, row + 1, column);
+        Dfs(board, row - 1, column);
+        Dfs(board, row, column + 1);
+        Dfs(board, row, column - 1);
+    }
+}
+```

LeetCodeNet/G0101_0200/S0133_clone_graph/readme.md

@@ -0,0 +1,122 @@
+[![](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)
+
+## 133\. Clone Graph
+
+Medium
+
+Given a reference of a node in a **[connected](https://en.wikipedia.org/wiki/Connectivity_(graph_theory)#Connected_graph)** undirected graph.
+
+Return a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) (clone) of the graph.
+
+Each node in the graph contains a value (`int`) and a list (`List[Node]`) of its neighbors.
+
+class Node { public int val; public List<Node> neighbors; } 
+
+**Test case format:**
+
+For simplicity, each node's value is the same as the node's index (1-indexed). For example, the first node with `val == 1`, the second node with `val == 2`, and so on. The graph is represented in the test case using an adjacency list.
+
+**An adjacency list** is a collection of unordered **lists** used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.
+
+The given node will always be the first node with `val = 1`. You must return the **copy of the given node** as a reference to the cloned graph.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/11/04/133_clone_graph_question.png)
+
+**Input:** adjList = \[\[2,4],[1,3],[2,4],[1,3]]
+
+**Output:** [[2,4],[1,3],[2,4],[1,3]]
+
+**Explanation:**
+
+    There are 4 nodes in the graph.
+    1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+    2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+    3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+    4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3). 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/01/07/graph.png)
+
+**Input:** adjList = \[\[]]
+
+**Output:** [[]]
+
+**Explanation:** Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors. 
+
+**Example 3:**
+
+**Input:** adjList = []
+
+**Output:** []
+
+**Explanation:** This an empty graph, it does not have any nodes. 
+
+**Example 4:**
+
+![](https://assets.leetcode.com/uploads/2020/01/07/graph-1.png)
+
+**Input:** adjList = \[\[2],[1]]
+
+**Output:** [[2],[1]] 
+
+**Constraints:**
+
+*   The number of nodes in the graph is in the range `[0, 100]`.
+*   `1 <= Node.val <= 100`
+*   `Node.val` is unique for each node.
+*   There are no repeated edges and no self-loops in the graph.
+*   The Graph is connected and all nodes can be visited starting from the given node.
+
+## Solution
+
+```csharp
+public class Node {
+    public int val;
+    public IList<Node> neighbors;
+
+    public Node() {
+        val = 0;
+        neighbors = new List<Node>();
+    }
+
+    public Node(int _val) {
+        val = _val;
+        neighbors = new List<Node>();
+    }
+
+    public Node(int _val, List<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+
+    public override string ToString() {
+        var result = new System.Text.StringBuilder();
+        result.Append("[");
+        bool first = true;
+        foreach (var node in neighbors) {
+            if (!first) result.Append(",");
+            if (node.neighbors == null || node.neighbors.Count == 0) {
+                result.Append(node.val);
+            } else {
+                var inner = new System.Text.StringBuilder();
+                inner.Append("[");
+                bool innerFirst = true;
+                foreach (var nodeItem in node.neighbors) {
+                    if (!innerFirst) inner.Append(",");
+                    inner.Append(nodeItem.val);
+                    innerFirst = false;
+                }
+                inner.Append("]");
+                result.Append(inner.ToString());
+            }
+            first = false;
+        }
+        result.Append("]");
+        return result.ToString();
+    }
+}
+```

LeetCodeNet/G0101_0200/S0134_gas_station/readme.md

@@ -0,0 +1,72 @@
+[![](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)
+
+## 134\. Gas Station
+
+Medium
+
+There are `n` gas stations along a circular route, where the amount of gas at the <code>i<sup>th</sup></code> station is `gas[i]`.
+
+You have a car with an unlimited gas tank and it costs `cost[i]` of gas to travel from the <code>i<sup>th</sup></code> station to its next <code>(i + 1)<sup>th</sup></code> station. You begin the journey with an empty tank at one of the gas stations.
+
+Given two integer arrays `gas` and `cost`, return _the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return_ `-1`. If there exists a solution, it is **guaranteed** to be **unique**
+
+**Example 1:**
+
+**Input:** gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+
+**Output:** 3
+
+**Explanation:**
+
+    Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+    Travel to station 4. Your tank = 4 - 1 + 5 = 8
+    Travel to station 0. Your tank = 8 - 2 + 1 = 7
+    Travel to station 1. Your tank = 7 - 3 + 2 = 6
+    Travel to station 2. Your tank = 6 - 4 + 3 = 5
+    Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
+    Therefore, return 3 as the starting index. 
+
+**Example 2:**
+
+**Input:** gas = [2,3,4], cost = [3,4,3]
+
+**Output:** -1
+
+**Explanation:**
+
+    You can't start at station 0 or 1, as there is not enough gas to travel to the next station.
+    Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+    Travel to station 0. Your tank = 4 - 3 + 2 = 3
+    Travel to station 1. Your tank = 3 - 3 + 3 = 3
+    You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
+    Therefore, you can't travel around the circuit once no matter where you start. 
+
+**Constraints:**
+
+*   `gas.length == n`
+*   `cost.length == n`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= gas[i], cost[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public int CanCompleteCircuit(int[] gas, int[] cost) {
+        int index = 0;
+        int total = 0;
+        int current = 0;
+        for (int i = 0; i < gas.Length; i++) {
+            int balance = gas[i] - cost[i];
+            total += balance;
+            current += balance;
+            if (current < 0) {
+                index = i + 1;
+                current = 0;
+            }
+        }
+        return total >= 0 ? index : -1;
+    }
+}
+```