Added tasks 120-127

Author: javadev

LeetCodeNet/G0101_0200/S0120_triangle/readme.md

@@ -0,0 +1,76 @@
+[![](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)
+
+## 120\. Triangle
+
+Medium
+
+Given a `triangle` array, return _the minimum path sum from top to bottom_.
+
+For each step, you may move to an adjacent number of the row below. More formally, if you are on index `i` on the current row, you may move to either index `i` or index `i + 1` on the next row.
+
+**Example 1:**
+
+**Input:** triangle = \[\[2],[3,4],[6,5,7],[4,1,8,3]]
+
+**Output:** 11
+
+**Explanation:**
+
+    The triangle looks like:
+        2
+       3 4
+      6 5 7
+     4 1 8 3
+     The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above). 
+
+**Example 2:**
+
+**Input:** triangle = \[\[-10]]
+
+**Output:** -10 
+
+**Constraints:**
+
+*   `1 <= triangle.length <= 200`
+*   `triangle[0].length == 1`
+*   `triangle[i].length == triangle[i - 1].length + 1`
+*   <code>-10<sup>4</sup> <= triangle[i][j] <= 10<sup>4</sup></code>
+
+**Follow up:** Could you do this using only `O(n)` extra space, where `n` is the total number of rows in the triangle?
+
+## Solution
+
+```csharp
+using System.Collections.Generic;
+
+public class Solution {
+    public int MinimumTotal(IList<IList<int>> triangle) {
+        if (triangle == null || triangle.Count == 0) {
+            return 0;
+        }
+        int n = triangle.Count;
+        int[][] dp = new int[n][];
+        for (int i = 0; i < n; i++) {
+            dp[i] = new int[triangle[n - 1].Count];
+            for (int j = 0; j < dp[i].Length; j++) {
+                dp[i][j] = -10001;
+            }
+        }
+        return Dfs(triangle, dp, 0, 0);
+    }
+
+    private int Dfs(IList<IList<int>> triangle, int[][] dp, int row, int col) {
+        if (row >= triangle.Count) {
+            return 0;
+        }
+        if (dp[row][col] != -10001) {
+            return dp[row][col];
+        }
+        int sum = triangle[row][col] +
+            System.Math.Min(Dfs(triangle, dp, row + 1, col), Dfs(triangle, dp, row + 1, col + 1));
+        dp[row][col] = sum;
+        return sum;
+    }
+}
+```

LeetCodeNet/G0101_0200/S0122_best_time_to_buy_and_sell_stock_ii/readme.md

@@ -0,0 +1,57 @@
+[![](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)
+
+## 122\. Best Time to Buy and Sell Stock II
+
+Medium
+
+You are given an integer array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+On each day, you may decide to buy and/or sell the stock. You can only hold **at most one** share of the stock at any time. However, you can buy it then immediately sell it on the **same day**.
+
+Find and return _the **maximum** profit you can achieve_.
+
+**Example 1:**
+
+**Input:** prices = [7,1,5,3,6,4]
+
+**Output:** 7
+
+**Explanation:** Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4. Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3. Total profit is 4 + 3 = 7. 
+
+**Example 2:**
+
+**Input:** prices = [1,2,3,4,5]
+
+**Output:** 4
+
+**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4. Total profit is 4. 
+
+**Example 3:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0. 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 3 * 10<sup>4</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        int max = 0;
+        for (int i = 1; i < prices.Length; i++) {
+            if (prices[i] > prices[i - 1]) {
+                max += prices[i] - prices[i - 1];
+            }
+        }
+        return max;
+    }
+}
+```

LeetCodeNet/G0101_0200/S0123_best_time_to_buy_and_sell_stock_iii/readme.md

@@ -0,0 +1,70 @@
+[![](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)
+
+## 123\. Best Time to Buy and Sell Stock III
+
+Hard
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+Find the maximum profit you can achieve. You may complete **at most two transactions**.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+**Input:** prices = [3,3,5,0,0,3,1,4]
+
+**Output:** 6
+
+**Explanation:** Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3. Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
+
+**Example 2:**
+
+**Input:** prices = [1,2,3,4,5]
+
+**Output:** 4
+
+**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4. Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again. 
+
+**Example 3:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** In this case, no transaction is done, i.e. max profit = 0. 
+
+**Example 4:**
+
+**Input:** prices = [1]
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        if (prices.Length == 0) {
+            return 0;
+        }
+        int fb = int.MinValue;
+        int sb = int.MinValue;
+        int fs = 0;
+        int ss = 0;
+        foreach (int price in prices) {
+            fb = System.Math.Max(fb, -price);
+            fs = System.Math.Max(fs, fb + price);
+            sb = System.Math.Max(sb, fs - price);
+            ss = System.Math.Max(ss, sb + price);
+        }
+        return ss;
+    }
+}
+```

LeetCodeNet/G0101_0200/S0125_valid_palindrome/readme.md

@@ -0,0 +1,85 @@
+[![](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)
+
+## 125\. Valid Palindrome
+
+Easy
+
+A phrase is a **palindrome** if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.
+
+Given a string `s`, return `true` _if it is a **palindrome**, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s = "A man, a plan, a canal: Panama"
+
+**Output:** true
+
+**Explanation:** "amanaplanacanalpanama" is a palindrome. 
+
+**Example 2:**
+
+**Input:** s = "race a car"
+
+**Output:** false
+
+**Explanation:** "raceacar" is not a palindrome. 
+
+**Example 3:**
+
+**Input:** s = " "
+
+**Output:** true
+
+**Explanation:** s is an empty string "" after removing non-alphanumeric characters. Since an empty string reads the same forward and backward, it is a palindrome. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 2 * 10<sup>5</sup></code>
+*   `s` consists only of printable ASCII characters.
+
+## Solution
+
+```csharp
+public class Solution {
+    public bool IsPalindrome(string s) {
+        int i = 0;
+        int j = s.Length - 1;
+        bool res = true;
+        while (res) {
+            while (i < j && IsNotAlphaNumeric(s[i])) {
+                i++;
+            }
+            while (i < j && IsNotAlphaNumeric(s[j])) {
+                j--;
+            }
+            if (i >= j) {
+                break;
+            }
+            char left = UpperToLower(s[i]);
+            char right = UpperToLower(s[j]);
+            if (left != right) {
+                res = false;
+            }
+            i++;
+            j--;
+        }
+        return res;
+    }
+
+    private bool IsNotAlphaNumeric(char c) {
+        return (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9');
+    }
+
+    private bool IsUpper(char c) {
+        return c >= 'A' && c <= 'Z';
+    }
+
+    private char UpperToLower(char c) {
+        if (IsUpper(c)) {
+            c = (char)(c + 32);
+        }
+        return c;
+    }
+}
+```

LeetCodeNet/G0101_0200/S0127_word_ladder/readme.md

@@ -0,0 +1,91 @@
+[![](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)
+
+## 127\. Word Ladder
+
+Hard
+
+A **transformation sequence** from word `beginWord` to word `endWord` using a dictionary `wordList` is a sequence of words <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> such that:
+
+*   Every adjacent pair of words differs by a single letter.
+*   Every <code>s<sub>i</sub></code> for `1 <= i <= k` is in `wordList`. Note that `beginWord` does not need to be in `wordList`.
+*   <code>s<sub>k</sub> == endWord</code>
+
+Given two words, `beginWord` and `endWord`, and a dictionary `wordList`, return _the **number of words** in the **shortest transformation sequence** from_ `beginWord` _to_ `endWord`_, or_ `0` _if no such sequence exists._
+
+**Example 1:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
+
+**Output:** 5
+
+**Explanation:** One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> cog", which is 5 words long. 
+
+**Example 2:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
+
+**Output:** 0
+
+**Explanation:** The endWord "cog" is not in wordList, therefore there is no valid transformation sequence. 
+
+**Constraints:**
+
+*   `1 <= beginWord.length <= 10`
+*   `endWord.length == beginWord.length`
+*   `1 <= wordList.length <= 5000`
+*   `wordList[i].length == beginWord.length`
+*   `beginWord`, `endWord`, and `wordList[i]` consist of lowercase English letters.
+*   `beginWord != endWord`
+*   All the words in `wordList` are **unique**.
+
+## Solution
+
+```csharp
+using System.Collections.Generic;
+
+public class Solution {
+    public int LadderLength(string beginWord, string endWord, IList<string> wordDict) {
+        var beginSet = new HashSet<string>();
+        var endSet = new HashSet<string>();
+        var wordSet = new HashSet<string>(wordDict);
+        var visited = new HashSet<string>();
+        if (!wordDict.Contains(endWord)) {
+            return 0;
+        }
+        int len = 1;
+        int strLen = beginWord.Length;
+        beginSet.Add(beginWord);
+        endSet.Add(endWord);
+        while (beginSet.Count > 0 && endSet.Count > 0) {
+            if (beginSet.Count > endSet.Count) {
+                var temp = beginSet;
+                beginSet = endSet;
+                endSet = temp;
+            }
+            var tempSet = new HashSet<string>();
+            foreach (var s in beginSet) {
+                char[] chars = s.ToCharArray();
+                for (int i = 0; i < strLen; i++) {
+                    char old = chars[i];
+                    for (char j = 'a'; j <= 'z'; j++) {
+                        chars[i] = j;
+                        string temp = new string(chars);
+                        if (endSet.Contains(temp)) {
+                            return len + 1;
+                        }
+                        if (!visited.Contains(temp) && wordSet.Contains(temp)) {
+                            tempSet.Add(temp);
+                            visited.Add(temp);
+                        }
+                    }
+                    chars[i] = old;
+                }
+            }
+            beginSet = tempSet;
+            len++;
+        }
+        return 0;
+    }
+}
+```