update exercises

data/3.算法高阶/1.leetcode/26_移除元素/solution.md

@@ -3,30 +3,123 @@
 ## aop
 ### before
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 ### after
 ```cpp
-
+int main()
+{
+    Solution sol;
+    int res;
+    vector<int> nums{0, 1, 2, 2, 3, 0, 4, 2};
+    res = sol.removeElement(nums, 2);
+    cout << res;
+    return 0;
+}
 ```
 
 ## 答案
 ```cpp
-
+class Solution
+{
+public:
+    int removeElement(vector<int> &nums, int val)
+    {
+        int count = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (nums[i] != val)
+            {
+                nums[count++] = nums[i];
+            }
+        }
+        return count;
+    }
+};
 ```
 ## 选项
 
 ### A
 ```cpp
-
+class Solution
+{
+public:
+    int removeElement(vector<int> &nums, int val)
+    {
+        int i = 0;
+        for (int j = 0; j < nums.size(); j++)
+        {
+            if (nums[j] != val)
+            {
+                nums[i] = nums[j];
+                i++;
+            }
+        }
+        return i;
+    }
+};
 ```
 
 ### B
 ```cpp
-
+class Solution
+{
+public:
+    int removeElement(vector<int> &nums, int val)
+    {
+        int n = nums.size();
+        int i = 0;
+        while (i < n)
+        {
+            if (nums[i] == val)
+            {
+                nums[i] = nums[n - 1];
+                n--;
+            }
+            else
+                i++;
+        }
+        return n;
+    }
+};
 ```
 
 ### C
 ```cpp
+class Solution
+{
+public:
+    int removeElement(vector<int> &nums, int val)
+    {
+        int tmp_len = nums.size();
+
+        if (tmp_len == 0)
+            return 0;
+        else
+        {
+            for (int ii = 1; ii < nums.size(); ii++)
+            {
+                if (nums[ii] == val)
+                    tmp_len = tmp_len - 1;
+            }
+
+            for (int i = 0; i < nums.size(); i++)
+            {
+                if (nums[i] == val)
+                {
+                    for (int j = i; j < nums.size(); j++)
+                    {
+                        if (nums[j] != val)
+                        {
+                            nums[j] = nums[i];
+                        }
+                    }
+                }
+            }
 
+            return tmp_len;
+        }
+    }
+};
 ```

data/3.算法高阶/1.leetcode/27_实现 strStr()/solution.md

@@ -3,30 +3,157 @@
 ## aop
 ### before
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 ### after
 ```cpp
-
+int main()
+{
+    Solution sol;
+    int res;
+    res = sol.strStr("hello", "ll");
+    cout << res;
+    return 0;
+}
 ```
 
 ## 答案
 ```cpp
-
+class Solution
+{
+public:
+    int strStr(string haystack, string needle)
+    {
+        return haystack.find(needle);
+    }
+};
 ```
 ## 选项
 
 ### A
 ```cpp
-
+class Solution
+{
+public:
+    int strStr(string haystack, string needle)
+    {
+        int l1 = haystack.size();
+        int l2 = needle.size();
+        int i = 0, j = 0;
+        while (i < l1 && j < l2)
+        {
+            if (haystack[i] == needle[j])
+            {
+                i++;
+                j++;
+            }
+            else
+            {
+                i = i - j + 1;
+                j = 0;
+            }
+        }
+        if (j >= l2)
+            return (i - j);
+        else
+            return -1;
+    }
+};
 ```
 
 ### B
 ```cpp
+class Solution
+{
+public:
+    vector<int> next(string str)
+    {
+        vector<int> v;
+        v.push_back(-1);
+        int i = 0, j = -1;
+        while (i < str.size())
+        {
+            if (j == -1 || str[i] == str[j])
+            {
+                ++i;
+                ++j;
+                v.push_back(j);
+            }
+            else
+                j = v[j];
+        }
+        return v;
+    }
+    int strStr(string haystack, string needle)
+    {
+        int i = 0;
+        int j = 0;
+        int len1 = haystack.size(), len2 = needle.size();
+        vector<int> nextptr;
+        if (needle.empty())
+            return 0;
+
+        nextptr = next(needle);
 
+        while ((i < len1) && (j < len2))
+        {
+
+            if ((j == -1) || (haystack[i] == needle[j]))
+
+            {
+                i++;
+                j++;
+            }
+            else
+            {
+                j = nextptr[j];
+            }
+        }
+
+        if (j == needle.size())
+            return i - j;
+        else
+            return -1;
+    }
+};
 ```
 
 ### C
 ```cpp
-
+class Solution
+{
+public:
+    int strStr(string haystack, string needle)
+    {
+        int flag = 0;
+        int i, j;
+        int sizeofh = haystack.length();
+        int sizeofn = needle.length();
+        if (needle == "")
+        {
+            return 0;
+        }
+        for (i = 0; i < sizeofh; i++)
+        {
+            for (j = 0; j < sizeofn; j++)
+            {
+                if (i + j > sizeofh)
+                {
+                    break;
+                }
+                if (haystack[i + j] != needle[j])
+                {
+                    break;
+                }
+            }
+        }
+        if (flag)
+        {
+            return i;
+        }
+        else
+            return -1;
+    }
+};
 ```

data/3.算法高阶/1.leetcode/28_两数相除/solution.md

@@ -3,30 +3,191 @@
 ## aop
 ### before
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 ### after
 ```cpp
-
+int main()
+{
+    Solution sol;
+    int res;
+    res = sol.divide(10, 3);
+    cout << res;
+    return 0;
+}
 ```
 
 ## 答案
 ```cpp
-
+class Solution
+{
+public:
+    int divide(int dividend, int divisor)
+    {
+        if (dividend == 0 || divisor == 1)
+            return dividend;
+        if (divisor == -1)
+            return dividend == INT_MIN ? INT_MAX : -dividend;
+        int sign = (dividend > 0) ^ (divisor > 0) ? -1 : 1;
+        int res = div(-abs(dividend), -abs(divisor));
+        return sign == 1 ? res : -res;
+    }
+    int div(int a, int b)
+    {
+        if (a > b)
+            return 0;
+        int cnt = 1, val = b;
+        while (val - a + val >= 0)
+        {
+            cnt <<= 1;
+            val += val;
+        }
+        return div(a - val, b);
+    }
+};
 ```
 ## 选项
 
 ### A
 ```cpp
-
+class Solution
+{
+public:
+    int divide(int dividend, int divisor)
+    {
+        int signal = 1;
+        unsigned int dvd = dividend;
+        if (dividend < 0)
+        {
+            signal *= -1;
+            dvd = ~dvd + 1;
+        }
+        unsigned int dvs = divisor;
+        if (divisor < 0)
+        {
+            signal *= -1;
+            dvs = ~dvs + 1;
+        }
+        int shift = 0;
+        while (dvd > dvs << shift)
+        {
+            shift++;
+        }
+        unsigned int res = 0;
+        while (dvd >= dvs)
+        {
+            while (dvd < dvs << shift)
+            {
+                shift--;
+            }
+            res |= (unsigned int)1 << shift;
+            dvd -= dvs << shift;
+        }
+        if (signal == 1 && res >= INT_MAX)
+        {
+            return INT_MAX;
+        }
+        else
+        {
+            return res * signal;
+        }
+    }
+};
 ```
 
 ### B
 ```cpp
-
+class Solution
+{
+public:
+    int divide(int dividend, int divisor)
+    {
+        if (dividend == INT_MIN && divisor == -1)
+            return INT_MAX;
+        if (dividend == 0)
+            return 0;
+        int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;
+        long x = (dividend < 0) ? -(long)dividend : (long)dividend;
+        long y = (divisor < 0) ? -(long)divisor : (long)divisor;
+        long result = 0;
+        while (x >= y)
+        {
+            long temp = y, mid = 1;
+            while (x >= (temp << 1))
+            {
+                mid <<= 1;
+                temp <<= 1;
+            }
+            result += mid;
+            x -= temp;
+        }
+        return sign > 0 ? result : -result;
+    }
+};
 ```
 
 ### C
 ```cpp
+class Solution
+{
+public:
+    int divide(int dividend, int divisor)
+    {
+        int INI_MIN = -2147483648, INI_MAX = 2147483647;
+        if (dividend == divisor)
+            return 1;
+        if (divisor == 1)
+            return dividend;
+        if (dividend == INI_MIN && divisor == -1)
+            return INI_MAX;
+        if (divisor == INI_MIN)
+        {
+            if (dividend == INI_MIN)
+                return 1;
+            else
+                return 0;
+        }
+
+        bool sign = false;
+        if (dividend > 0 && divisor > 0 || dividend < 0 && divisor < 0)
+        {
+            sign = true;
+        }
+
+        int result_1 = 0;
+        if (dividend == INI_MIN)
+        {
+            if (divisor > 0)
+                dividend = dividend + divisor;
+            else
+                dividend = dividend - divisor;
+            result_1++;
+        }
+
+        dividend = abs(dividend);
+        divisor = abs(divisor);
+        while (dividend >= divisor)
+        {
+            unsigned int temp = divisor, res = 1;
+
+            while (dividend >= (temp << 1))
+            {
+                res <<= 1;
+                temp <<= 1;
+            }
 
+            result_1 += res;
+            dividend -= temp;
+        }
+        if (sign == true)
+        {
+            return result_1;
+        }
+        else
+        {
+            return -result_1;
+        }
+    }
+};
 ```

data/3.算法高阶/1.leetcode/29_串联所有单词的子串/solution.md

@@ -3,30 +3,245 @@
 ## aop
 ### before
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 ### after
 ```cpp
+int main()
+{
+    Solution sol;
+    vector<int> res;
+    string s = "barfoothefoobarman";
+    vector<string> words{"foo", "bar"};
+    res = sol.findSubstring(s, words);
 
+    for (auto i : res)
+        cout << i << " ";
+    return 0;
+}
 ```
 
 ## 答案
 ```cpp
-
+class Solution
+{
+public:
+    vector<int> findSubstring(string s, vector<string> &words)
+    {
+        if (words.empty() || s.empty())
+            return {};
+        vector<int> ans;
+        int len = words[0].length(), n = words.size(), total = n * len;
+        ;
+        int l = s.length();
+        unordered_map<string, int> list;
+        int i, j, left;
+        for (i = 0; i < n; i++)
+            list[words[i]]++;
+        for (i = 0; i <= l - total; i++)
+        {
+            unordered_map<string, int> window;
+            bool flag = true;
+            left = i;
+            string str;
+            while (left - i < total)
+            {
+                str = s.substr(left, len);
+                if (list.count(str) == 1 && window[str] != list[str])
+                {
+                    window[str]++;
+                    left += len;
+                }
+                else
+                {
+                    flag = false;
+                }
+            }
+            if (flag)
+                ans.push_back(i);
+        }
+        return ans;
+    }
+};
 ```
 ## 选项
 
 ### A
 ```cpp
-
+class Solution
+{
+public:
+    vector<int> findSubstring(string s, vector<string> &words)
+    {
+        vector<int> res;
+        if (s.empty() || words.empty())
+        {
+            return res;
+        }
+        unordered_map<string, int> ht;
+        for (const auto &w : words)
+        {
+            ht[w]++;
+        }
+        int len = words[0].length();
+        for (int i = 0, j = 0; i < s.length() - words.size() * len + 1; i++)
+        {
+            unordered_map<string, int> counting;
+            for (j = 0; j < words.size(); j++)
+            {
+                string word = s.substr(i + j * len, len);
+                if (++counting[word] > ht[word])
+                {
+                    break;
+                }
+            }
+            if (j == words.size())
+            {
+                res.push_back(i);
+            }
+        }
+        return res;
+    }
+};
 ```
 
 ### B
 ```cpp
-
+class Solution
+{
+public:
+    vector<int> findSubstring(string s, vector<string> &words)
+    {
+        if (words.empty() || s.empty())
+            return {};
+        vector<int> ans;
+        unordered_map<string, int> umap1;
+        unordered_map<string, int> umap2;
+        int count = 0;
+        int left = 0;
+        for (string str : words)
+            ++umap1[str];
+        int len = words[0].size();
+        int slen = s.size();
+        for (int i = 0; i < len; i++)
+        {
+            left = i;
+            count = 0;
+            umap2.clear();
+            for (int j = i; j <= slen - len; j += len)
+            {
+                string temp = s.substr(j, len);
+                if (umap1.count(temp))
+                {
+                    umap2[temp]++;
+                    count++;
+                    while (umap2[temp] > umap1[temp])
+                    {
+                        string temp2 = s.substr(left, len);
+                        --umap2[temp2];
+                        --count;
+                        left += len;
+                    }
+                    if (count == words.size())
+                    {
+                        ans.push_back(left);
+                        --umap2[s.substr(left, len)];
+                        --count;
+                        left += len;
+                    }
+                }
+                else
+                {
+                    umap2.clear();
+                    count = 0;
+                    left = j + len;
+                }
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 ### C
 ```cpp
+class Solution
+{
+public:
+    vector<int> findSubstring(string s, vector<string> &words)
+    {
+        vector<int> result;
+        if (words.size() == 0 || s.length() == 0)
+            return result;
+
+        map<string, int> words_map;
+        int word_len = words[0].length();
+        int word_num = words.size();
+        if (word_len > s.length())
+            return result;
+        for (vector<string>::iterator it = words.begin(); it != words.end(); it++)
+        {
+            if (words_map.count(*it))
+                words_map[*it]++;
+            else
+                words_map[*it] = 1;
+        }
+
+        for (int i = 0; i < word_len; i++)
+        {
+            int left = i, right = i;
+            int cur_num = 0;
+            map<string, int> s_map;
+            string right_str, left_string;
+            while (right <= s.length() - word_len)
+            {
+                right_str = s.substr(right, word_len);
+
+                if (!words_map.count(right_str))
+                {
+                    right += word_len;
+                    left = right;
+                    cur_num = 0;
+                    s_map.clear();
+                }
+                else
+                {
+
+                    if (!s_map.count(right_str))
+                        s_map.insert(pair<string, int>(right_str, 1));
+                    else
+                        s_map[right_str] += 1;
+
+                    cur_num += 1;
+                    right += word_len;
+
+                    if (s_map[right_str] > words_map[right_str])
+                    {
+
+                        while (s_map[right_str] > words_map[right_str])
+                        {
+                            string left_str = s.substr(left, word_len);
+                            s_map[left_str]--;
+                            cur_num--;
+                            left += word_len;
+                        }
+                    }
+
+                    if (cur_num == word_num)
+                    {
+
+                        result.push_back(left);
+
+                        s_map[s.substr(left, word_len)]--;
+                        left += word_len;
+                        cur_num--;
+                    }
+                }
+            }
+        }
 
+        return result;
+    }
+};
 ```

data/3.算法高阶/1.leetcode/30_下一个排列/solution.md

@@ -12,21 +12,178 @@
 
 ## 答案
 ```cpp
-
+class Solution
+{
+public:
+    void nextPermutation(vector<int> &nums)
+    {
+        if (nums.size() <= 1)
+            return;
+        int i, j;
+        for (i = nums.size() - 2; i >= 0; i--)
+        {
+            if (nums.at(i) < nums.at(i + 1))
+                break;
+        }
+        if (i < 0)
+            reverse(nums, 0, nums.size() - 1);
+        else
+        {
+            for (j = nums.size() - 1; j > i; j--)
+            {
+                if (nums.at(j) > nums.at(i))
+                    break;
+            }
+            swap(nums, i, j);
+            reverse(nums, i, nums.size() - 1);
+        }
+    }
+    void swap(vector<int> &nums, int i, int j)
+    {
+        int temp = nums.at(j);
+        nums.at(j) = nums.at(i);
+        nums.at(i) = temp;
+    }
+    void reverse(vector<int> &nums, int i, int j)
+    {
+        while (i < j)
+        {
+            swap(nums, i, j);
+            i++;
+            j--;
+        }
+    }
+};
 ```
 ## 选项
 
 ### A
 ```cpp
-
+class Solution
+{
+public:
+	void nextPermutation(vector<int> &nums)
+	{
+		if (nums.size() < 2)
+		{
+			return;
+		}
+		int i = nums.size() - 2;
+		while (i >= 0 && nums[i] >= nums[i + 1])
+		{
+			i--;
+		}
+		if (i >= 0)
+		{
+			int j = nums.size() - 1;
+			while (j >= 0 && nums[j] >= nums[i])
+			{
+				j--;
+			}
+			swap(nums.begin() + i, nums.begin() + j);
+		}
+		reverse(nums.begin() + i + 1, nums.end());
+	}
+};
 ```
 
 ### B
 ```cpp
+class Solution
+{
+public:
+    void nextPermutation(vector<int> &num)
+    {
+        int index = num.size() - 1;
+        while (num[index - 1] >= num[index])
+        {
+            index--;
+        }
+
+        if (index == 0)
+        {
+            sort(num.begin(), num.end());
+            return;
+        }
 
+        for (int i = num.size() - 1; i >= index; i--)
+        {
+            if (num[i] > num[index - 1])
+            {
+                swap(num[i], num[index - 1]);
+                break;
+            }
+        }
+
+        sort(num.begin() + index, num.end());
+        return;
+    }
+};
 ```
 
 ### C
 ```cpp
+void reverse(vector<int> &nums, int begin, int end)
+{
+    while (begin < end)
+    {
+        int temp = nums[begin];
+        nums[begin] = nums[end];
+        nums[end] = temp;
+        begin++;
+        end--;
+    }
+    return;
+}
+
+int minIndex(vector<int> nums, int begin, int end, int i)
+{
+    int min = nums[begin];
+    int x = i;
+    for (int j = begin; j <= end; j++)
+    {
+        if (min >= nums[j] && nums[j] > nums[i])
+        {
+            min = nums[j];
+            x = j;
+        }
+    }
+    return x;
+}
+
+class Solution
+{
+public:
+    void nextPermutation(vector<int> &nums)
+    {
+        if (nums.size() == 0 || nums.size() == 1)
+        {
+            return;
+        }
+        int size = nums.size();
+        int i = 0;
+        for (i = size - 2; i >= 0; i--)
+        {
+            if (nums[i] < nums[i + 1])
+            {
+                break;
+            }
+        }
+        if (i == -1)
+        {
+            reverse(nums, 0, size - 1);
+            return;
+        }
+        else
+        {
+            int min = minIndex(nums, i + 1, size - 1, i);
+            int temp = nums[i];
+            nums[i] = nums[min];
+            nums[min] = temp;
+            sort(nums.begin() + i + 1, nums.end());
+            return;
+        }
+    }
+};
 
 ```

data/3.算法高阶/1.leetcode/32_搜索旋转排序数组/solution.md

@@ -3,30 +3,229 @@
 ## aop
 ### before
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 ### after
 ```cpp
+int main()
+{
+    Solution sol;
+    int res;
+    vector<int> nums{4, 5, 6, 7, 0, 1, 2};
+    int target = 0;
+
+    res = sol.search(nums, target);
 
+    cout << res << " ";
+    return 0;
+}
 ```
 
 ## 答案
 ```cpp
-
+class Solution
+{
+public:
+    int search(vector<int> &nums, int target)
+    {
+        return bs(nums, 0, nums.size(), target);
+    }
+    int bs(vector<int> &nums, int i, int j, int &target)
+    {
+        if (i > j)
+            return -1;
+        int k = (i + j) / 2;
+        if (nums[k] == target)
+            return k;
+        if (nums[k] < nums[j])
+        {
+            if (target < nums[k] || target > nums[j])
+                return bs(nums, i + 1, k - 1, target);
+            else
+                return bs(nums, k - 1, j, target);
+        }
+        else
+        {
+            if (target > nums[k] || target < nums[i])
+                return bs(nums, k + 1, j, target);
+            else
+                return bs(nums, i - 1, k, target);
+        }
+    }
+};
 ```
 ## 选项
 
 ### A
 ```cpp
-
+class Solution
+{
+public:
+    int search(vector<int> &nums, int target)
+    {
+        int lo = 0;
+        int hi = nums.size() - 1;
+        while (lo <= hi)
+        {
+            int mid = lo + (hi - lo) / 2;
+            if (nums[mid] == target)
+            {
+                return mid;
+            }
+            if (nums[lo] <= nums[mid])
+            {
+                if (nums[lo] <= target && target < nums[mid])
+                {
+                    hi = mid - 1;
+                }
+                else
+                {
+                    lo = mid + 1;
+                }
+            }
+            else
+            {
+                if (nums[mid] < target && target <= nums[hi])
+                {
+                    lo = mid + 1;
+                }
+                else
+                {
+                    hi = mid - 1;
+                }
+            }
+        }
+        return -1;
+    }
+};
 ```
 
 ### B
 ```cpp
+class Solution
+{
+public:
+    int search(vector<int> &nums, int target)
+    {
+        int l = 0, r = nums.size() - 1;
+        while (l <= r)
+        {
+            int mid = (l + r) / 2;
+            int newMid = nums[0] > nums[mid] ? nums[mid] + 0x3f3f3f3f : nums[mid];
+            int newTarget = nums[0] > target ? target + 0x3f3f3f3f : target;
+            if (newMid == newTarget)
+                return mid;
+            else if (newMid < newTarget)
+                l = mid + 1;
+            else if (newMid > newTarget)
+                r = mid - 1;
+        }
 
+        return -1;
+    }
+};
 ```
 
 ### C
 ```cpp
+class Solution
+{
+public:
+    int search(vector<int> &nums, int target)
+    {
+        int n = nums.size();
+        if (n == 0)
+            return -1;
+        int loc = -1;
+        int i = 0;
+        int j = n - 1;
+        int cur = i;
+        while (i <= j)
+        {
+            if (nums[i] == target)
+            {
+                loc = i;
+                break;
+            }
+            else if (nums[j] == target)
+            {
+                loc = j;
+                break;
+            }
+            if ((nums[i] > target && nums[j] < target) || i == j)
+            {
+                break;
+            }
+            if (nums[i] < target)
+            {
+                int mid = (i + j) / 2;
+                if (i == mid || j == mid)
+                    return loc;
+                while (nums[mid] < nums[i])
+                {
+                    j = mid - 1;
+                    mid = (i + j) / 2;
+                }
+                if (nums[mid] < target)
+                {
+                    i = mid;
+                    continue;
+                }
+                else
+                {
+                    j = mid;
+                    while (i <= j)
+                    {
+                        mid = (i + j) / 2;
+                        if (nums[mid] == target)
+                        {
+                            loc = mid;
+                            break;
+                        }
+                        if (nums[mid] > target)
+                            j = mid - 1;
+                        else
+                            i = mid + 1;
+                    }
+                }
+            }
+            if (nums[j] > target)
+            {
+                int mid = (i + j) / 2;
+                if (i == mid || j == mid)
+                    return loc;
+                while (nums[mid] > nums[j])
+                {
+                    i = mid + 1;
+                    mid = (i + j) / 2;
+                }
+                if (nums[mid] > target)
+                {
+                    j = mid;
+                    continue;
+                }
+                else
+                {
+                    i = mid;
+                    while (i <= j)
+                    {
+                        mid = (i + j) / 2;
+                        if (nums[mid] == target)
+                        {
+                            loc = mid;
+                            break;
+                        }
+                        if (nums[mid] > target)
+                            j = mid - 1;
+                        else
+                            i = mid + 1;
+                    }
+                }
+            }
+        }
 
+        return loc;
+    }
+};
 ```