surrounded-region.py to surrounded-regions.py

.gitignore

@@ -0,0 +1,91 @@
+.idea/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# dotenv
+.env
+
+# virtualenv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject

C++/01-matrix.cpp

@@ -0,0 +1,37 @@
+// Time:  O(m * n)
+// Space: O(m * n)
+
+class Solution {
+public:
+    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
+        queue<pair<int, int>> queue;
+        for (int i = 0; i < matrix.size(); ++i) {
+            for (int j = 0; j < matrix[0].size(); ++j) {
+                if (matrix[i][j] == 0) {
+                    queue.emplace(i, j);
+                }
+                else {
+                    matrix[i][j] = numeric_limits<int>::max();
+                }
+            }
+        }
+
+        const vector<pair<int, int>> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
+        while (!queue.empty()) {
+            auto cell = queue.front();
+            queue.pop();
+            for (const auto& dir : dirs) {
+                auto i = cell.first + dir.first;
+                auto j = cell.second + dir.second;
+                if (i < 0 || i >= matrix.size() || j < 0 || j >= matrix[0].size() || 
+                    matrix[i][j] <= matrix[cell.first][cell.second] + 1) {
+                        continue;
+                }
+                queue.emplace(i, j);
+                matrix[i][j] = matrix[cell.first][cell.second] + 1;
+            }
+        }
+
+        return matrix;
+    }
+};

C++/132-pattern.cpp

@@ -0,0 +1,21 @@
+// Time:  O(n)
+// Space: O(n)
+
+class Solution {
+public:
+    bool find132pattern(vector<int>& nums) {
+        int ak = numeric_limits<int>::min();
+        stack<int> st;
+        for (int i = nums.size() - 1; i >= 0; --i) {
+            if (nums[i] < ak) {
+                return true;
+            } else {
+                while (!st.empty() && nums[i] > st.top()) {
+                    ak = st.top(), st.pop(); 
+                }
+            }
+            st.emplace(nums[i]);
+        }
+        return false;
+    }
+};

C++/3sum-closest.cpp

@@ -0,0 +1,44 @@
+// Time:  O(n^2)
+// Space: O(1)
+
+class Solution {
+public:
+    /**
+     * @param numbers: Give an array numbers of n integer
+     * @param target: An integer
+     * @return: return the sum of the three integers, the sum closest target.
+     */
+    int threeSumClosest(vector<int> nums, int target) {
+        int ans = numeric_limits<int>::max();
+        int min_diff = numeric_limits<int>::max();
+
+        // Make nums in increasing order. Time: O(nlogn)
+        sort(nums.begin(), nums.end());
+
+        for (int i = 0; i < static_cast<int>(nums.size()) - 2; ++i) {
+            if (i == 0 || nums[i] != nums[i - 1]) {  // Skip duplicated.
+                int j = i + 1;
+                int k = nums.size() - 1;
+
+                while (j < k) {  // Time: O(n) for each i.
+                    const auto sum = nums[i] + nums[j] + nums[k];
+
+                    if (sum > target) {  // Should decrease sum.
+                        --k;
+                    } else if (sum < target) {  // Should increase sum.
+                        ++j;
+                    } else {
+                        return target;
+                    }
+
+                    if (abs(sum - target) < min_diff) {
+                        min_diff = abs(sum - target);
+                        ans = sum;
+                    }
+                }
+            }
+        }
+
+        return ans;
+    }
+};

C++/3sum-smaller.cpp

@@ -0,0 +1,25 @@
+// Time:  O(n^2)
+// Space: O(1)
+
+class Solution {
+public:
+    int threeSumSmaller(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+        const int n = nums.size();
+
+        int count = 0;
+        for (int k = 2; k < n; ++k) {
+            int i = 0, j = k - 1;
+            while (i < j) {  // Two Pointers, linear time.
+                if (nums[i] + nums[j] + nums[k] >= target) {
+                    --j;
+                } else {
+                    count += j - i;
+                    ++i;
+                }
+            }
+        }
+
+        return count;
+    }
+};

C++/3sum.cpp

@@ -0,0 +1,41 @@
+// Time:  O(n^2)
+// Space: O(1)
+
+class Solution {
+public:
+    /**
+     * @param numbers : Give an array numbers of n integer
+     * @return : Find all unique triplets in the array which gives the sum of zero.
+     */
+    vector<vector<int>> threeSum(vector<int> &nums) {
+        vector<vector<int>> ans;
+        const int target = 0;
+
+        // Make nums in increasing order. Time: O(nlogn)
+        sort(nums.begin(), nums.end());
+
+        for (int i = 0; i < static_cast<int>(nums.size()) - 2; ++i) {
+            if (i == 0 || nums[i] != nums[i - 1]) {  // Skip duplicated.
+                for (int j = i + 1, k = nums.size() - 1; j < k; ) {  // Time: O(n) for each i.
+                    if (j - 1 > i  && nums[j] == nums[j - 1]) {  // Skip duplicated.
+                        ++j;
+                    } else if (k + 1 < nums.size() && nums[k] == nums[k + 1]) {  // Skip duplicated.
+                        --k;
+                    } else {
+                        const auto sum = nums[i] + nums[j] + nums[k];
+                        if (sum > target) {  // Should decrease sum.
+                            --k;
+                        } else if (sum < target) {  // Should increase sum.
+                            ++j;
+                        } else {
+                            ans.push_back({nums[i], nums[j], nums[k]});
+                            ++j, --k;
+                        }
+                    }
+                }
+            }
+        }
+
+        return ans;
+    }
+};

C++/4sum-ii.cpp

@@ -0,0 +1,23 @@
+// Time:  O(n^2)
+// Space: O(n^2)
+
+class Solution {
+public:
+    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+        unordered_map<int, int> A_B_sum;
+        for (const auto& a : A) {
+            for (const auto& b : B) {
+                ++A_B_sum[a + b];
+            }
+        }
+        int result = 0;
+        for (const auto& c : C) {
+            for (const auto& d : D) {
+                if (A_B_sum.find(-c - d) != A_B_sum.end()) {
+                    result += A_B_sum[-c - d];
+                }
+            }
+        }
+        return result;
+    }
+};

C++/4sum.cpp

@@ -0,0 +1,79 @@
+// Time:  O(n^3)
+// Space: O(1)
+
+class Solution {
+public:
+    vector<vector<int> > fourSum(vector<int> &num, int target) {
+        int len = num.size();
+        int left, right, sum;
+        sort(num.begin(), num.end());
+        vector<vector<int>> res;
+        for (int i = 0; i < len - 3; ++i) {
+            if (i && num[i] == num[i - 1]) {
+                continue;
+            }
+            for (int j = i + 1; j < len - 2; ++j) {
+                if (j != i + 1 && num[j] == num[j - 1]) {
+                    continue;
+                }
+                sum = target - num[i] - num[j];
+                left = j + 1, right = len - 1;
+                while (left < right) {
+                    if (num[left] + num[right] == sum) {
+                        res.push_back({num[i], num[j], num[left], num[right]});
+                        ++left, --right;
+                        while (left < right && num[left] == num[left - 1]) {
+                            ++left;
+                        }
+                        while (left < right && num[right] == num[right + 1]) {
+                            --right;
+                        }
+                    } else {
+                        if (num[left] + num[right] > sum) {
+                            --right;
+                        } else {
+                            ++left;
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+};
+
+// Time:  O(n^4)
+// Space: O(n^2)
+class Solution2 {
+public:
+    vector<vector<int> > fourSum(vector<int> &num, int target) {
+        vector<vector<int>> ans;
+        if (num.size() < 4)  {
+            return ans;
+        }
+        sort(num.begin(), num.end());
+        unordered_multimap<int, pair<int, int>> cache;
+
+        for (int i = 0; i < num.size(); ++i) {
+            for (int j = i + 1; j < num.size(); ++j) {
+                cache.emplace(num[i] + num[j], make_pair(i, j));
+            }
+        }
+
+        for (auto i = cache.begin(); i != cache.end(); ++i) {
+            auto a = i->second.first;
+            auto b = i->second.second;
+            auto range = cache.equal_range(target - i->first);
+            for (auto j = range.first; j != range.second; ++j) {
+                auto c = j->second.first;
+                auto d = j->second.second;
+                if (b < c) {
+                    ans.push_back({num[a], num[b], num[c], num[d]});
+                }
+            }
+        }
+        sort(ans.begin(), ans.end());
+        ans.erase(unique(ans.begin(), ans.end()), ans.end());
+        return ans;
+    }
+};