Added tasks 209-219

Author: ThanhNIT

LeetCodeNet.Tests/G0201_0300/S0209_minimum_size_subarray_sum/SolutionTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0201_0300.S0209_minimum_size_subarray_sum {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void MinSubArrayLen() {
+        Assert.Equal(2, new Solution().MinSubArrayLen(7, new int[] {2, 3, 1, 2, 4, 3}));
+    }
+
+    [Fact]
+    public void MinSubArrayLen2() {
+        Assert.Equal(1, new Solution().MinSubArrayLen(4, new int[] {1, 4, 4}));
+    }
+
+    [Fact]
+    public void MinSubArrayLen3() {
+        Assert.Equal(0, new Solution().MinSubArrayLen(11, new int[] {1, 1, 1, 1, 1, 1, 1, 1}));
+    }
+}
+}

LeetCodeNet.Tests/G0201_0300/S0210_course_schedule_ii/SolutionTest.cs

@@ -0,0 +1,27 @@
+namespace LeetCodeNet.G0201_0300.S0210_course_schedule_ii {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void CourseScheduleII() {
+        int[][] prerequisites = new int[][] { new int[] {1, 0} };
+        int numCourses = 2;
+        Assert.Equal(new int[] {0, 1}, new Solution().FindOrder(numCourses, prerequisites));
+    }
+
+    [Fact]
+    public void CourseScheduleII2() {
+        int[][] prerequisites = new int[][] { new int[] {1, 0}, new int[] {2, 0}, new int[] {3, 1}, new int[] {3, 2} };
+        int numCourses = 4;
+        Assert.Equal(new int[] {0, 1, 2, 3}, new Solution().FindOrder(numCourses, prerequisites));
+    }
+
+    [Fact]
+    public void CourseScheduleII3() {
+        int[][] prerequisites = new int[][] { };
+        int numCourses = 1;
+        Assert.Equal(new int[] {0}, new Solution().FindOrder(numCourses, prerequisites));
+    }
+}
+}

LeetCodeNet.Tests/G0201_0300/S0211_design_add_and_search_words_data_structure/WordDictionaryTest.cs

@@ -0,0 +1,19 @@
+namespace LeetCodeNet.G0201_0300.S0211_design_add_and_search_words_data_structure {
+
+using Xunit;
+
+public class WordDictionaryTest {
+    [Fact]
+    public void WorldDataStructure() {
+        string[] input = {"bad", "dad", "mad"};
+        var dictionary = new WordDictionary();
+        foreach (var s in input) {
+            dictionary.AddWord(s);
+        }
+        Assert.False(dictionary.Search("pad"));
+        Assert.True(dictionary.Search("bad"));
+        Assert.True(dictionary.Search(".ad"));
+        Assert.True(dictionary.Search("b.."));
+    }
+}
+}

LeetCodeNet.Tests/G0201_0300/S0212_word_search_ii/SolutionTest.cs

@@ -0,0 +1,32 @@
+namespace LeetCodeNet.G0201_0300.S0212_word_search_ii {
+
+using System.Collections.Generic;
+using Xunit;
+
+public class SolutionTest {    
+    [Fact]
+    public void FindWords() {
+        char[][] board = {
+            new[] { 'o', 'a', 'a', 'n' },
+            new[] { 'e', 't', 'a', 'e' },
+            new[] { 'i', 'h', 'k', 'r' },
+            new[] { 'i', 'f', 'l', 'v' }
+        };
+        string[] words = { "oath", "pea", "eat", "rain" };
+        var expected = new List<string> { "oath", "eat" };
+        var result = new Solution().FindWords(board, words);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void FindWords2() {
+        char[][] board = {
+            new[] { 'a', 'b' },
+            new[] { 'c', 'd' }
+        };
+        string[] words = { "abcb" };
+        var result = new Solution().FindWords(board, words);
+        Assert.Empty(result);
+    }
+}
+}

LeetCodeNet.Tests/G0201_0300/S0219_contains_duplicate_ii/SolutionTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0201_0300.S0219_contains_duplicate_ii {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void ContainsNearbyDuplicate() {
+        Assert.True(new Solution().ContainsNearbyDuplicate(new[] { 1, 2, 3, 1 }, 3));
+    }
+
+    [Fact]
+    public void ContainsNearbyDuplicate2() {
+        Assert.True(new Solution().ContainsNearbyDuplicate(new[] { 1, 0, 1, 1 }, 1));
+    }
+
+    [Fact]
+    public void ContainsNearbyDuplicate3() {
+        Assert.False(new Solution().ContainsNearbyDuplicate(new[] { 1, 2, 3, 1, 2, 3 }, 2));
+    }
+}
+}

LeetCodeNet/G0201_0300/S0209_minimum_size_subarray_sum/Solution.cs

@@ -0,0 +1,30 @@
+namespace LeetCodeNet.G0201_0300.S0209_minimum_size_subarray_sum {
+
+// #Medium #Array #Binary_Search #Prefix_Sum #Sliding_Window #Algorithm_II_Day_5_Sliding_Window
+// #Binary_Search_II_Day_1 #Top_Interview_150_Sliding_Window
+// #2025_07_14_Time_0_ms_(100.00%)_Space_52.33_MB_(91.45%)
+
+public class Solution {
+    public int MinSubArrayLen(int target, int[] nums) {
+        int i = 0, j = 0, sum = 0, min = int.MaxValue;
+        while (j < nums.Length) {
+            sum += nums[j];
+            if (sum >= target) {
+                while (i <= j) {
+                    if (sum - nums[i] >= target) {
+                        sum -= nums[i];
+                        i++;
+                    } else {
+                        break;
+                    }
+                }
+                if (j - i + 1 < min) {
+                    min = j - i + 1;
+                }
+            }
+            j++;
+        }
+        return min == int.MaxValue ? 0 : min;
+    }
+}
+}

LeetCodeNet/G0201_0300/S0209_minimum_size_subarray_sum/readme.md

@@ -0,0 +1,33 @@
+209\. Minimum Size Subarray Sum
+
+Medium
+
+Given an array of positive integers `nums` and a positive integer `target`, return the minimal length of a **contiguous subarray** <code>[nums<sub>l</sub>, nums<sub>l+1</sub>, ..., nums<sub>r-1</sub>, nums<sub>r</sub>]</code> of which the sum is greater than or equal to `target`. If there is no such subarray, return `0` instead.
+
+**Example 1:**
+
+**Input:** target = 7, nums = [2,3,1,2,4,3]
+
+**Output:** 2
+
+**Explanation:** The subarray [4,3] has the minimal length under the problem constraint. 
+
+**Example 2:**
+
+**Input:** target = 4, nums = [1,4,4]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** target = 11, nums = [1,1,1,1,1,1,1,1]
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>1 <= target <= 10<sup>9</sup></code>
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+
+**Follow up:** If you have figured out the `O(n)` solution, try coding another solution of which the time complexity is `O(n log(n))`.

LeetCodeNet/G0201_0300/S0210_course_schedule_ii/Solution.cs

@@ -0,0 +1,43 @@
+namespace LeetCodeNet.G0201_0300.S0210_course_schedule_ii {
+
+// #Medium #Top_Interview_Questions #Depth_First_Search #Breadth_First_Search #Graph
+// #Topological_Sort #Level_2_Day_11_Graph/BFS/DFS #Top_Interview_150_Graph_General
+// #2025_07_14_Time_4_ms_(91.35%)_Space_53.47_MB_(15.48%)
+
+using System.Collections.Generic;
+
+public class Solution {
+    public int[] FindOrder(int numCourses, int[][] prerequisites) {
+        var graph = new Dictionary<int, List<int>>();
+        for (int i = 0; i < numCourses; i++) {
+            graph[i] = new List<int>();
+        }
+        foreach (var classes in prerequisites) {
+            graph[classes[0]].Add(classes[1]);
+        }
+        var output = new List<int>();
+        var visited = new Dictionary<int, bool>();
+        foreach (var c in graph.Keys) {
+            if (Dfs(c, graph, visited, output)) {
+                return new int[0];
+            }
+        }
+        return output.ToArray();
+    }
+
+    private bool Dfs(int course, Dictionary<int, List<int>> graph, Dictionary<int, bool> visited, List<int> output) {
+        if (visited.ContainsKey(course)) {
+            return visited[course];
+        }
+        visited[course] = true;
+        foreach (var c in graph[course]) {
+            if (Dfs(c, graph, visited, output)) {
+                return true;
+            }
+        }
+        visited[course] = false;
+        output.Add(course);
+        return false;
+    }
+}
+}

LeetCodeNet/G0201_0300/S0210_course_schedule_ii/readme.md

@@ -0,0 +1,46 @@
+210\. Course Schedule II
+
+Medium
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you **must** take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.
+
+*   For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+Return _the ordering of courses you should take to finish all courses_. If there are many valid answers, return **any** of them. If it is impossible to finish all courses, return **an empty array**.
+
+**Example 1:**
+
+**Input:** numCourses = 2, prerequisites = [[1,0]]
+
+**Output:** [0,1]
+
+**Explanation:**
+
+    There are a total of 2 courses to take. To take course 1 you should have finished course 0.
+    So the correct course order is [0,1].
+
+**Example 2:**
+
+**Input:** numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+
+**Output:** [0,2,1,3]
+
+**Explanation:**
+
+    There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
+    So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+
+**Example 3:**
+
+**Input:** numCourses = 1, prerequisites = []
+
+**Output:** [0] 
+
+**Constraints:**
+
+*   `1 <= numCourses <= 2000`
+*   `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
+*   `prerequisites[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   All the pairs <code>[a<sub>i</sub>, b<sub>i</sub>]</code> are **distinct**.

LeetCodeNet/G0201_0300/S0211_design_add_and_search_words_data_structure/WordDictionary.cs

@@ -0,0 +1,75 @@
+namespace LeetCodeNet.G0201_0300.S0211_design_add_and_search_words_data_structure {
+
+// #Medium #String #Depth_First_Search #Design #Trie #Top_Interview_150_Trie
+// #2025_07_14_Time_380_ms_(93.39%)_Space_147.60_MB_(63.66%)
+
+public class WordDictionary {
+    private class Node {
+        public Node[] kids = new Node[26];
+        public bool isTerminal;
+    }
+
+    private readonly Node[] root = new Node[26];
+
+    public WordDictionary() {
+        // empty constructor
+    }
+
+    public void AddWord(string word) {
+        int n = word.Length;
+        if (root[n] == null) {
+            root[n] = new Node();
+        }
+        Node node = root[n];
+        for (int i = 0; i < n; i++) {
+            int c = word[i] - 'a';
+            Node kid = node.kids[c];
+            if (kid == null) {
+                kid = new Node();
+                node.kids[c] = kid;
+            }
+            node = kid;
+        }
+        node.isTerminal = true;
+    }
+
+    public bool Search(string word) {
+        Node node = root[word.Length];
+        return node != null && Dfs(0, node, word);
+    }
+
+    private bool Dfs(int i, Node node, string word) {
+        int len = word.Length;
+        if (i == len) {
+            return false;
+        }
+        char c = word[i];
+        if (c == '.') {
+            foreach (Node kid in node.kids) {
+                if (kid == null) {
+                    continue;
+                }
+                if ((i == len - 1 && kid.isTerminal) || Dfs(i + 1, kid, word)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        Node next = node.kids[c - 'a'];
+        if (next == null) {
+            return false;
+        }
+        if (i == len - 1) {
+            return next.isTerminal;
+        }
+        return Dfs(i + 1, next, word);
+    }
+}
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary obj = new WordDictionary();
+ * obj.AddWord(word);
+ * bool param_2 = obj.Search(word);
+ */