1

Author: lzl124631x

leetcode/1. Two Sum/README.md

@@ -0,0 +1,72 @@
+# [1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/submissions/)
+
+<p>Given an array of integers, return <strong>indices</strong> of the two numbers such that they add up to a specific target.</p>
+
+<p>You may assume that each input would have <strong><em>exactly</em></strong> one solution, and you may not use the <em>same</em> element twice.</p>
+
+<p><strong>Example:</strong></p>
+
+<pre>Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[<strong>0</strong>] + nums[<strong>1</strong>] = 2 + 7 = 9,
+return [<strong>0</strong>, <strong>1</strong>].
+</pre>
+
+
+**Related Topics**:  
+[Array](https://leetcode.com/tag/array/), [Hash Table](https://leetcode.com/tag/hash-table/)
+
+**Similar Questions**:
+* [3Sum (Medium)](https://leetcode.com/problems/3sum/)
+* [4Sum (Medium)](https://leetcode.com/problems/4sum/)
+* [Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/)
+* [Two Sum III - Data structure design (Easy)](https://leetcode.com/problems/two-sum-iii-data-structure-design/)
+* [Subarray Sum Equals K (Medium)](https://leetcode.com/problems/subarray-sum-equals-k/)
+* [Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/)
+* [Two Sum Less Than K (Easy)](https://leetcode.com/problems/two-sum-less-than-k/)
+
+## Solution 1.
+
+```cpp
+// OJ: https://leetcode.com/problems/two-sum/
+// Author: github.com/lzl124631x
+// Time: O(NlogN)
+// Space: O(N)
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& A, int target) {
+        vector<vector<int>> v; 
+        int N = A.size(), L = 0, R = N - 1;
+        for (int i = 0; i < N; ++i) v.push_back({ A[i], i });
+        sort(begin(v), end(v), [](const vector<int> &a, const vector<int> &b) { return a[0] < b[0]; });
+        while (L < R) {
+            int sum = v[L][0] + v[R][0];
+            if (sum == target) return { v[L][1], v[R][1] };
+            if (sum < target) ++L;
+            else --R;
+        }
+        return {};
+    }
+};
+```
+
+## Solution 2.
+
+```cpp
+// OJ: https://leetcode.com/problems/two-sum/
+// Author: github.com/lzl124631x
+// Time: O(N)
+// Space: O(N)
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& A, int target) {
+        unordered_map<int, int> m;
+        for (int i = 0; i < A.size(); ++i) {
+            int t = target - A[i];
+            if (m.count(t)) return { m[t], i };
+            m[A[i]] = i;
+        }
+        return {};
+    }
+};
+```

leetcode/1. Two Sum/s1.cpp

@@ -0,0 +1,51 @@
+class Solution {
+public:
+    vector<string> braceExpansionII(string s) {
+        stack<pair<bool, vector<string>>> ans; // bool -> isList
+        vector<string> init{""};
+        ans.push(make_pair(false, init));
+        for (int i = 0; i < s.size(); ++i) {
+            if (isalpha(s[i])) {
+                if (ans.top().first) {
+                    vector<string> tmp{ string(1, s[i]) };
+                    ans.push(make_pair(false, tmp));
+                } else {
+                    for (auto &a : ans.top().second) a += s[i];
+                }
+            } else if (s[i] == '{') {
+                vector<string> tmp;
+                ans.push(make_pair(true, tmp));
+            } else { // , or }
+                auto top = ans.top();
+                ans.pop();
+                if (ans.top().first) {
+                    for (auto &a : top.second) ans.top().second.push_back(a);
+                } else {
+                    vector<string> tmp;
+                    for (auto &a : ans.top().second)
+                        for (auto &b : top.second)
+                            tmp.push_back(a + b);
+                    swap(tmp, ans.top().second);
+                }
+                if (s[i] == '}') {
+                    auto top = ans.top();
+                    ans.pop();
+                    if (ans.top().first) {
+                        for (auto &a : top.second) ans.top().second.push_back(a);
+                    } else {
+                        vector<string> tmp;
+                        for (auto &a : ans.top().second)
+                            for (auto &b : top.second)
+                                tmp.push_back(a + b);
+                        swap(tmp, ans.top().second);
+                    }
+                }
+            }
+            cout << i << endl;
+        }
+        auto &v = ans.top().second;
+        sort(v.begin(), v.end());
+        v.erase(unique(v.begin(), v.end()), v.end());
+        return v;
+    }
+};

leetcode/1. Two Sum/s2.cpp

@@ -0,0 +1,85 @@
+# [1223. Dice Roll Simulation (Medium)](https://leetcode.com/problems/dice-roll-simulation/)
+
+<p>A die simulator generates a random number from 1 to 6 for each roll.&nbsp;You introduced a constraint to the generator such that it cannot roll the number <code>i</code> more than <code>rollMax[i]</code> (1-indexed) <strong>consecutive</strong> times.&nbsp;</p>
+
+<p>Given an array of integers&nbsp;<code>rollMax</code>&nbsp;and an integer&nbsp;<code>n</code>, return the number of distinct sequences that can be obtained with exact <code>n</code> rolls.</p>
+
+<p>Two sequences are considered different if at least one element differs from each other. Since the answer&nbsp;may be too large,&nbsp;return it modulo <code>10^9 + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2, rollMax = [1,1,2,2,2,3]
+<strong>Output:</strong> 34
+<strong>Explanation:</strong> There will be 2 rolls of die, if there are no constraints on the die, there are 6 * 6 = 36 possible combinations. In this case, looking at rollMax array, the numbers 1 and 2 appear at most once consecutively, therefore sequences (1,1) and (2,2) cannot occur, so the final answer is 36-2 = 34.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 2, rollMax = [1,1,1,1,1,1]
+<strong>Output:</strong> 30
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, rollMax = [1,1,1,2,2,3]
+<strong>Output:</strong> 181
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 5000</code></li>
+	<li><code>rollMax.length == 6</code></li>
+	<li><code>1 &lt;= rollMax[i] &lt;= 15</code></li>
+</ul>
+
+
+**Related Topics**:  
+[Dynamic Programming](https://leetcode.com/tag/dynamic-programming/)
+
+## Solution 1. DP
+
+Let `dp[i][j]` be the number of distinct sequences ending with `j` obtained using `i` rolles.
+
+```
+dp[1][j] = 1       1 <= j <= 6
+```
+
+Ignoring the `rollMax`, we have `dp[i][j] = sum( dp[i-1][k] | 1 <= k <= 6 )`.
+
+If we pick `j` at `i` roll, we need to exclude the cases where there are already `rollMax[j]` `j` numbers right in front of `i`th roll.
+
+The number of such cases is `dp[i-rollMax[j]-1][k]` where `1 <= k <= 6` and `k != j`.
+
+```cpp
+// OJ: https://leetcode.com/problems/dice-roll-simulation/
+// Author: github.com/lzl124631x
+// Time: O(N)
+// Space: O(N)
+// Ref: https://leetcode.com/problems/dice-roll-simulation/discuss/403756/Java-Share-my-DP-solution
+class Solution {
+public:
+    int dieSimulator(int n, vector<int>& A) {
+        long mod = 1e9+7;
+        vector<vector<long>> dp(n, vector<long>(7));
+        for (int i = 0; i < 6; ++i) dp[0][i] = 1;
+        dp[0][6] = 6;
+        for (int i = 1; i < n; ++i) {
+            long sum = 0;
+            for (int j = 0; j < 6; ++j) {
+                dp[i][j] = dp[i - 1][6];
+                if (i < A[j]) sum = (sum + dp[i][j]) % mod;
+                else {
+                    if (i - A[j] - 1 >= 0) dp[i][j] = (dp[i][j] - (dp[i - A[j] - 1][6] - dp[i - A[j] - 1][j]) + mod) % mod;
+                    else dp[i][j] = (dp[i][j] - 1) % mod;
+                    sum = (sum + dp[i][j]) % mod;
+                }
+            }
+            dp[i][6] = sum;
+        }
+        return dp[n - 1][6];
+    }
+};
+```

leetcode/1096. Brace Expansion II/recursive.cpp

@@ -0,0 +1,28 @@
+// OJ: https://leetcode.com/problems/dice-roll-simulation/
+// Author: github.com/lzl124631x
+// Time: O(N)
+// Space: O(N)
+// Ref: https://leetcode.com/problems/dice-roll-simulation/discuss/403756/Java-Share-my-DP-solution
+class Solution {
+public:
+    int dieSimulator(int n, vector<int>& A) {
+        long mod = 1e9+7;
+        vector<vector<long>> dp(n, vector<long>(7));
+        for (int i = 0; i < 6; ++i) dp[0][i] = 1;
+        dp[0][6] = 6;
+        for (int i = 1; i < n; ++i) {
+            long sum = 0;
+            for (int j = 0; j < 6; ++j) {
+                dp[i][j] = dp[i - 1][6];
+                if (i < A[j]) sum = (sum + dp[i][j]) % mod;
+                else {
+                    if (i - A[j] - 1 >= 0) dp[i][j] = (dp[i][j] - (dp[i - A[j] - 1][6] - dp[i - A[j] - 1][j]) + mod) % mod;
+                    else dp[i][j] = (dp[i][j] - 1) % mod;
+                    sum = (sum + dp[i][j]) % mod;
+                }
+            }
+            dp[i][6] = sum;
+        }
+        return dp[n - 1][6];
+    }
+};

leetcode/1223. Dice Roll Simulation/README.md

@@ -0,0 +1,88 @@
+# [1320. Minimum Distance to Type a Word Using Two Fingers (Hard)](https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/)
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/01/02/leetcode_keyboard.png" style="width: 417px; height: 250px;"></p>
+
+<p>You have a keyboard layout as shown above in the XY plane, where each English uppercase letter is located at some coordinate, for example, the letter <strong>A</strong> is located at coordinate <strong>(0,0)</strong>, the letter <strong>B</strong> is located at coordinate <strong>(0,1)</strong>, the letter <strong>P</strong> is located at coordinate <strong>(2,3)</strong> and the letter <strong>Z</strong> is located at coordinate <strong>(4,1)</strong>.</p>
+
+<p>Given the string <code>word</code>, return the minimum total distance to type such string using only two&nbsp;fingers. The distance between coordinates <strong>(x<sub>1</sub>,y<sub>1</sub>)</strong> and <strong>(x<sub>2</sub>,y<sub>2</sub>)</strong> is <strong>|x<sub>1</sub> - x<sub>2</sub>| + |y<sub>1</sub> - y<sub>2</sub>|</strong>.&nbsp;</p>
+
+<p>Note that the initial positions of your two&nbsp;fingers are considered free so don't count towards your total distance, also your two&nbsp;fingers do not have to start at the first letter or the first two&nbsp;letters.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> word = "CAKE"
+<strong>Output:</strong> 3
+<strong>Explanation: 
+</strong>Using two fingers, one optimal way to type "CAKE" is: 
+Finger 1 on letter 'C' -&gt; cost = 0 
+Finger 1 on letter 'A' -&gt; cost = Distance from letter 'C' to letter 'A' = 2 
+Finger 2 on letter 'K' -&gt; cost = 0 
+Finger 2 on letter 'E' -&gt; cost = Distance from letter 'K' to letter 'E' = 1 
+Total distance = 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> word = "HAPPY"
+<strong>Output:</strong> 6
+<strong>Explanation: </strong>
+Using two fingers, one optimal way to type "HAPPY" is:
+Finger 1 on letter 'H' -&gt; cost = 0
+Finger 1 on letter 'A' -&gt; cost = Distance from letter 'H' to letter 'A' = 2
+Finger 2 on letter 'P' -&gt; cost = 0
+Finger 2 on letter 'P' -&gt; cost = Distance from letter 'P' to letter 'P' = 0
+Finger 1 on letter 'Y' -&gt; cost = Distance from letter 'A' to letter 'Y' = 4
+Total distance = 6
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> word = "NEW"
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> word = "YEAR"
+<strong>Output:</strong> 7
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= word.length &lt;= 300</code></li>
+	<li>Each <code data-stringify-type="code">word[i]</code>&nbsp;is an English uppercase letter.</li>
+</ul>
+
+**Related Topics**:  
+[Dynamic Programming](https://leetcode.com/tag/dynamic-programming/)
+
+## Solution 1. DP
+
+```cpp
+// OJ: https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/
+// Author: github.com/lzl124631x
+// Time: O(N)
+// Space: O(1)
+// Ref: https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/discuss/477652/JavaC%2B%2BPython-1D-DP-O(1)-Space
+class Solution {
+    int d(int a, int b) {
+        return abs(a / 6 - b / 6) + abs(a % 6 - b % 6);
+    }
+public:
+    int minimumDistance(string word) {
+        vector<int> dp(26);
+        int res = 0, save = 0, n = word.size();
+        for (int i = 0; i < n - 1; ++i) {
+            int b = word[i] - 'A', c = word[i + 1] - 'A';
+            for (int a = 0; a < 26; ++a)
+                dp[b] = max(dp[b], dp[a] + d(b, c) - d(a, c));
+            save = max(save, dp[b]);
+            res += d(b, c);
+        }
+        return res - save;
+    }
+};
+```

leetcode/1223. Dice Roll Simulation/s1.cpp

@@ -0,0 +1,23 @@
+// OJ: https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/
+// Author: github.com/lzl124631x
+// Time: O(N)
+// Space: O(1)
+// Ref: https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/discuss/477652/JavaC%2B%2BPython-1D-DP-O(1)-Space
+class Solution {
+    int d(int a, int b) {
+        return abs(a / 6 - b / 6) + abs(a % 6 - b % 6);
+    }
+public:
+    int minimumDistance(string word) {
+        vector<int> dp(26);
+        int res = 0, save = 0, n = word.size();
+        for (int i = 0; i < n - 1; ++i) {
+            int b = word[i] - 'A', c = word[i + 1] - 'A';
+            for (int a = 0; a < 26; ++a)
+                dp[b] = max(dp[b], dp[a] + d(b, c) - d(a, c));
+            save = max(save, dp[b]);
+            res += d(b, c);
+        }
+        return res - save;
+    }
+};