add exercises

data/3.算法高阶/1.leetcode/158_至多包含两个不同字符的最长子串/solution.cpp

+// 滑动窗口
+// 时间复杂度：O(n) 空间复杂度：O(n)
+class Solution
+{
+public:
+    int lengthOfLongestSubstringTwoDistinct(string s)
+    {
+        unordered_map<char, int> m;
+        int cnt = 0;             // 不同字符个数
+        int left = 0, right = 0; // right指向的是窗口外的下一个字符
+        int maxLen = 0;
+        while (right < s.size())
+        {
+            if (m[s[right]] == 0)
+                cnt++;       // 出现新字符
+            m[s[right++]]++; // 计数+1并右移
+            while (cnt > 2)
+            {                 // 当窗口元素大于2，窗口缩小
+                m[s[left]]--; // 计数-1
+                if (m[s[left++]] == 0)
+                {
+                    cnt--; // 字符计数减为0
+                }
+            }
+            maxLen = max(maxLen, right - left); // 满足条件的窗口长度
+        }
+        return maxLen;
+    }
+};

data/3.算法高阶/1.leetcode/159_相交链表/solution.cpp

+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
+    {
+        if (!headA || !headB)
+            return NULL;
+        ListNode *l1 = headA, *l2 = headB;
+        while (l1 != l2)
+        {
+            l1 = l1 ? l1->next : headB;
+            l2 = l2 ? l2->next : headA;
+        }
+        return l1;
+    }
+};

data/3.算法高阶/1.leetcode/160_相隔为 1 的编辑距离/solution.cpp

+class Solution
+{
+public:
+    bool isOneEditDistance(string s, string t)
+    {
+        int gap = s.size() - t.size();
+        s = s + '0';
+        t = t + '0';
+        if (gap == 0)
+        {
+            int k = 0;
+            for (int i = 0; i < s.size(); i++)
+                if (s[i] != t[i])
+                    k++;
+            if (k == 1)
+                return true;
+        }
+        else if (abs(gap) == 1)
+        {
+            for (int i = 0; i < s.size(); i++)
+                if (s[i] != t[i] && s[i] != t[i + 1] && s[i + 1] != t[i])
+                    return false;
+            return true;
+        }
+        return false;
+    }
+};

data/3.算法高阶/1.leetcode/161_寻找峰值/solution.cpp

+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int findPeakElement(vector<int> &nums)
+    {
+        int left = 0;
+        int right = nums.size() - 1;
+        while (left <= right)
+        {
+            int mid = (left + right) >> 1;
+            if (left == right)
+            {
+                return left;
+            }
+            if (nums[mid] > nums[mid + 1])
+            {
+                right = mid;
+            }
+            else
+            {
+                left = mid + 1;
+            }
+        }
+        return -1;
+    }
+};

data/3.算法高阶/1.leetcode/162_缺失的区间/solution.cpp

+class Solution
+{
+public:
+    vector<string> findMissingRanges(vector<int> &nums, int lower, int upper)
+    {
+        long l = lower;
+        vector<string> ans;
+        for (int i = 0; i < nums.size(); ++i)
+        {
+            if (l == nums[i])
+                l++; //相等，我跳过你
+            else if (l < nums[i])
+            {                        //有空缺
+                if (l < nums[i] - 1) //大于1
+                    ans.push_back(to_string(l) + "->" + to_string(nums[i] - 1));
+                else if (l == nums[i] - 1) //等于1
+                    ans.push_back(to_string(l));
+                l = long(nums[i]) + 1; //更新l到nums[i]下一个数
+                                       // [2147483647]
+                                       // 0
+                                       // 2147483647
+            }
+        }
+        if (l < upper)
+            ans.push_back(to_string(l) + "->" + to_string(upper));
+        else if (l == upper)
+            ans.push_back(to_string(l));
+        return ans;
+    }
+};

data/3.算法高阶/1.leetcode/163_最大间距/solution.cpp

+class Solution
+{
+public:
+    int maximumGap(vector<int> &nums)
+    {
+        if (nums.size() < 2)
+            return 0;
+        sort(nums.begin(), nums.end());
+        int max_difference = 0;
+        for (int i = 0; i < nums.size() - 1; i++)
+        {
+            if (nums[i + 1] - nums[i] > max_difference)
+                max_difference = nums[i + 1] - nums[i];
+        }
+        return max_difference;
+    }
+};

data/3.算法高阶/1.leetcode/164_比较版本号/solution.cpp

+class Solution
+{
+public:
+    int compareVersion(string version1, string version2)
+    {
+        int n1 = version1.size(), n2 = version2.size();
+        int i = 0, j = 0, d1 = 0, d2 = 0;
+        string v1, v2;
+        while (i < n1 || j < n2)
+        {
+            while (i < n1 && version1[i] != '.')
+            {
+                v1 += (version1[i++]);
+            }
+            d1 = atoi(v1.c_str());
+            while (j < n2 && version2[j] != '.')
+            {
+                v2 += (version2[j++]);
+            }
+            d2 = atoi(v2.c_str());
+            if (d1 > d2)
+                return 1;
+            else if (d1 < d2)
+                return -1;
+            v1.clear();
+            v2.clear();
+            ++i;
+            ++j;
+        }
+        return 0;
+    }
+};

data/3.算法高阶/1.leetcode/165_分数到小数/solution.cpp

+class Solution
+{
+public:
+    string fractionToDecimal(int numerator, int denominator)
+    {
+        int m1 = numerator > 0 ? 1 : -1;
+        int m2 = denominator > 0 ? 1 : -1;
+        long long num = abs((long long)numerator);
+        long long den = abs((long long)denominator);
+        long long t = num / den;
+        long long res = num % den;
+        string ans = to_string(t);
+        if (m1 * m2 == -1 && (t > 0 || res > 0))
+            ans = '-' + ans;
+        if (res == 0)
+            return ans;
+        ans += '.';
+        unordered_map<long long, int> m;
+        string s = "";
+        int pos = 0;
+        while (res != 0)
+        {
+            if (m.find(res) != m.end())
+            {
+                s.insert(m[res], "(");
+                s += ')';
+                return ans + s;
+            }
+            m[res] = pos;
+            s += to_string((res * 10) / den);
+            res = (res * 10) % den;
+            pos++;
+        }
+        return ans + s;
+    }
+};

data/3.算法高阶/1.leetcode/166_两数之和 II - 输入有序数组/solution.cpp

+class Solution
+{
+public:
+    vector<int> twoSum(vector<int> &numbers, int target)
+    {
+        int i = 0;                  //第一个指针从头开始
+        int j = numbers.size() - 1; //第二个指针从末尾开始
+        while (i < j)
+        {
+            int sum = numbers[i] + numbers[j]; //sum为两数之和
+            if (sum > target)                  //sum比目标值大了，则需要变小，于是末尾指针前移
+            {
+                j--;
+            }
+            else if (sum < target) //sum比目标值小了，则需要变大，于是首指针后移
+            {
+                i++;
+            }
+            else //不大于也不小于，则等于。满足了条件，返回即可
+            {
+                return {i + 1, j + 1}; //由于返回的是下标值，所以需要+1
+            }
+        }
+        return {-1, -1};
+    }
+};

data/3.算法高阶/1.leetcode/167_Excel表列名称/solution.cpp

+class Solution
+{
+public:
+    string convertToTitle(int n)
+    {
+        string ans;
+        while (n)
+        {
+            if (n % 26 == 0)
+            {
+                ans = ans + 'Z';
+                n = n - 26;
+            }
+            else
+            {
+                ans += (n % 26 - 1 + 'A');
+            }
+            n /= 26;
+        }
+        reverse(ans.begin(), ans.end());
+        return ans;
+    }
+};

data/3.算法高阶/1.leetcode/168_多数元素/solution.cpp

+class Solution
+{
+public:
+    int majorityElement(vector<int> &nums)
+    {
+        map<int, int> mp;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            mp[nums[i]] += 1;
+            if (mp[nums[i]] > nums.size() / 2)
+                return nums[i];
+        }
+        return -1;
+    }
+};

data/3.算法高阶/1.leetcode/169_两数之和 III - 数据结构设计/solution.cpp

+class TwoSum
+{
+    unordered_map<int, int> m;
+
+public:
+    /** Initialize your data structure here. */
+    TwoSum()
+    {
+    }
+
+    /** Add the number to an internal data structure.. */
+    void add(int number)
+    {
+        m[number]++;
+    }
+
+    /** Find if there exists any pair of numbers which sum is equal to the value. */
+    bool find(int value)
+    {
+        for (auto it = m.begin(); it != m.end(); ++it)
+        {
+            if ((it->first * 2 == value && it->second >= 2) || (it->first * 2 != value && m.find(value - it->first) != m.end()))
+                return true;
+        }
+        return false;
+    }
+};

data/3.算法高阶/1.leetcode/170_Excel表列序号/solution.cpp

+class Solution
+{
+public:
+    int titleToNumber(string s)
+    {
+        int sum = 0;
+        int i = 0;
+        for (i = 0; i < s.size() - 1; ++i)
+        {
+            sum = (sum + s[i] - 64) * 26;
+        }
+        sum += (s[i] - 64);
+        return sum;
+    }
+};

data/3.算法高阶/1.leetcode/171_阶乘后的零/solution.cpp

+class Solution
+{
+public:
+    int trailingZeroes(int n)
+    {
+        int count = 0;
+        while (n >= 5)
+        {
+            count += n / 5;
+            n /= 5;
+        }
+        return count;
+    }
+};

data/3.算法高阶/1.leetcode/172_二叉搜索树迭代器/solution.cpp

+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class BSTIterator
+{
+public:
+    BSTIterator(TreeNode *root)
+    {
+        TreeNode *cur = root;
+        while (cur)
+        {
+            st.push(cur);
+            cur = cur->left;
+        }
+    }
+
+    /** @return whether we have a next smallest number */
+    bool hasNext()
+    {
+        return !st.empty();
+    }
+
+    /** @return the next smallest number */
+    int next()
+    {
+        TreeNode *next = st.top();
+        TreeNode *cur = next->right;
+        st.pop();
+        while (cur)
+        {
+            st.push(cur);
+            cur = cur->left;
+        }
+        return next->val;
+    }
+
+private:
+    stack<TreeNode *> st;
+};

data/3.算法高阶/1.leetcode/173_地下城游戏/solution.cpp

+class Solution
+{
+public:
+    int calculateMinimumHP(vector<vector<int>> &dungeon)
+    {
+        if (dungeon.empty())
+        {
+            return 0;
+        }
+        int m = dungeon.size(), n = dungeon[0].size();
+        vector<vector<long long>> dp(m + 1, vector<long long>(n + 1, INT_MAX));
+        dp[m - 1][n] = dp[m][n - 1] = 1;
+        for (int i = m - 1; i >= 0; --i)
+        {
+            for (int j = n - 1; j >= 0; --j)
+            {
+                dp[i][j] = min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j];
+                if (dp[i][j] <= 0)
+                {
+                    dp[i][j] = 1;
+                }
+            }
+        }
+        return dp[0][0];
+    }
+};

data/3.算法高阶/1.leetcode/178_最大数/solution.cpp

+class Solution
+{
+public:
+    bool static cmp(string a, string b)
+    {
+        return (a + b) > (b + a); //当a+b>b+a时a排在b前面
+    }
+    string largestNumber(vector<int> &nums)
+    {
+        int flag = 0;
+        vector<string> v;
+        for (vector<int>::iterator i = nums.begin(); i < nums.end(); i++)
+        {
+            v.push_back(to_string(*i));
+            if (*i)
+                flag = 1;
+        }
+        if (!flag)
+            return "0";
+        sort(v.begin(), v.end(), cmp); //没有生成实例就要调用，故cmp应声明为static
+        string s = "";
+        for (int i = 0; i < v.size(); i++)
+            s = s + v[i];
+        return s;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/185_翻转字符串里的单词 II/solution.cpp

+class Solution
+{
+public:
+    void reverseWords(string &s)
+    {
+        int left = 0;
+        for (int i = 0; i <= s.size(); ++i)
+        {
+            if (i == s.size() || s[i] == ' ')
+            {
+                reverse(s, left, i - 1);
+                left = i + 1;
+            }
+        }
+        reverse(s, 0, s.size() - 1);
+    }
+    void reverse(string &s, int left, int right)
+    {
+        while (left < right)
+        {
+            char t = s[left];
+            s[left] = s[right];
+            s[right] = t;
+            ++left;
+            --right;
+        }
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/186_重复的DNA序列/solution.cpp

+class Solution
+{
+public:
+    vector<string> findRepeatedDnaSequences(string s)
+    {
+        if (s.size() < 10)
+            return {};
+        vector<string> ans;
+        unordered_set<string> ss;
+        unordered_set<string> t;
+        for (int i = 0; i < s.size() - 9; ++i)
+        {
+
+            if (ss.count(s.substr(i, 10)))
+            {
+                if (!t.count(s.substr(i, 10)))
+                {
+                    ans.push_back(s.substr(i, 10));
+                    t.insert(s.substr(i, 10));
+                }
+            }
+            else
+            {
+                ss.insert(s.substr(i, 10));
+            }
+        }
+        return ans;
+    }
+};

data/3.算法高阶/1.leetcode/187_买卖股票的最佳时机 IV/solution.cpp

+class Solution
+{
+    int maxProfit(int max_k, int[] prices)
+    {
+        int n = prices.length;
+        if (n == 0)
+        {
+            return 0;
+        }
+        if (max_k > n / 2)
+        {
+            int[][] dp2 = new int[n][2];
+            //若max_k > n/2,则交易次数k没有约束
+            for (int i = 0; i < n; i++)
+            {
+                //base case
+                if (i - 1 == -1)
+                {
+                    dp2[i][0] = 0;
+                    dp2[i][1] = -prices[i];
+                    continue;
+                }
+                //状态转移方程
+                dp2[i][0] = Math.max(dp2[i - 1][0], dp2[i - 1][1] + prices[i]);
+                dp2[i][1] = Math.max(dp2[i - 1][1], dp2[i - 1][0] - prices[i]);
+            }
+            return dp2[n - 1][0];
+        }
+
+        /**
+         * k = 任意整数
+         * dp[i][k][0]表示第i天剩余k次交易机会，不持有股票
+         * dp[i][k][1]表示第i天剩余k次交易机会，持有股票
+         */
+        int[][][] dp = new int[n][max_k + 1][2];
+
+        for (int i = 0; i < n; i++)
+        {
+            for (int k = max_k; k >= 1; k--)
+            {
+                //base case
+                if (i - 1 == -1)
+                {
+                    dp[i][k][0] = 0;
+                    dp[i][k][1] = -prices[i];
+                    continue;
+                }
+                //状态转移方程
+                dp[i][k][0] = Math.max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i]);
+                dp[i][k][1] = Math.max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i]);
+            }
+        }
+
+        return dp[n - 1][max_k][0];
+    }
+}
\ No newline at end of file

data/3.算法高阶/1.leetcode/188_旋转数组/solution.cpp

+class Solution
+{
+public:
+    //数组反转函数
+    void reverseArray(vector<int> &array, int begin, int end)
+    {
+        int temp, tmp_end = end;
+        for (int i = begin; i <= (begin + end) / 2; i++)
+        {
+            temp = array[i];
+            array[i] = array[tmp_end];
+            array[tmp_end] = temp;
+            tmp_end--;
+        }
+    }
+
+    void rotate(vector<int> &nums, int k)
+    {
+        int len = nums.size();
+        k %= len;
+        if (k == 0)
+            return;
+        //使用自定义的反转函数
+        reverseArray(nums, 0, len - k - 1);
+        reverseArray(nums, len - k, len - 1);
+        reverseArray(nums, 0, len - 1);
+
+        //使用C++自带的反转函数
+        /*reverse(nums.begin(), nums.end() - k);
+	    reverse(nums.end() - k, nums.end());
+	    reverse(nums.begin(), nums.end());*/
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/189_颠倒二进制位/solution.cpp

+class Solution
+{
+public:
+    uint32_t reverseBits(uint32_t n)
+    {
+        uint32_t m = 0;
+        for (int i = 0; i < 32; ++i)
+        {
+            m <<= 1;
+            m = m | (n & 1);
+            n >>= 1;
+        }
+
+        return m;
+    }
+};

data/3.算法高阶/1.leetcode/190_位1的个数/solution.cpp

+class Solution
+{
+public:
+    int hammingWeight(uint32_t n)
+    {
+        int cnt = 0;
+        for (auto i = 0; i < 32; i++)
+        {
+            if (1 << i & n)
+                cnt++;
+        }
+
+        return cnt;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/191_统计词频/solution.sh

+cat words.txt |tr -s ' ' '\n' |sort|uniq -c|sort -r|awk '{print $2,$1}'
\ No newline at end of file

data/3.算法高阶/1.leetcode/192_有效电话号码/solution.sh

+grep -E "^\([0-9]{3}) [0-9]{3}-[0-9]{4}$|^[0-9]{3}-[0-9]{3}-[0-9]{4}$" file.txt

data/3.算法高阶/1.leetcode/193_转置文件/solution.sh

+count=$(head -1 file.txt | wc -w)
+for ((i = 1; i <= count; i++)); do
+  awk -v arg=$i '{print $arg}' file.txt | xargs
+done

data/3.算法高阶/1.leetcode/194_第十行/solution.sh

+awk "NR==10" file.txt 
\ No newline at end of file

data/3.算法高阶/1.leetcode/195_删除重复的电子邮箱/solution.sql

+DELETE p2
+FROM Person p1
+    JOIN Person p2 ON p2.Email = p1.Email
+WHERE p2.Id > p1.Id;
\ No newline at end of file

data/3.算法高阶/1.leetcode/196_上升的温度/solution.sql

+select a.id `Id`
+from Weather a
+    inner join Weather b on datediff(a.recordDate, b.recordDate) = 1
+where a.Temperature > b.Temperature
\ No newline at end of file

data/3.算法高阶/1.leetcode/197_打家劫舍/solution.cpp

+class Solution
+{
+public:
+    int rob(vector<int> &nums)
+    {
+        if (nums.size() == 0)
+            return 0;
+        if (nums.size() == 1)
+            return nums[0];
+        vector<int> dp(nums.size());
+        dp[0] = nums[0];
+        dp[1] = max(nums[0], nums[1]);
+        for (int i = 2; i < nums.size(); i++)
+        {
+            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
+        }
+        return dp[nums.size() - 1];
+    }
+};

data/3.算法高阶/1.leetcode/198_二叉树的右视图/solution.cpp

+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    vector<int> rightSideView(TreeNode *root)
+    {
+        vector<int> view; //save the result
+        queue<pair<TreeNode *, int>> Q;
+        if (root)
+            Q.push(make_pair(root, 0)); //root and its level 0
+        while (!Q.empty())
+        {
+            TreeNode *node = Q.front().first; //current node
+            int depth = Q.front().second;     //level of the node
+            Q.pop();
+            if (view.size() == depth) //每行第一个
+                view.push_back(node->val);
+            else
+                view[depth] = node->val; //每行只存一个，不断更新
+            if (node->left)
+                Q.push(make_pair(node->left, depth + 1));
+            if (node->right)
+                Q.push(make_pair(node->right, depth + 1));
+        }
+        return view;
+    }
+};

data/3.算法高阶/1.leetcode/199_岛屿数量/solution.cpp

+class Solution
+{
+public:
+    void DFS(vector<vector<int>> &mark, vector<vector<char>> &grid, int x, int y)
+    {                                          //深度搜索
+        mark[x][y] = 1;                        //标记以搜索的位置
+        static const int dx[] = {-1, 1, 0, 0}; //方向数组
+        static const int dy[] = {0, 0, -1, 1};
+        for (int i = 0; i < 4; i++)
+        {
+            int newx = dx[i] + x;
+            int newy = dy[i] + y;
+            if (newx < 0 || newx >= mark.size() || newy < 0 || newy >= mark[newx].size())
+            { //超过数组边界时
+                continue;
+            }
+            if (mark[newx][newy] == 0 && grid[newx][newy] == '1')
+            {
+                DFS(mark, grid, newx, newy);
+            }
+        }
+    }
+    int numIslands(vector<vector<char>> &grid)
+    {
+        int island_num = 0; //记载岛屿数量
+        vector<vector<int>> mark;
+        for (int i = 0; i < grid.size(); i++)
+        {
+            mark.push_back(vector<int>());
+            for (int j = 0; j < grid[i].size(); j++)
+            {
+                mark[i].push_back(0);
+            }
+        }
+        for (int i = 0; i < grid.size(); i++)
+        {
+            for (int j = 0; j < grid[i].size(); j++)
+            {
+                if (mark[i][j] == 0 && grid[i][j] == '1')
+                {
+                    DFS(mark, grid, i, j); //或BFS
+                    island_num++;
+                }
+            }
+        }
+        return island_num;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/200_数字范围按位与/solution.cpp

+class Solution
+{
+public:
+    int rangeBitwiseAnd(int m, int n)
+    {
+        int i = 0;
+        for (; m != n; ++i)
+        { //直到m == n的时候，得到的就是两者的公共前缀
+            m >>= 1;
+            n >>= 1;
+        }
+        return n << i;
+    }
+};

data/3.算法高阶/1.leetcode/201_快乐数/solution.cpp

+class Solution
+{
+public:
+    bool isHappy(int n)
+    {
+        map<int, int> m;
+        while (n != 1 && m.find(n) == m.end())
+        {
+            m.insert(pair<int, int>(n, 0));
+            int s = 0;
+            while (n)
+            {
+                s += pow((n % 10), 2);
+                n /= 10;
+            }
+            n = s;
+        }
+        if (n == 1)
+            return true;
+        else
+            return false;
+    }
+};

data/3.算法高阶/1.leetcode/202_移除链表元素/solution.cpp

+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *removeElements(ListNode *head, int val)
+    {
+        if (head == NULL)
+        {
+            return NULL;
+        }
+        head->next = removeElements(head->next, val);
+        return head->val == val ? head->next : head;
+    }
+};