Leetcode101.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "religious-contrast",
   "metadata": {},
   "source": [
    "\\？表示很难有思路\n",
    "\n",
    "\\!表示重看一遍思路\n",
    "\n",
    "Re表示重做"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loose-sheep",
   "metadata": {},
   "source": [
    "排序：`std::sort(g.begin(), g.end(), [](int a, int b){return a > b;}); // #include <algorithm> `\n",
    "\n",
    "求和：`accumulate(candies.begin(), candies.end(), 0); // 0是初始值 `"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "modern-shape",
   "metadata": {},
   "source": [
    "# 贪心算法"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "printable-heater",
   "metadata": {},
   "source": [
    "## 455. 分发饼干\n",
    "假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。\n",
    "\n",
    "对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。\n",
    "```CPP\n",
    "#include <algorithm>\n",
    "\n",
    "class Solution {\n",
    "public:\n",
    "    int findContentChildren(vector<int>& g, vector<int>& s) {\n",
    "        int index_g{0};\n",
    "        int index_s{0};\n",
    "        // 分别对两个数组排序\n",
    "        std::sort(g.begin(), g.end());\n",
    "        std::sort(s.begin(), s.end());\n",
    "        // 循环饼干数组\n",
    "        int temp_s{0};\n",
    "        while(index_g<g.size()&&index_s<s.size()){\n",
    "            if(s[index_s]>=g[index_g]){\n",
    "                index_g++;index_s++;\n",
    "            }\n",
    "            else{\n",
    "                index_s++;\n",
    "            }\n",
    "        }\n",
    "        return index_g;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "heard-garden",
   "metadata": {},
   "source": [
    "## ！135. 分发糖果\n",
    "n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。\n",
    "\n",
    "你需要按照以下要求，给这些孩子分发糖果：\n",
    "\n",
    "每个孩子至少分配到 1 个糖果。\n",
    "相邻两个孩子评分更高的孩子会获得更多的糖果。\n",
    "请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int candy(vector<int>& ratings) {\n",
    "        // 给予所有人一个糖果\n",
    "        vector<int> candies(ratings.size() ,1);\n",
    "        // 从左往右遍历，只判断右比左大，根据排名给予更多糖果\n",
    "        for(int i{0};i<ratings.size()-1;i++){\n",
    "            if(ratings[i+1]>ratings[i]){\n",
    "                candies[i+1]=candies[i]+1;\n",
    "            }\n",
    "        }\n",
    "        // 从右往左遍历，只判断左比右大，根据排名给予更多糖果\n",
    "        for(int i=ratings.size()-1;i>=1;i--){\n",
    "            if(ratings[i-1]>ratings[i]&&candies[i-1]<=candies[i]){\n",
    "                candies[i-1]=candies[i]+1;\n",
    "            }\n",
    "        }\n",
    "        return accumulate(candies.begin(), candies.end(), 0);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "according-penguin",
   "metadata": {},
   "source": [
    "## 435. 无重叠区间\n",
    "给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int eraseOverlapIntervals(vector<vector<int>>& intervals) {\n",
    "        // 选择从start排序还是end排序，若选择start排序则无法衡量区间的大小\n",
    "        // 1. 按照end排序 2. 遍历筛选，优先选择小且不重合的end\n",
    "        sort(intervals.begin(),intervals.end(),[](vector<int> &a, vector<int> &b)\n",
    "        {return a[1]<b[1];});\n",
    "        int n = intervals.size();\n",
    "        int remove_num{0};\n",
    "        int former_end{intervals[0][1]};  // 维护上一个没被丢弃的向量end\n",
    "        for(int i=1;i<n;++i){\n",
    "            if(intervals[i][0]<former_end){  //不重叠\n",
    "                ++remove_num;\n",
    "            }\n",
    "            else{\n",
    "                former_end = intervals[i][1];\n",
    "            }\n",
    "        }\n",
    "        return remove_num;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "patent-manor",
   "metadata": {},
   "source": [
    "## （Re）763. 划分字母区间\n",
    "给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。\n",
    "\n",
    "注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。\n",
    "\n",
    "返回一个表示每个字符串片段的长度的列表。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> partitionLabels(string s) {\n",
    "        /*  1. 检查最后一位数出现的索引列表\n",
    "            2. 用end变量表示当前选择的范围，\n",
    "        */\n",
    "        int last_index[26]{0};\n",
    "        for(int i{0};i<s.length();++i){\n",
    "            last_index[s[i]-'a']=i;\n",
    "        }\n",
    "        int start{0}, end{last_index[s[0]-'a']};\n",
    "        vector<int> o;\n",
    "        for(int i{1};i<s.length();++i){\n",
    "            int tp = s[i]-'a';\n",
    "            if(i>end){\n",
    "                o.push_back(end-start+1);\n",
    "                start=i+1;\n",
    "                end=last_index[s[i+1]-'a'];\n",
    "                continue;\n",
    "            }\n",
    "            end=max(last_index[tp],end);\n",
    "        }\n",
    "        return o;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "armed-category",
   "metadata": {},
   "source": [
    "## 122. 买卖股票的最佳时机 II\n",
    "**难点在于想到：只要比今天高就卖出**\n",
    "\n",
    "给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。\n",
    "\n",
    "在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。\n",
    "\n",
    "返回 你能获得的 最大 利润 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int maxProfit(vector<int>& prices) {\n",
    "        // 1. 只要比今天高就卖出 2. 遍历时维护最低价即可\n",
    "        int cur_price{prices[0]};\n",
    "        int o{0};\n",
    "        for(int i{1};i<prices.size();++i){\n",
    "            if(prices[i]>cur_price){\n",
    "                o=o+prices[i]-cur_price;\n",
    "            }\n",
    "            cur_price=prices[i];\n",
    "        }\n",
    "        return o;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unauthorized-owner",
   "metadata": {},
   "source": [
    "## 2！665. 非递减数列\n",
    "给你一个长度为 n 的整数数组 nums ，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。\n",
    "\n",
    "我们是这样定义一个非递减数列的： 对于数组中任意的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool checkPossibility(vector<int>& nums) {\n",
    "        // 顺序不正确时的两种处理方式：\n",
    "        // 1. 将当前值变小（与前一个值相等）默认，若条件不符合则采用方法2，在下一循环进行检查\n",
    "        // 2. 将当前值变大（与后一个值相等）\n",
    "        int n=nums.size();\n",
    "        bool count=false;\n",
    "        if(n==1) return true;\n",
    "        for(int i{0};i<n-1;++i){\n",
    "            if(nums[i]>nums[i+1]){\n",
    "                if(count) return false; // 若修改超过一次，则返回false\n",
    "                else{\n",
    "                    if(i==(n-2)){\n",
    "                        if(count) return false;\n",
    "                        else return true;\n",
    "                    }\n",
    "                    if(i==0){\n",
    "                        nums[0]=nums[1];\n",
    "                    }\n",
    "                    else{\n",
    "                        if(nums[i-1]>nums[i+1]){\n",
    "                            // 修改nums[i+1]=nums[i]\n",
    "                            nums[i+1]=nums[i];\n",
    "                        }\n",
    "                        else{\n",
    "                            nums[i]=nums[i-1];\n",
    "                        }\n",
    "                    }\n",
    "                    count=true;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return true;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "junior-construction",
   "metadata": {},
   "source": [
    "## 2！406. 根据身高重建队列\n",
    "假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。\n",
    "\n",
    "请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {\n",
    "        /*  1. 按高度排序，同样身高按个数排序\n",
    "            2. 循环,因为在列表里的均比当前高，所以直接右移选择位置即可\n",
    "            people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]\n",
    "            people = [[7,0],[7,1],[6,1],[5,0],[5,2],[4,4]]\n",
    "        */\n",
    "        sort(people.begin(),people.end(),[](vector<int> &a, vector<int> &b){\n",
    "            return a[0]>b[0] || (a[0]==b[0]&&a[1]<b[1]);\n",
    "            });\n",
    "        vector<vector<int>> o;\n",
    "        o.push_back(people[0]);\n",
    "        for(int i{1};i<people.size();++i){\n",
    "            o.insert(o.begin()+people[i][1],people[i]);\n",
    "        }\n",
    "        return o;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "municipal-montana",
   "metadata": {},
   "source": [
    "## 88. 合并两个有序数组\n",
    "给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。\n",
    "\n",
    "请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。\n",
    "\n",
    "注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {\n",
    "        // 从nums1的末尾从后往前排\n",
    "        int a{m-1},b{n-1},cur{m+n-1};\n",
    "        while(a>-1||b>-1){\n",
    "            if(a==-1){\n",
    "                for(int i{0};i<=b;++i){\n",
    "                    // cout<<\"1\";\n",
    "                    nums1[i]=nums2[i];\n",
    "                    // cout<<\"2\";\n",
    "                }\n",
    "                break;\n",
    "            }\n",
    "            if(b==-1){\n",
    "                break;\n",
    "            }\n",
    "            if(nums1[a]>nums2[b]){\n",
    "                nums1[cur]=nums1[a];\n",
    "                --a;\n",
    "                --cur;\n",
    "            }\n",
    "            else{\n",
    "                nums1[cur]=nums2[b];\n",
    "                --b;\n",
    "                --cur;\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "superb-valuation",
   "metadata": {},
   "source": [
    "## 142. 环形链表 II\n",
    "给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。\n",
    "\n",
    "如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。\n",
    "\n",
    "不允许修改 链表。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode *detectCycle(ListNode *head) {\n",
    "        // 快慢指针法\n",
    "        ListNode *slow{head},*fast{head};\n",
    "        while(fast->next!=nullptr&&fast!=nullptr){\n",
    "            fast=fast->next->next;\n",
    "            slow=slow->next;\n",
    "            if(fast==slow){\n",
    "                // 将fast移动至开头\n",
    "                fast=head;\n",
    "                while(fast!=slow){\n",
    "                    fast=fast->next;\n",
    "                    slow=slow->next;\n",
    "                }\n",
    "                return fast;\n",
    "            }\n",
    "        }\n",
    "        return nullptr;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "outer-saudi",
   "metadata": {},
   "source": [
    "## 69. x 的平方根 \n",
    "**注意**：\n",
    "1. 0和1的情况 \n",
    "2. mid>x/mid而不是mid\\*mid防止溢出\n",
    "\n",
    "给你一个非负整数 x ，计算并返回 x 的 算术平方根 。\n",
    "\n",
    "由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。\n",
    "\n",
    "注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int mySqrt(int x) {\n",
    "        if(x==0||x==1){\n",
    "            return x;\n",
    "        }\n",
    "        int start{0},end{x};\n",
    "        while(start<end){\n",
    "            int mid=(start+end)/2;\n",
    "            // cout<<mid;\n",
    "            if(mid>x/mid){\n",
    "                end=mid;\n",
    "            }\n",
    "            else{\n",
    "                if(start==mid){\n",
    "                    return mid;\n",
    "                }\n",
    "                start=mid;\n",
    "            }\n",
    "        }\n",
    "        return start;\n",
    "        // [07) [03) [13) [23)\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tested-accountability",
   "metadata": {},
   "source": [
    "# 双指针"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "private-network",
   "metadata": {},
   "source": [
    "## (Re)81. 搜索旋转排序数组 II\n",
    "已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。\n",
    "\n",
    "在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。\n",
    "\n",
    "给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。\n",
    "\n",
    "你必须尽可能减少整个操作步骤。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool search(vector<int>& nums, int target) {\n",
    "        // 二分查找\n",
    "        return binarySearch(nums,target,0,nums.size()-1);\n",
    "    }\n",
    "    bool binarySearch(vector<int>& nums, int target, int left, int right) {\n",
    "        if(left>right) return false;\n",
    "        if(left==right) return nums[left]==target;\n",
    "        int mid=(left+right)/2;\n",
    "        int mid_val=nums[mid];\n",
    "        if(mid_val==target){\n",
    "            return true;\n",
    "        }\n",
    "        if(mid_val<nums[left]){\n",
    "            if(target>mid_val&&target<nums[left]) return binarySearch(nums,target,mid+1,right);\n",
    "            else return binarySearch(nums,target,left,mid-1);\n",
    "        }\n",
    "        else{\n",
    "            if(mid==left) return binarySearch(nums,target,mid+1,right);\n",
    "            if(target<nums[left]){\n",
    "                if(target>mid_val) return binarySearch(nums,target,mid+1,right);\n",
    "                else return binarySearch(nums,target,left,mid-1);\n",
    "            }\n",
    "            else return binarySearch(nums,target,left,mid-1);\n",
    "        }\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "atmospheric-atmosphere",
   "metadata": {},
   "source": [
    "#  深广度优先搜索"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prepared-venice",
   "metadata": {},
   "source": [
    "## 695. 岛屿的最大面积\n",
    "给你一个大小为 m x n 的二进制矩阵 grid 。\n",
    "\n",
    "岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。\n",
    "\n",
    "岛屿的面积是岛上值为 1 的单元格的数目。\n",
    "\n",
    "计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int maxAreaOfIsland(vector<vector<int>>& grid) {\n",
    "        // 对遍历到的节点深度优先搜索，遍历后设置为0\n",
    "        int max_area{0};\n",
    "        int m=grid.size(), n=grid[0].size();\n",
    "        for(int i{0};i<m;++i){\n",
    "            for(int j{0};j<n;++j){\n",
    "                if(!grid[i][j]) continue;\n",
    "                // 深度搜索\n",
    "                int ta = findMaxArea(grid,i,j,m,n);\n",
    "                if(ta>max_area) max_area=ta;\n",
    "            }\n",
    "        }\n",
    "        return max_area;\n",
    "    }\n",
    "    int findMaxArea(vector<vector<int>>& grid, int i, int j, int& m, int &n){\n",
    "        int ta{1};\n",
    "        grid[i][j]=0;\n",
    "        stack<pair<int,int>> s;\n",
    "        s.push({i,j});\n",
    "        // 递归寻找上下左右四个方向\n",
    "        while(!s.empty()){\n",
    "            auto tp = s.top();\n",
    "            s.pop();\n",
    "            if(tp.second+1<n&&grid[tp.first][tp.second+1]){\n",
    "                grid[tp.first][tp.second+1]=0;\n",
    "                s.push(pair<int,int>{tp.first,tp.second+1});\n",
    "                ++ta;\n",
    "            }\n",
    "            if(tp.second-1>=0&&grid[tp.first][tp.second-1]){\n",
    "                grid[tp.first][tp.second-1]=0;\n",
    "                s.push(pair<int,int>{tp.first,tp.second-1});\n",
    "                ++ta;\n",
    "            }\n",
    "            if(tp.first+1<m&&grid[tp.first+1][tp.second]){\n",
    "                grid[tp.first+1][tp.second]=0;\n",
    "                s.push(pair<int,int>{tp.first+1,tp.second});\n",
    "                ++ta;\n",
    "            }\n",
    "            if(tp.first-1>=0&&grid[tp.first-1][tp.second]){\n",
    "                grid[tp.first-1][tp.second]=0;\n",
    "                s.push(pair<int,int>{tp.first-1,tp.second});\n",
    "                ++ta;\n",
    "            }\n",
    "        }\n",
    "        return ta;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "needed-wayne",
   "metadata": {},
   "source": [
    "## (Re)547. 省份数量\n",
    "**使用向量visited记录是否访问过**\n",
    "\n",
    "有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。\n",
    "\n",
    "省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。\n",
    "\n",
    "给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。\n",
    "\n",
    "返回矩阵中 省份 的数量。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int findCircleNum(vector<vector<int>>& isConnected) {\n",
    "        // 遍历j<i避免重复\n",
    "        // 深度搜索并将与其相连的置0\n",
    "        /*\n",
    "        1 1 0\n",
    "        1 1 0\n",
    "        0 0 1\n",
    "        */\n",
    "        stack<int> s;\n",
    "        int num{0};\n",
    "        vector<bool> visited(isConnected.size(), false);\n",
    "        for(int i{0};i<isConnected.size();++i){\n",
    "            for(int j{0};j<i;++j){\n",
    "                if(isConnected[i][j]==1){\n",
    "                    ++num;\n",
    "                    cout<<i<<\"\\t\"<<j<<\"\\n\";\n",
    "                    s.push(i);\n",
    "                    s.push(j);\n",
    "                    visited[i]=true;\n",
    "                    visited[j]=true;\n",
    "                    isConnected[i][j]=2;\n",
    "                    while(!s.empty()){\n",
    "                        int t{s.top()};\n",
    "                        s.pop();\n",
    "                        // 找到与该城市相连的城市并置0\n",
    "                        for(int k{0};k<t;++k){\n",
    "                            if(isConnected[t][k]){\n",
    "                                isConnected[t][k]=2;\n",
    "                                visited[k]=true;\n",
    "                                s.push(k);\n",
    "                            }\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        for(int i{0};i<isConnected.size();++i){\n",
    "            if(!visited[i]) ++num;\n",
    "        }\n",
    "        return num;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "surprising-contemporary",
   "metadata": {},
   "source": [
    "## (Re)417. 太平洋大西洋水流问题\n",
    "有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。\n",
    "\n",
    "这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵 heights ， heights[r][c] 表示坐标 (r, c) 上单元格 高于海平面的高度 。\n",
    "\n",
    "岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。\n",
    "\n",
    "返回网格坐标 result 的 2D 列表 ，其中 result[i] = [ri, ci] 表示雨水从单元格 (ri, ci) 流动 既可流向太平洋也可流向大西洋 。\n",
    "\n",
    "**思路1：采用深度优先，两块分开搜索，从边上开始深度搜索，最后进行统计**\n",
    "```CPP\n",
    "static const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n",
    "\n",
    "class Solution {\n",
    "public:\n",
    "    vector<vector<int>> heights;\n",
    "\n",
    "    void dfs(int row, int col, vector<vector<bool>> & ocean) {\n",
    "        int m = ocean.size();\n",
    "        int n = ocean[0].size();\n",
    "        if (ocean[row][col]) {   // 如果遍历过就不管了\n",
    "            return;\n",
    "        }\n",
    "        ocean[row][col] = true;\n",
    "        for (int i = 0; i < 4; i++) {\n",
    "            int newRow = row + dirs[i][0], newCol = col + dirs[i][1];\n",
    "            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && heights[newRow][newCol] >= heights[row][col]) {\n",
    "                dfs(newRow, newCol, ocean);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {\n",
    "        this->heights = heights;\n",
    "        int m = heights.size();\n",
    "        int n = heights[0].size();\n",
    "        vector<vector<bool>> pacific(m, vector<bool>(n, false));\n",
    "        vector<vector<bool>> atlantic(m, vector<bool>(n, false));\n",
    "\n",
    "        for (int i = 0; i < m; i++) {\n",
    "            dfs(i, 0, pacific);\n",
    "        }\n",
    "        for (int j = 1; j < n; j++) {\n",
    "            dfs(0, j, pacific);\n",
    "        }\n",
    "        for (int i = 0; i < m; i++) {\n",
    "            dfs(i, n - 1, atlantic);\n",
    "        }\n",
    "        for (int j = 0; j < n - 1; j++) {\n",
    "            dfs(m - 1, j, atlantic);\n",
    "        }\n",
    "        vector<vector<int>> result;\n",
    "        for (int i = 0; i < m; i++) {\n",
    "            for (int j = 0; j < n; j++) {\n",
    "                if (pacific[i][j] && atlantic[i][j]) {\n",
    "                    vector<int> cell;\n",
    "                    cell.emplace_back(i);\n",
    "                    cell.emplace_back(j);\n",
    "                    result.emplace_back(cell);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return result;\n",
    "    }\n",
    "};\n",
    "\n",
    "```\n",
    "思路2：广度优先\n",
    "\n",
    "```CPP\n",
    "static const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n",
    "\n",
    "class Solution {\n",
    "public:\n",
    "    vector<vector<int>> heights;\n",
    "    // 广度优先\n",
    "    void bfs(int row, int col, vector<vector<bool>> & ocean) {\n",
    "        if (ocean[row][col]) {\n",
    "            return;\n",
    "        }\n",
    "        int m = heights.size();\n",
    "        int n = heights[0].size();\n",
    "        ocean[row][col] = true;\n",
    "        queue<pair<int, int>> qu;\n",
    "        qu.emplace(row, col);\n",
    "        while (!qu.empty()) {\n",
    "            auto [row, col] = qu.front();\n",
    "            qu.pop();\n",
    "            for (int i = 0; i < 4; i++) {\n",
    "                int newRow = row + dirs[i][0], newCol = col + dirs[i][1];\n",
    "                if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && heights[newRow][newCol] >= heights[row][col] && !ocean[newRow][newCol]) {\n",
    "                    ocean[newRow][newCol] = true;\n",
    "                    qu.emplace(newRow, newCol);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {\n",
    "        this->heights = heights;\n",
    "        int m = heights.size();\n",
    "        int n = heights[0].size();\n",
    "        vector<vector<bool>> pacific(m, vector<bool>(n, false));\n",
    "        vector<vector<bool>> atlantic(m, vector<bool>(n, false));\n",
    "\n",
    "        for (int i = 0; i < m; i++) {\n",
    "            bfs(i, 0, pacific);\n",
    "        }\n",
    "        for (int j = 1; j < n; j++) {\n",
    "            bfs(0, j, pacific);\n",
    "        }\n",
    "        for (int i = 0; i < m; i++) {\n",
    "            bfs(i, n - 1, atlantic);\n",
    "        }\n",
    "        for (int j = 0; j < n - 1; j++) {\n",
    "            bfs(m - 1, j, atlantic);\n",
    "        }\n",
    "        vector<vector<int>> result;\n",
    "        for (int i = 0; i < m; i++) {\n",
    "            for (int j = 0; j < n; j++) {\n",
    "                if (pacific[i][j] && atlantic[i][j]) {\n",
    "                    vector<int> cell;\n",
    "                    cell.emplace_back(i);\n",
    "                    cell.emplace_back(j);\n",
    "                    result.emplace_back(cell);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return result;\n",
    "    }\n",
    "};\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hidden-emergency",
   "metadata": {},
   "source": [
    "# 动态规划"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deluxe-wagon",
   "metadata": {},
   "source": [
    "## 542. 01 矩阵\n",
    "给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。\n",
    "\n",
    "两个相邻元素间的距离为 1 。\n",
    "\n",
    "**法1：广度优先**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> tp{-1,0,1,0,-1};\n",
    "    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {\n",
    "        // 思路1：广度优先，将遍历到的0放入队列，然后按层级遍历其周围点，距离逐渐+1\n",
    "        int m=mat.size(),n=mat[0].size();\n",
    "        vector<vector<bool>> is_visited(m,vector<bool>(n,false));\n",
    "        vector<vector<int>> o(m,vector<int>(n,0));\n",
    "        queue<pair<int,int>> q;\n",
    "        // 首先找到所有的0\n",
    "        for(int i{0};i<m;++i){\n",
    "            for(int j{0};j<n;++j){\n",
    "                if(!mat[i][j]){\n",
    "                    q.emplace(i,j);\n",
    "                    is_visited[i][j]=true;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        // 广度优先\n",
    "        while(!q.empty()){\n",
    "            auto [a,b] = q.front();\n",
    "            q.pop();\n",
    "            for(int i{0};i<4;++i){\n",
    "                int c{a+tp[i]},d{b+tp[i+1]};\n",
    "                //在边界内且没访问过\n",
    "                if(c>-1&&c<m&&d>-1&&d<n&&!is_visited[c][d]){\n",
    "                    o[c][d]=o[a][b]+1; // 赋值为最近点距离+1\n",
    "                    is_visited[c][d]=true;\n",
    "                    q.emplace(c,d);  // 入队列\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return o;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "civilian-cutting",
   "metadata": {},
   "source": [
    "## 221. 最大正方形\n",
    "在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。\n",
    "\n",
    "**思路有问题，直接用DP即可，正方形严格遵守三个点的规则，而我用的DP+广度，时间没有通过**\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> tp{0,1,1,0};\n",
    "    int maximalSquare(vector<vector<char>>& matrix) {\n",
    "        // 广度搜索，循环查找正(n)\n",
    "        int m=matrix.size(),n=matrix[0].size();\n",
    "        queue<pair<int,int>> q;\n",
    "        vector<vector<int>> area(m,vector<int>(n,0));\n",
    "        // 将为1的加入队列\n",
    "        char c{'1'};\n",
    "        int max{0};\n",
    "        for(int i{0};i<m;++i){\n",
    "            for(int j{0};j<n;++j){\n",
    "                if(matrix[i][j]==c){\n",
    "                    q.emplace(i,j);\n",
    "                    area[i][j]=1;\n",
    "                    max=1;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        // 循环查找是否符合条件\n",
    "        while(!q.empty()){\n",
    "            auto [a,b]=q.front();\n",
    "            q.pop();\n",
    "            bool near{true};\n",
    "            for(int i{0};i<3;++i){\n",
    "                int c{a+tp[i]},d{b+tp[i+1]};\n",
    "                if(c>=m||d>=n||area[c][d]==0){ \n",
    "                    near=false;\n",
    "                    break;\n",
    "                }\n",
    "            }\n",
    "            // 若周围三点均符合，则入队列\n",
    "            if(near&&area[a+1][b]>=area[a+1][b+1]&&area[a][b+1]>=area[a+1][b+1]&&area[a][b]>=area[a+1][b+1]){\n",
    "                q.emplace(a+1,b+1);\n",
    "                // cout<<a+1<<\" \"<<b+1<<\"\\n\";\n",
    "                area[a+1][b+1]+=1;\n",
    "                if(area[a+1][b+1]>max) max=area[a+1][b+1];\n",
    "            }\n",
    "        }\n",
    "        return max*max;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coastal-mailing",
   "metadata": {},
   "source": [
    "## ！279. 完全平方数\n",
    "\n",
    "**非连续的DP问题，需要分解**\n",
    "\n",
    "给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。\n",
    "\n",
    "完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int numSquares(int n) {\n",
    "        // dp[i]=1+min(dp[i-j*j]) j*j<i\n",
    "        vector<int> dp(n+1,INT_MAX);\n",
    "        dp[0]=0;\n",
    "        for(int i{1};i<=n;++i){\n",
    "            int minn{INT_MAX};\n",
    "            for(int j{1};j*j<=i;++j){\n",
    "                minn=min(minn,dp[i-j*j]);\n",
    "            }\n",
    "            dp[i]=1+minn;\n",
    "        }\n",
    "        return dp[n];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "imported-watershed",
   "metadata": {},
   "source": [
    "## (Re)91. 解码方法\n",
    "一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：\n",
    "\n",
    "'A' -> \"1\"\n",
    "'B' -> \"2\"\n",
    "...\n",
    "'Z' -> \"26\"\n",
    "要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，\"11106\" 可以映射为：\n",
    "\n",
    "\"AAJF\" ，将消息分组为 (1 1 10 6)\n",
    "\"KJF\" ，将消息分组为 (11 10 6)\n",
    "注意，消息不能分组为  (1 11 06) ，因为 \"06\" 不能映射为 \"F\" ，这是由于 \"6\" 和 \"06\" 在映射中并不等价。\n",
    "\n",
    "给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。\n",
    "\n",
    "题目数据保证答案肯定是一个 32 位 的整数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "massive-rocket",
   "metadata": {},
   "source": [
    "## ！1143. 最长公共子序列\n",
    "\n",
    "**注意边界：需要用m+1**，若用m则初始化有问题\n",
    "\n",
    "给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。\n",
    "\n",
    "一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。\n",
    "\n",
    "例如，\"ace\" 是 \"abcde\" 的子序列，但 \"aec\" 不是 \"abcde\" 的子序列。\n",
    "两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int longestCommonSubsequence(string text1, string text2) {\n",
    "        int m=text1.length(),n=text2.length();\n",
    "        // 以二维数组代表第一个数组结尾和第二个数组结尾\n",
    "        vector<vector<int>> dp(m+1,vector<int>(n+1,0));\n",
    "        for(int i{1};i<=m;++i){\n",
    "            for(int j{1};j<=n;++j){\n",
    "                if(text1[i-1]==text2[j-1]){\n",
    "                    dp[i][j]=dp[i-1][j-1]+1;\n",
    "                }\n",
    "                else{\n",
    "                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return dp[m][n];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "resistant-headline",
   "metadata": {},
   "source": [
    "## (Re)416. 分割等和子集\n",
    "\n",
    "**与上相同注意边界：需要用m+1还是m**\n",
    "\n",
    "给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool canPartition(vector<int>& nums) {\n",
    "        int sum=accumulate(nums.begin(),nums.end(),0);\n",
    "        int n=nums.size();\n",
    "        if(sum%2||n<2) return false;\n",
    "        sum=sum/2;\n",
    "        // dp[i][j]表示从前i个元素中选取子集能是否否等于j\n",
    "        // dp[i][j]=true if dp[i-x][j-nums[i]]==true\n",
    "        vector<vector<bool>> dp(n,vector<bool>(sum+1,false));\n",
    "        for(int i{0};i<n;++i){\n",
    "            dp[i][0]=true;\n",
    "        }\n",
    "        for(int i{1};i<n;++i){\n",
    "            for(int j{1};j<=sum;++j){\n",
    "                if((j-nums[i])>=0){\n",
    "                    dp[i][j]=dp[i-1][j-nums[i]]|dp[i-1][j];\n",
    "                }\n",
    "                else{\n",
    "                    dp[i][j]=dp[i-1][j];\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        // cout<<sum<<\" \"<<nums[0]<<\"\\n\";\n",
    "        // for(auto el:dp){\n",
    "        //         cout << el <<\"\\n\";\n",
    "        // }\n",
    "        return dp[n-1][sum];\n",
    "    }\n",
    "};\n",
    "```\n",
    "**减少数组到一维**\n",
    "![image.png](attachment:image.png)\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool canPartition(vector<int>& nums) {\n",
    "        int n = nums.size();\n",
    "        if (n < 2) {\n",
    "            return false;\n",
    "        }\n",
    "        int sum = 0, maxNum = 0;\n",
    "        for (auto& num : nums) {\n",
    "            sum += num;\n",
    "            maxNum = max(maxNum, num);\n",
    "        }\n",
    "        if (sum & 1) {\n",
    "            return false;\n",
    "        }\n",
    "        int target = sum / 2;\n",
    "        if (maxNum > target) {\n",
    "            return false;\n",
    "        }\n",
    "        vector<int> dp(target + 1, 0);\n",
    "        dp[0] = true;\n",
    "        for (int i = 0; i < n; i++) {\n",
    "            int num = nums[i];\n",
    "            for (int j = target; j >= num; --j) {\n",
    "                dp[j] |= dp[j - num];\n",
    "            }\n",
    "        }\n",
    "        return dp[target];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "insured-keyboard",
   "metadata": {},
   "source": [
    "## 474. 一和零\n",
    "给你一个二进制字符串数组 strs 和两个整数 m 和 n 。\n",
    "\n",
    "请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。\n",
    "\n",
    "如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。\n",
    "\n",
    "**无空间优化：**\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int findMaxForm(vector<string>& strs, int m, int n) {\n",
    "        // dp[i][j]表示包含第i个元素时且0的个数为j个时的最大子集\n",
    "        // j的取值为0-m，i的取值为0-i，\n",
    "        int nv=strs.size();\n",
    "        vector<vector<vector<int>>> dp(nv+1,vector<vector<int>>(m+1,vector<int>(n+1,0)));\n",
    "        // dp[0]=vector<int>(m+1,0);\n",
    "\n",
    "        for(int i{1};i<nv+1;++i){\n",
    "            // 统计当前字符串中的0个数\n",
    "            int n_zero{0};\n",
    "            for(const char& el:strs[i-1]){\n",
    "                if(el=='0') n_zero+=1;\n",
    "            }\n",
    "            int n_one=strs[i-1].length()-n_zero;\n",
    "            for(int j{0};j<m+1;++j){\n",
    "                for(int k{0};k<n+1;++k){\n",
    "                    // 分包含当前元素和不包含当前元素\n",
    "                    if(j-n_zero>=0&&k-n_one>=0){\n",
    "                        dp[i][j][k]=max(dp[i-1][j][k],dp[i-1][j-n_zero][k-n_one]+1);\n",
    "                    }\n",
    "                    else{\n",
    "                        dp[i][j][k]=dp[i-1][j][k];\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return dp[nv][m][n];\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "空间优化：\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int findMaxForm(vector<string>& strs, int m, int n) {\n",
    "        // dp[i][j][k]表示包含第i个元素时且0的个数为j个时的最大子集\n",
    "        // j的取值为0-m，i的取值为0-i，\n",
    "        // 空间优化：去除第i层，从大到小遍历\n",
    "        int nv=strs.size();\n",
    "        vector<vector<int>> dp(m+1,vector<int>(n+1,0));\n",
    "        // dp[0]=vector<int>(m+1,0);\n",
    "\n",
    "        for(int i{1};i<nv+1;++i){\n",
    "            // 统计当前字符串中的0个数\n",
    "            int n_zero{0};\n",
    "            for(const char& el:strs[i-1]){\n",
    "                if(el=='0') n_zero+=1;\n",
    "            }\n",
    "            int n_one=strs[i-1].length()-n_zero;\n",
    "            for(int j{m};j>=0;--j){\n",
    "                for(int k{n};k>=0;--k){\n",
    "                    // 分包含当前元素和不包含当前元素\n",
    "                    if(j-n_zero>=0&&k-n_one>=0){\n",
    "                        dp[j][k]=max(dp[j][k],dp[j-n_zero][k-n_one]+1);\n",
    "                    }\n",
    "                    else{\n",
    "                        dp[j][k]=dp[j][k];\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return dp[m][n];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hidden-ancient",
   "metadata": {},
   "source": [
    "## 322. 零钱兑换\n",
    "给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。\n",
    "\n",
    "计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。\n",
    "\n",
    "你可以认为每种硬币的数量是无限的。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int coinChange(vector<int>& coins, int amount) {\n",
    "        if(!amount) return 0;\n",
    "        // dp[i][j]表示包含第i个面额的硬币时且金额为j时的最小数量\n",
    "        int m=coins.size();\n",
    "        vector<int> dp(amount+1,-1);\n",
    "        // 初始化，金额为0时数量为0\n",
    "        dp[0]=0;\n",
    "\n",
    "        for(int i{1};i<m+1;++i){\n",
    "            int change{coins[i-1]};\n",
    "            for(int j{amount};j>=0;--j){\n",
    "                // 遍历所有数量\n",
    "                int num{0},sub{j},minn{-1};\n",
    "                while(sub>=0){\n",
    "                    // cout<<num<<\"\\t\"<<sub<<'\\n';\n",
    "                    if(dp[sub]==-1){\n",
    "                        num++;\n",
    "                        sub-=change;\n",
    "                        continue;\n",
    "                    }\n",
    "                    if(minn==-1){\n",
    "                        minn=dp[sub]+num;\n",
    "                    }\n",
    "                    else{\n",
    "                        minn=min(dp[sub]+num,minn);\n",
    "                    }\n",
    "                    num++;\n",
    "                    sub-=change;\n",
    "                }\n",
    "                dp[j]=minn;\n",
    "            }\n",
    "        }\n",
    "        return dp[amount];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "demanding-ultimate",
   "metadata": {},
   "source": [
    "## ？650. 只有两个键的键盘\n",
    "最初记事本上只有一个字符 'A' 。你每次可以对这个记事本进行两种操作：\n",
    "\n",
    "Copy All（复制全部）：复制这个记事本中的所有字符（不允许仅复制部分字符）。\n",
    "Paste（粘贴）：粘贴 上一次 复制的字符。\n",
    "给你一个数字 n ，你需要使用最少的操作次数，在记事本上输出 恰好 n 个 'A' 。返回能够打印出 n 个 'A' 的最少操作次数。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int minSteps(int n) {\n",
    "        vector<int> dp(n + 1);\n",
    "        int h = sqrt(n);\n",
    "        // dp[1]=0 不需要初始化\n",
    "        for (int i = 2; i <= n; ++i) {\n",
    "            dp[i] = i;\n",
    "            for (int j = 2; j <= h; ++j) {\n",
    "                if (i % j == 0) {\n",
    "                    dp[i] = dp[j] + dp[i / j];\n",
    "                    break;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return dp[n];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incident-mortgage",
   "metadata": {},
   "source": [
    "## ！309. 最佳买卖股票时机含冷冻期\n",
    "**设定三个状态**\n",
    "\n",
    "给定一个整数数组prices，其中第  prices[i] 表示第 i 天的股票价格 。\n",
    "\n",
    "设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:\n",
    "\n",
    "卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。\n",
    "注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int maxProfit(vector<int>& prices) {\n",
    "        /* 第i天的累计收益 dp[i][j] j=0 持有股票 j=1 冷冻 j=2 不持有且无冷冻\n",
    "           持有股票：dp[i][0]=max(dp[i-1][0], dp[i-1][2]-prices[i])\n",
    "           冷冻：dp[i][1]=dp[i-1][0]+prices[i]\n",
    "           不持有：dp[i][2]=max(dp[i-1][2],dp[i-1][1])  要么前一天不持有，要么前一天冷冻\n",
    "        */\n",
    "        int n=prices.size();\n",
    "        vector<vector<int>> dp(n+1, vector<int>(3,0)); \n",
    "        dp[1][0]=-prices[0];\n",
    "        for(int i{2};i<n+1;++i){\n",
    "             dp[i][0]=max(dp[i-1][0], dp[i-1][2]-prices[i-1]);\n",
    "             dp[i][1]=dp[i-1][0]+prices[i-1];\n",
    "             dp[i][2]=max(dp[i-1][2],dp[i-1][1]);\n",
    "        }\n",
    "        return max(dp[n][1],dp[n][2]);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "possible-contribution",
   "metadata": {},
   "source": [
    "## 714. 买卖股票的最佳时机含手续费\n",
    "给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。\n",
    "\n",
    "你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。\n",
    "\n",
    "返回获得利润的最大值。\n",
    "\n",
    "注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。\n",
    "\n",
    " \n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int maxProfit(vector<int>& prices, int fee) {\n",
    "        /*  dp[i][0] 表示持有的状态 \n",
    "            dp[i][1] 表示不持有的状态\n",
    "        */\n",
    "        int n=prices.size();\n",
    "        if(n==1) return 0;\n",
    "        vector<vector<int>> dp(n,vector<int>(2,0));\n",
    "        dp[0][0]=-prices[0];\n",
    "        for(int i{1};i<n;++i){\n",
    "            dp[i][0]=max(dp[i-1][1]-prices[i],dp[i-1][0]); // 当天买入或持有\n",
    "            dp[i][1]=max(dp[i-1][0]+prices[i]-fee,dp[i-1][1]); // 当天卖出或之前不持有\n",
    "        }\n",
    "        return dp[n-1][1];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "architectural-column",
   "metadata": {},
   "source": [
    "# 数据结构"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "instructional-italy",
   "metadata": {},
   "source": [
    "## ！448. 找到所有数组中消失的数字\n",
    "给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> findDisappearedNumbers(vector<int>& nums) {\n",
    "        // 标记已经出现的数为nums[i]+n，使用nums[i]%n还原\n",
    "        int n=nums.size();\n",
    "        vector<int> v;\n",
    "        for(auto &num:nums){\n",
    "            nums[(num-1)%n]+=n;\n",
    "        }\n",
    "        for(int i{0};i<n;++i){\n",
    "            if(nums[i]<=n) v.push_back(i+1);\n",
    "        }\n",
    "        return v;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diagnostic-sympathy",
   "metadata": {},
   "source": [
    "## ！ [560. 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k/)\n",
    "\n",
    "给你一个整数数组 `nums` 和一个整数 `k` ，请你统计并返回 *该数组中和为 `k` 的连续子数组的个数* 。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int subarraySum(vector<int>& nums, int k) {\n",
    "        // 使用哈希表记录前缀和为X的个数\n",
    "        unordered_map<int,int> m;\n",
    "        int count{0},n=nums.size(),acc{0};\n",
    "        m[0]=1;\n",
    "        for(int i{0};i<n;++i){\n",
    "            acc+=nums[i];\n",
    "            // 设当前数为b，之前符合条件的数为a则：b-a=k，这个等式对只有一个元素同样有效\n",
    "            if(m.count(acc-k)) count+=m[acc-k];\n",
    "            // 添加当前i的前缀和\n",
    "            if(m.count(acc)) m[acc]+=1; \n",
    "            else m[acc]=1;\n",
    "        }\n",
    "        return count;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "running-burke",
   "metadata": {},
   "source": [
    "## ！[78. 子集](https://leetcode.cn/problems/subsets/)\n",
    "\n",
    "给你一个整数数组 `nums` ，数组中的元素 **互不相同** 。返回该数组所有可能的子集（幂集）。\n",
    "\n",
    "解集 **不能** 包含重复的子集。你可以按 **任意顺序** 返回解集。\n",
    "\n",
    "法1：使用0和1表示\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<vector<int>> subsets(vector<int>& nums) {\n",
    "        // 法1：设一个元素在子集中存在的情况为1，不存在为0，则总共有2的n次方种情况\n",
    "        //  即遍历从0-2的n次方，将其转为二进制数，然后遍历每一位选取子集\n",
    "        int n=nums.size(),size_sub=pow(2,n);\n",
    "        vector<vector<int>> out;\n",
    "        vector<int> sub;\n",
    "        for(int i{0};i<size_sub;++i){\n",
    "            int cur=0,tp{i};\n",
    "            while(tp){\n",
    "                if(tp%2==1){\n",
    "                    sub.push_back(nums[cur]);\n",
    "                }\n",
    "                tp=tp/2;\n",
    "                ++cur;\n",
    "            }\n",
    "            out.push_back(sub);\n",
    "            sub.clear();\n",
    "        }\n",
    "        return out;\n",
    "    }\n",
    "};\n",
    "```\n",
    "法2：使用0和1表示，且使用移位符操作\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<vector<int>> subsets(vector<int>& nums) {\n",
    "        int n=nums.size(),size_sub=1<<n;\n",
    "        vector<vector<int>> out;\n",
    "        vector<int> sub;\n",
    "        for(int i{0};i<size_sub;++i){\n",
    "            sub.clear();\n",
    "            int cur=0,tp{i};\n",
    "            while(tp){\n",
    "                if(tp%2){\n",
    "                    sub.push_back(nums[cur]);\n",
    "                }\n",
    "                tp=tp>>1;\n",
    "                ++cur;\n",
    "            }\n",
    "            out.push_back(sub);\n",
    "        }\n",
    "        return out;\n",
    "    }\n",
    "};\n",
    "```\n",
    "法3：递归思路\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> t;\n",
    "    vector<vector<int>> ans;\n",
    "\n",
    "    void dfs(int cur, vector<int>& nums) {\n",
    "        if (cur == nums.size()) {\n",
    "            ans.push_back(t);\n",
    "            return;\n",
    "        }\n",
    "        t.push_back(nums[cur]); //选择当前元素\n",
    "        dfs(cur + 1, nums);\n",
    "        t.pop_back();           //不选择当前元素\n",
    "        dfs(cur + 1, nums);\n",
    "    }\n",
    "\n",
    "    vector<vector<int>> subsets(vector<int>& nums) {\n",
    "        dfs(0, nums);\n",
    "        return ans;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "martial-prediction",
   "metadata": {},
   "source": [
    "# 位运算\n",
    "位运算可以用来取代求2的n次方，即`1<<n`\n",
    "\n",
    "也可以用来除以2，即`n>>1`"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "prescription-animation",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "perceived-intranet",
   "metadata": {},
   "source": [
    "# 链表\n",
    "```CPP\n",
    "struct ListNode{\n",
    "    int val;\n",
    "    ListNode *next;\n",
    "    ListNode(int x):val(x),next(nullptr){};\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "inner-application",
   "metadata": {},
   "source": [
    "## 206. 反转链表\n",
    "给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* reverseList(ListNode* head) {\n",
    "        ListNode *prev{nullptr}, *next;\n",
    "        while(head){\n",
    "            next=head->next; // 保存下一个节点\n",
    "            head->next=prev; // 改变节点指向\n",
    "            prev=head;       // 下一轮的节点指向是当前\n",
    "            head=next;\n",
    "        }\n",
    "        return prev;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eastern-masters",
   "metadata": {},
   "source": [
    "## 21. 合并两个有序链表\n",
    "将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 \n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {\n",
    "        ListNode* head=new ListNode(0);  // !!!这里必须动态分配新内存！\n",
    "        ListNode* tp=head;\n",
    "        while(list1||list2){\n",
    "            if(!list1){ // list1到遍历到末尾\n",
    "                head->next=list2;\n",
    "                break;\n",
    "            }\n",
    "            else if(!list2){\n",
    "                head->next=list1;\n",
    "                break;\n",
    "            }\n",
    "            if(list1->val<list2->val){\n",
    "                head->next=list1;\n",
    "                list1=list1->next;\n",
    "                head=head->next;\n",
    "            }\n",
    "            else{\n",
    "                head->next=list2;\n",
    "                list2=list2->next;\n",
    "                head=head->next;\n",
    "            }\n",
    "        }\n",
    "        return tp->next;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thousand-radar",
   "metadata": {},
   "source": [
    "## ！160. 相交链表\n",
    "给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {\n",
    "        ListNode *tp1{headA}, *tp2{headB};\n",
    "        if(!tp1||!tp2) return nullptr;\n",
    "        while(tp1!=tp2){\n",
    "            tp1=tp1?tp1->next:headB;\n",
    "            tp2=tp2?tp2->next:headA;\n",
    "        }\n",
    "        return tp1;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "choice-playing",
   "metadata": {},
   "source": [
    "## （Re）234. 回文链表\n",
    "给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。\n",
    "\n",
    "法1\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool isPalindrome(ListNode* head) {\n",
    "        ListNode* fast{head},*slow{head};\n",
    "        // 法1：快慢指针+栈\n",
    "        stack<int> s;\n",
    "        s.push(slow->val);\n",
    "        // 偶数链表slow在中左，奇数在中间\n",
    "        while(fast){\n",
    "            if(fast->next){\n",
    "                fast=fast->next->next;\n",
    "                if(fast){ \n",
    "                    slow=slow->next;\n",
    "                }\n",
    "                else{ // 偶数情况\n",
    "                    break;\n",
    "                }\n",
    "            }\n",
    "            else{ // 奇数情况下中间的值不需要比较\n",
    "                s.pop();\n",
    "                break;\n",
    "            }\n",
    "            s.push(slow->val);\n",
    "        }\n",
    "        slow=slow->next;\n",
    "        while(!s.empty()){\n",
    "            int tp{s.top()};\n",
    "            s.pop();\n",
    "            if(!slow||slow->val!=tp) return false;\n",
    "            slow=slow->next;\n",
    "        }\n",
    "        return slow?false:true;\n",
    "    }\n",
    "};\n",
    "```\n",
    "法2\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool isPalindrome(ListNode* head) {\n",
    "        if(!(head->next)) return true;\n",
    "        ListNode* fast{head},*slow{head};\n",
    "        // 法2：快慢指针+反转前半段\n",
    "        ListNode *next{head->next}, *prev{nullptr};\n",
    "        // 偶数链表slow在中左，奇数在中间\n",
    "        while(fast){\n",
    "            if(fast->next){\n",
    "                fast=fast->next->next;\n",
    "                // 反转\n",
    "                next=slow->next;\n",
    "                slow->next=prev;\n",
    "                prev=slow;\n",
    "                slow=next;\n",
    "            }\n",
    "            else{\n",
    "                // 奇数情况\n",
    "                next=next->next;\n",
    "                break;\n",
    "            }\n",
    "        }\n",
    "        while(prev&&next){\n",
    "            if(prev->val!=next->val) return false;\n",
    "            else{\n",
    "                prev=prev->next;\n",
    "                next=next->next;\n",
    "            }\n",
    "        }\n",
    "        return !prev&&!next?true:false;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bibliographic-digest",
   "metadata": {},
   "source": [
    "## ！19. 删除链表的倒数第 N 个结点\n",
    "**如何通过前后指针找到第 N 个结点**\n",
    "\n",
    "给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* removeNthFromEnd(ListNode* head, int n) {\n",
    "        if(!head->next) return nullptr;\n",
    "        // 前后指针，后指针比前指针后n个，其为倒数n个节点的前一个节点\n",
    "        ListNode *fast{head},*slow{head}, *dp;\n",
    "        while(n){\n",
    "            fast=fast->next;\n",
    "            --n;\n",
    "        }\n",
    "        // 边界1：待删除节点为第一个节点\n",
    "        if(!fast) return head->next;\n",
    "        while(fast){\n",
    "            fast=fast->next;\n",
    "            dp=slow;\n",
    "            slow=slow->next;\n",
    "        }\n",
    "        // 边界2：删除最后一个节点\n",
    "        if(dp->next->next){\n",
    "            dp->next=dp->next->next;\n",
    "        }\n",
    "        else{\n",
    "            dp->next=nullptr;\n",
    "        }\n",
    "        return head;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "living-compact",
   "metadata": {},
   "source": [
    "## ！[82. 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/)\n",
    "\n",
    "**官解简化版：使用dummy节点指向头节点，以避免头节点的讨论**\n",
    "给定一个已排序的链表的头 `head` ， *删除原始链表中所有重复数字的节点，只留下不同的数字* 。返回 *已排序的链表* 。\n",
    "\n",
    "1\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* deleteDuplicates(ListNode* head) {\n",
    "        if (!head) {\n",
    "            return head;\n",
    "        }\n",
    "        \n",
    "        ListNode* dummy = new ListNode(0, head);\n",
    "\n",
    "        ListNode* cur = dummy;\n",
    "        while (cur->next && cur->next->next) {\n",
    "            if (cur->next->val == cur->next->next->val) {\n",
    "                int x = cur->next->val;\n",
    "                while (cur->next && cur->next->val == x) {\n",
    "                    cur->next = cur->next->next;\n",
    "                }\n",
    "            }\n",
    "            else {\n",
    "                cur = cur->next;\n",
    "            }\n",
    "        }\n",
    "\n",
    "        return dummy->next;\n",
    "    }\n",
    "};\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "2\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* deleteDuplicates(ListNode* head) {\n",
    "        ListNode *dummy{new ListNode(0)},*prev{dummy},*next;\n",
    "        dummy->next=head;\n",
    "        int cur=INT_MAX;\n",
    "        // 若当前值与已删除节点的值相同，或与下一个值重复，则删除\n",
    "        while(head){\n",
    "            if(head->val==cur){\n",
    "                next=head->next;\n",
    "                prev->next=next;\n",
    "                delete head;\n",
    "                head=next;\n",
    "            }\n",
    "            else if(head->next&&head->next->val==head->val){\n",
    "                cur=head->val;\n",
    "                next=head->next->next;\n",
    "                prev->next=next;\n",
    "                delete head->next;\n",
    "                delete head;\n",
    "                head=next;\n",
    "            }\n",
    "            else{\n",
    "                prev=head;\n",
    "                head=head->next;\n",
    "            }\n",
    "        }\n",
    "        return dummy->next;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "laden-disorder",
   "metadata": {},
   "source": [
    "## [2. 两数相加](https://leetcode.cn/problems/add-two-numbers/)\n",
    "\n",
    "给你两个 **非空** 的链表，表示两个非负的整数。它们每位数字都是按照 **逆序** 的方式存储的，并且每个节点只能存储 **一位** 数字。\n",
    "\n",
    "请你将两个数相加，并以相同形式返回一个表示和的链表。\n",
    "\n",
    "你可以假设除了数字 0 之外，这两个数都不会以 0 开头。\n",
    "\n",
    "**直观思路：用数表示，但会溢出**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n",
    "        // 法1：用两个数\n",
    "        long long int a{0},b{0},sum,digit{1};\n",
    "        while(l1){\n",
    "            a=a+l1->val*digit;\n",
    "            l1=l1->next;\n",
    "            digit*=10;\n",
    "        }\n",
    "        digit=1;\n",
    "        while(l2){\n",
    "            b=b+l2->val*digit;\n",
    "            l2=l2->next;\n",
    "            digit*=10;\n",
    "        }\n",
    "        sum=a+b;\n",
    "        // cout<<sum;\n",
    "        // 以逆序构建链表\n",
    "        ListNode *out=new ListNode(0), *dummy{out};\n",
    "        if(!sum) return out;\n",
    "        while(sum){\n",
    "            out->val=sum%10;\n",
    "            sum/=10;\n",
    "            if(sum) out->next=new ListNode(0);\n",
    "            else break;\n",
    "            out=out->next;\n",
    "        }\n",
    "        return dummy;\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "**直接两个链表相加**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n",
    "        // 法2：两个链表相加\n",
    "        ListNode *dummy{new ListNode(0)},*head{dummy};\n",
    "        int up{0},val;\n",
    "        while(l1&&l2){\n",
    "            dummy->next=new ListNode(0);\n",
    "            dummy=dummy->next;\n",
    "            val=l1->val+l2->val+up;\n",
    "            dummy->val=val%10;\n",
    "            if(val/10) up=1;\n",
    "            else up=0;\n",
    "            l1=l1->next;\n",
    "            l2=l2->next;\n",
    "        }\n",
    "        if(l1){\n",
    "            while(l1){\n",
    "                dummy->next=new ListNode(0);\n",
    "                dummy=dummy->next;\n",
    "                val=l1->val+up;\n",
    "                dummy->val=val%10;\n",
    "                if(val/10) up=1;\n",
    "                else up=0;\n",
    "                l1=l1->next;\n",
    "            }\n",
    "        }\n",
    "        if(l2){\n",
    "            while(l2){\n",
    "                dummy->next=new ListNode(0);\n",
    "                dummy=dummy->next;\n",
    "                val=l2->val+up;\n",
    "                dummy->val=val%10;\n",
    "                if(val/10) up=1;\n",
    "                else up=0;\n",
    "                l2=l2->next;\n",
    "            }\n",
    "        }\n",
    "        if(up) dummy->next=new ListNode(1);\n",
    "        return head->next;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bibliographic-carter",
   "metadata": {},
   "source": [
    "https://leetcode.cn/problems/sort-list/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abroad-detector",
   "metadata": {},
   "source": [
    "## [148. 排序链表](https://leetcode.cn/problems/sort-list/)\n",
    "\n",
    "给你链表的头结点 `head` ，请将其按 **升序** 排列并返回 **排序后的链表** 。\n",
    "\n",
    "法1：归并排序\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    ListNode* sortList(ListNode* head) {\n",
    "        return sortList(head, nullptr);\n",
    "    }\n",
    "\n",
    "    ListNode* sortList(ListNode* head, ListNode* tail) {\n",
    "        if (head == nullptr) {\n",
    "            return head;\n",
    "        }\n",
    "        if (head->next == tail) {\n",
    "            head->next = nullptr;\n",
    "            return head;\n",
    "        }\n",
    "        ListNode* slow = head, *fast = head;\n",
    "        while (fast != tail) {\n",
    "            slow = slow->next;\n",
    "            fast = fast->next;\n",
    "            if (fast != tail) {\n",
    "                fast = fast->next;\n",
    "            }\n",
    "        }\n",
    "        ListNode* mid = slow;\n",
    "        return merge(sortList(head, mid), sortList(mid, tail));\n",
    "    }\n",
    "\n",
    "    ListNode* merge(ListNode* head1, ListNode* head2) {\n",
    "        ListNode* dummyHead = new ListNode(0);\n",
    "        ListNode* temp = dummyHead, *temp1 = head1, *temp2 = head2;\n",
    "        while (temp1 != nullptr && temp2 != nullptr) {\n",
    "            if (temp1->val <= temp2->val) {\n",
    "                temp->next = temp1;\n",
    "                temp1 = temp1->next;\n",
    "            } else {\n",
    "                temp->next = temp2;\n",
    "                temp2 = temp2->next;\n",
    "            }\n",
    "            temp = temp->next;\n",
    "        }\n",
    "        if (temp1 != nullptr) {\n",
    "            temp->next = temp1;\n",
    "        } else if (temp2 != nullptr) {\n",
    "            temp->next = temp2;\n",
    "        }\n",
    "        return dummyHead->next;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "narrative-straight",
   "metadata": {},
   "source": [
    "## ！！！[143. 重排链表](https://leetcode.cn/problems/reorder-list/)\n",
    "\n",
    "给定一个单链表 `L` 的头节点 `head` ，单链表 `L` 表示为：\n",
    "\n",
    "```\n",
    "L0 → L1 → … → Ln - 1 → Ln\n",
    "```\n",
    "\n",
    "请将其重新排列后变为：\n",
    "\n",
    "```\n",
    "L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …\n",
    "```\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    void reorderList(ListNode* head) {\n",
    "        /*\n",
    "            1. 快慢指针找到中点，倒排后半部分\n",
    "            2. 插入\n",
    "        */\n",
    "        ListNode *fast{head}, *slow{head}, *tp, *next, *out{head};\n",
    "        while(fast){\n",
    "            if(fast->next) fast=fast->next->next;\n",
    "            else fast=fast->next;\n",
    "            slow=slow->next;\n",
    "        }\n",
    "        // 若无节点或只有一个节点，直接返回\n",
    "        if(!slow) return;\n",
    "        // 此时slow是后半部分的起点，反转即可\n",
    "        next=slow->next;\n",
    "        slow->next=nullptr;\n",
    "        while(next){\n",
    "            // 存储next->next\n",
    "            tp=next->next;\n",
    "            // 将next指向当前值\n",
    "            next->next=slow;\n",
    "            // 当前值为下一个值\n",
    "            slow=next;\n",
    "            next=tp; \n",
    "        }\n",
    "        // 此时slow是后半部分的头部\n",
    "        while(slow){\n",
    "            next=head->next;\n",
    "            tp=slow->next;\n",
    "            head->next=slow;\n",
    "            slow->next=next;\n",
    "            head=next;\n",
    "            slow=tp;\n",
    "        }\n",
    "        if(head) head->next=nullptr;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "listed-teaching",
   "metadata": {},
   "source": [
    "# 二叉树\n",
    "## 遍历顺序\n",
    "前序遍历先遍历父结点，再遍历左结点，最后遍历右节点，我们得到的遍历顺序是[1 2 4 5 3\n",
    "6]。\n",
    "```CPP\n",
    "void preorder(TreeNode* root) {\n",
    "visit(root);\n",
    "preorder(root->left);\n",
    "preorder(root->right);\n",
    "}\n",
    "```\n",
    "\n",
    "中序遍历先遍历左节点，再遍历父结点，最后遍历右节点，我们得到的遍历顺序是[4 2 5 1 3\n",
    "6]。\n",
    "```CPP\n",
    "void inorder(TreeNode* root) {\n",
    "inorder(root->left);\n",
    "visit(root);\n",
    "inorder(root->right);\n",
    "}\n",
    "```\n",
    "\n",
    "后序遍历先遍历左节点，再遍历右结点，最后遍历父节点，我们得到的遍历顺序是[4 5 2 6 3\n",
    "1]。\n",
    "```CPP\n",
    "void postorder(TreeNode* root) {\n",
    "postorder(root->left);\n",
    "postorder(root->right);\n",
    "visit(root);\n",
    "}\n",
    "```\n",
    "二叉查找树（Binary Search Tree, BST）是一种特殊的二叉树：对于每个父节点，其左子节点的值小于等于父结点的值，其右子节点的值大于等于父结点的值。\n",
    "\n",
    "## 存储方式\n",
    "普通二叉树 一般采用 链式存储结构 ，比如 二叉链表，三叉链表；\n",
    "完全二叉树 一般采用 顺序存储结构，比如 数组；\n",
    "\n",
    "**采用数组存储的完全二叉树：假设数组下标从 1 开始，二叉树 的根结点存储在位置 1，如果根结点有左孩子，左孩子存储在位置 2 = 2 * 1，如果根结点有右孩子，右孩子存储在位置 3 = 2 * 1 + 1。对于存储在位置 i 的结点，如果它有左孩子，左孩子存储在位置 2 * i，如果它有右孩子，右孩子存储在位置 2 * i + 1。**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "regulated-effect",
   "metadata": {},
   "source": [
    "## 110. 平衡二叉树\n",
    "**核心在于深度遍历的同时检查节点是否平衡**\n",
    "\n",
    "给定一个二叉树，判断它是否是高度平衡的二叉树。\n",
    "\n",
    "本题中，一棵高度平衡二叉树定义为：\n",
    "\n",
    "一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool isBalanced(TreeNode* root) {\n",
    "        if(!root) return true;\n",
    "        // 深度遍历，在遍历时检查每个节点\n",
    "         return nodeBalanced(root)==-1?false:true;\n",
    "    }\n",
    "\n",
    "    int nodeBalanced(TreeNode* root) {\n",
    "        // 深度遍历\n",
    "        if(!root) return 0;\n",
    "        // 检查当前节点的子节点深度\n",
    "        int left_d=nodeBalanced(root->left), right_d=nodeBalanced(root->right);\n",
    "        if(left_d==-1||right_d==-1||abs(left_d-right_d)>=2) return -1;\n",
    "        // 返回当前节点深度\n",
    "        int maxd{1};\n",
    "        maxd= maxd+std::max(left_d, right_d);\n",
    "        return maxd;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nominated-perspective",
   "metadata": {},
   "source": [
    "## （Re）437. 路径总和 III\n",
    "给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。\n",
    "\n",
    "路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    unordered_map<long long, int> prefix;\n",
    "\n",
    "    int dfs(TreeNode *root, long long curr, int targetSum) {\n",
    "        if (!root) {\n",
    "            return 0;\n",
    "        }\n",
    "\n",
    "        int ret = 0;\n",
    "        curr += root->val;\n",
    "        if (prefix.count(curr - targetSum)) {\n",
    "            ret = prefix[curr - targetSum];\n",
    "        }\n",
    "\n",
    "        prefix[curr]++;\n",
    "        ret += dfs(root->left, curr, targetSum);\n",
    "        ret += dfs(root->right, curr, targetSum);\n",
    "        prefix[curr]--;\n",
    "\n",
    "        return ret;\n",
    "    }\n",
    "\n",
    "    int pathSum(TreeNode* root, int targetSum) {\n",
    "        prefix[0] = 1;\n",
    "        return dfs(root, 0, targetSum);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "large-charge",
   "metadata": {},
   "source": [
    "## ！101. 对称二叉树\n",
    "**关键在于用两个节点进行层次遍历**\n",
    "\n",
    "给你一个二叉树的根节点 root ， 检查它是否轴对称。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool isSymmetric(TreeNode* root) {\n",
    "        return root?chileNodeSym(root->right,root->left):true;\n",
    "    }\n",
    "\n",
    "    bool chileNodeSym(TreeNode *right,TreeNode *left){\n",
    "        if(!right&&!left) return true;\n",
    "        else if(!right||!left||right->val!=left->val) return false;\n",
    "        return chileNodeSym(right->right,left->left)&&chileNodeSym(right->left,left->right);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "virtual-windows",
   "metadata": {},
   "source": [
    "## !层次遍历：637. 二叉树的层平均值\n",
    "给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。\n",
    "\n",
    " ```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<double> averageOfLevels(TreeNode* root) {\n",
    "        vector<double> ans;\n",
    "        if (!root) {\n",
    "            return ans;\n",
    "        }\n",
    "        queue<TreeNode*> q;\n",
    "        q.push(root);\n",
    "        while (!q.empty()) {\n",
    "            int count = q.size();\n",
    "            double sum = 0;\n",
    "            for (int i = 0; i < count; ++i) {\n",
    "                TreeNode* node = q.front();\n",
    "                q.pop();\n",
    "                sum += node->val;\n",
    "                if (node->left) {\n",
    "                    q.push(node->left);\n",
    "                }\n",
    "                if (node->right) {\n",
    "                    q.push(node->right);\n",
    "                }\n",
    "            }\n",
    "            ans.push_back(sum / count);\n",
    "        }\n",
    "        return ans;\n",
    "    }\n",
    "    };\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "literary-cradle",
   "metadata": {},
   "source": [
    "## (TODO)105. 从前序与中序遍历序列构造二叉树\n",
    "给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    unordered_map<int,int> m;\n",
    "    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {\n",
    "        /*  前序是中左右，中序是左中右\n",
    "            中序遍历中根节点左边为左子树根节点，通过左子树值在前序中找到右子树值\n",
    "            由于无重复元素，可直接对应查找inorder\n",
    "            buildTreeHelper给定子树的preorder区间，构造子树\n",
    "        */\n",
    "        TreeNode *t{new TreeNode(preorder[0])}, *o{t};\n",
    "        for(int i{0};i<inorder.size();++i){\n",
    "            m.insert({inorder[i],i});\n",
    "        }\n",
    "        buildTreeHelper(t,preorder,0,preorder.size()-1);\n",
    "        return o;\n",
    "    }\n",
    "    void buildTreeHelper(TreeNode *t, vector<int>& preorder, int p1, int p2){\n",
    "        // 边界\n",
    "        if(p1>=p2) return;\n",
    "        // p1为该子树开始节点即中心节点，p2为该子树结束节点\n",
    "        int num{0}; // 左子树范围\n",
    "        // if(t->val==2){\n",
    "        //     cout<<p1<<\"\\t\"<<p2<<\"\\t\"<<num<<\"\\t\";\n",
    "        // }\n",
    "        if(m[preorder[p1+1]]>=m[t->val]){ // 左子树节点不存在\n",
    "            t->left=nullptr;\n",
    "        }\n",
    "        else{\n",
    "            // 左节点\n",
    "            t->left=new TreeNode(preorder[p1+1]);\n",
    "            // 构建左子树\n",
    "            num=m[t->val]-p1;\n",
    "            buildTreeHelper(t->left,preorder,p1+1,p1+num);\n",
    "        }\n",
    "        // 右节点，范围是[p1+1+num,p2]\n",
    "        // 右子树节点不存在的两种情况：1.越界 2.右节点在中节点左边\n",
    "        if(p2<p1+1+num||m[preorder[p1+1+num]]<=m[t->val]){ \n",
    "            t->right=nullptr;\n",
    "        }\n",
    "        else{\n",
    "            // 右节点\n",
    "            t->right=new TreeNode(preorder[p1+1+num]);\n",
    "            // 构建右子树\n",
    "            buildTreeHelper(t->right,preorder,p1+1+num,p2);\n",
    "        }\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "automotive-karaoke",
   "metadata": {},
   "source": [
    "## ！[669. 修剪二叉搜索树](https://leetcode.cn/problems/trim-a-binary-search-tree/)\n",
    "\n",
    "**重点在于**只关注当前节点，如不符合则返回符合的节点，递归实现\n",
    "\n",
    "给你二叉搜索树的根节点 `root` ，同时给定最小边界`low` 和最大边界 `high`。通过修剪二叉搜索树，使得所有节点的值在`[low, high]`中。修剪树 **不应该** 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 **唯一的答案** 。\n",
    "\n",
    "所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    TreeNode* trimBST(TreeNode* root, int low, int high) {\n",
    "        if(!root) return nullptr;\n",
    "        // 递归实现，对于不符合要求的节点，返回其符合要求的子节点\n",
    "        int val{root->val};\n",
    "        // 检查当前节点\n",
    "        if(val<low){\n",
    "            root=trimBST(root->right,low,high);\n",
    "        }\n",
    "        else if(val>high){\n",
    "            root=trimBST(root->left,low,high);\n",
    "        }\n",
    "        if(!root) return nullptr;\n",
    "        // 检查左右节点\n",
    "        root->left=trimBST(root->left,low,high);\n",
    "        root->right=trimBST(root->right,low,high);\n",
    "        return root;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lightweight-ecuador",
   "metadata": {},
   "source": [
    "## [208. 实现 Trie (前缀树)](https://leetcode.cn/problems/implement-trie-prefix-tree/)\n",
    "\n",
    "难度中等1427\n",
    "\n",
    "**[Trie](https://baike.baidu.com/item/字典树/9825209?fr=aladdin)**（发音类似 \"try\"）或者说 **前缀树** 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。\n",
    "```CPP\n",
    "#include<iostream>\n",
    "#include<string>\n",
    "#include <vector>\n",
    "\n",
    "using namespace std;\n",
    "\n",
    "class TrieNode {\n",
    "public:\n",
    "    bool is_val;\n",
    "    vector<TrieNode*> alpha;\n",
    "\n",
    "    TrieNode():is_val(false){\n",
    "        for(int i{0};i<26;++i){\n",
    "            alpha.push_back(nullptr);\n",
    "        }\n",
    "    };\n",
    "};\n",
    "\n",
    "class Trie {\n",
    "public:\n",
    "    /*  字典树\n",
    "        1. 每个节点代表一个单词\n",
    "        2. 每个节点的子节点有26个子节点\n",
    "        3. 子节点按顺序排列，值用布尔表示以这个字母结尾的单词是否存在\n",
    "    */\n",
    "    TrieNode *root;\n",
    "\n",
    "    Trie() {\n",
    "        root=new TrieNode();\n",
    "        root->is_val=true;\n",
    "    }\n",
    "\n",
    "    void insert(const string& word) {\n",
    "        TrieNode *t{root};\n",
    "        if(!word.size()) return;\n",
    "        // 插入每个节点，将单词的最后一个字母节点设定为true\n",
    "        for(const char &c:word){\n",
    "            if(!t->alpha[c-'a']){\n",
    "                t->alpha[c-'a']=new TrieNode();\n",
    "            }\n",
    "            t=t->alpha[c-'a'];\n",
    "        }\n",
    "        t->is_val= true;\n",
    "    }\n",
    "\n",
    "    bool search(const string& word) {\n",
    "        TrieNode *t{root};\n",
    "        int n=word.size();\n",
    "        for(int i{0};i<n;++i){\n",
    "            if(!t) return false;\n",
    "            t=t->alpha[word[i]-'a'];\n",
    "        }\n",
    "        // 检查当前节点有无值\n",
    "        return t?t->is_val:false;\n",
    "    }\n",
    "\n",
    "    bool startsWith(const string& prefix) {\n",
    "        TrieNode *t{root};\n",
    "        for(const char &c:prefix){\n",
    "            if(!t) return false;\n",
    "            // cout<<c<<\"\\n\";\n",
    "            t=t->alpha[c-'a'];\n",
    "        }\n",
    "        return t?true:false;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tracked-costume",
   "metadata": {},
   "source": [
    "## ！[662. 二叉树最大宽度](https://leetcode.cn/problems/maximum-width-of-binary-tree/)\n",
    "\n",
    "给你一棵二叉树的根节点 `root` ，返回树的 **最大宽度** 。\n",
    "\n",
    "树的 **最大宽度** 是所有层中最大的 **宽度** 。\n",
    "\n",
    "每一层的 **宽度** 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 `null` 节点，这些 `null` 节点也计入长度。\n",
    "\n",
    "题目数据保证答案将会在 **32 位** 带符号整数范围内。\n",
    "\n",
    "**法1：层次遍历+采用数组索引标号完全二叉树的方式计算宽度**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int widthOfBinaryTree(TreeNode* root) {\n",
    "        // 层次遍历+采用数组索引标号完全二叉树的方式计算宽度\n",
    "        unsigned long long depth_max{1};\n",
    "        queue<pair<TreeNode*,unsigned long long>> s;\n",
    "        s.emplace(root,1L);\n",
    "        while(!s.empty()){ // 去除一层中的所有节点，计算最大最小宽度\n",
    "            // 这里方式有问题，直接最右边节点减去最左边即可\n",
    "            unsigned long long left{s.front().second},right{s.front().second},size=s.size();\n",
    "            for(int i{0};i<size;++i){\n",
    "                auto [t,index]=s.front();\n",
    "                s.pop();\n",
    "                left=min(index,left);\n",
    "                right=max(index,right);\n",
    "                // 加入左右子节点\n",
    "                // cout<<left<<\" \"<<right<<\" \"<<index<<endl;\n",
    "                if(t->left) s.emplace(t->left,2*index);\n",
    "                if(t->right) s.emplace(t->right,2*index+1);\n",
    "            }\n",
    "            depth_max=max(depth_max,right-left+1);\n",
    "        }\n",
    "        return depth_max;\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "**法2：使用深度优先搜索，只对每一层的第一个值进行存储，其他值只进行比较求宽度。用一个哈希表记录每一层的宽度**\n",
    "```CPP\n",
    "using ULL = unsigned long long;\n",
    "\n",
    "class Solution {\n",
    "public:\n",
    "    int widthOfBinaryTree(TreeNode* root) {\n",
    "        unordered_map<int, ULL> levelMin;\n",
    "        function<ULL(TreeNode*, int, ULL)> dfs = [&](TreeNode* node, int depth, ULL index)->ULL {\n",
    "            if (node == nullptr) {\n",
    "                return 0LL;\n",
    "            }\n",
    "            if (!levelMin.count(depth)) {\n",
    "                levelMin[depth] = index; // 每一层最先访问到的节点会是最左边的节点，即每一层编号的最小值\n",
    "            }\n",
    "            return max({index - levelMin[depth] + 1LL, dfs(node->left, depth + 1, index * 2), dfs(node->right, depth + 1, index * 2 + 1)});\n",
    "        };\n",
    "        return dfs(root, 1, 1LL);\n",
    "    }\n",
    "};\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cooked-drinking",
   "metadata": {},
   "source": [
    "# 字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "german-horror",
   "metadata": {},
   "source": [
    "## 647. 回文子串\n",
    "给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。\n",
    "\n",
    "回文字符串 是正着读和倒过来读一样的字符串。\n",
    "\n",
    "子字符串 是字符串中的由连续字符组成的一个序列。\n",
    "\n",
    "具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。\n",
    "\n",
    "**法1：穷举法**\n",
    "```CPP\n",
    "class Solution:\n",
    "    def countSubstrings(self, s: str) -> int:\n",
    "        l=len(s)\n",
    "        count=0\n",
    "        for i in range(l):\n",
    "            for j in range(i,l):\n",
    "                if self.isSub(s[i:j+1]):\n",
    "                    count+=1\n",
    "        return count\n",
    "\n",
    "    def isSub(self,s):\n",
    "        if s==s[::-1]:\n",
    "            # print(s)\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "```\n",
    "\n",
    "**法2：以中心位置穷举**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int countSubstrings(string s) {\n",
    "        int num = 0;\n",
    "        int n = s.size(); \n",
    "        for(int i=0;i<n;i++)//遍历回文中心点\n",
    "        {\n",
    "            for(int j=0;j<=1;j++)//j=0,中心是一个点，j=1,中心是两个点\n",
    "            {\n",
    "                int l = i;\n",
    "                int r = i+j;\n",
    "                while(l>=0 && r<n && s[l--]==s[r++])num++;\n",
    "            }\n",
    "        }\n",
    "        return num;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "photographic-scottish",
   "metadata": {},
   "source": [
    "## ！[5. 最长回文子串](https://leetcode.cn/problems/longest-palindromic-substring/)\n",
    "\n",
    "给你一个字符串 `s`，找到 `s` 中最长的回文子串。\n",
    "\n",
    "如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    string longestPalindrome(string s) {\n",
    "        /*\n",
    "            1. dp[i][j]表示从i到j的字符子串是否为回文\n",
    "            2. dp[i][j]=dp[i+1][j-1]&&s[i]==s[j]?true:false;\n",
    "            3. j-i<3只需判断s[i]==s[j]\n",
    "        */\n",
    "        int n=s.length();\n",
    "        vector<bool> dp(n);\n",
    "        int start{0},max_length{0};\n",
    "        for(int i{n-1};i>=0;--i){\n",
    "            for(int j{n-1};j>=i;--j){\n",
    "                if(j-i<3) dp[j]=(s[i]==s[j])?true:false;\n",
    "                else dp[j]=(dp[j-1]&&s[i]==s[j])?true:false;\n",
    "                if(dp[j]&&max_length<j-i+1){\n",
    "                    start=i;\n",
    "                    max_length=j-i+1;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return s.substr(start,max_length);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "virtual-cycle",
   "metadata": {},
   "source": [
    "## ！696. 计数二进制子串\n",
    "给定一个字符串 s，统计并返回具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是成组连续的。\n",
    "\n",
    "重复出现（不同位置）的子串也要统计它们出现的次数。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int countBinarySubstrings(string s) {\n",
    "        int n=s.length(),num{0};\n",
    "        if(n==1) return 0;\n",
    "        // 记录以s[i]结尾的连续数，l1是0的，l2是1的\n",
    "        int l0{0},l1{0};\n",
    "        if(s[0]=='0'){\n",
    "            ++l0;\n",
    "        }\n",
    "        else{\n",
    "            ++l1;\n",
    "        }\n",
    "        for(int i{1};i<n;++i){\n",
    "            if(s[i]=='1'){\n",
    "                if(s[i-1]=='0'){\n",
    "                    l1=1;\n",
    "                    ++num;\n",
    "                }\n",
    "                else{\n",
    "                    if(l1+1<=l0) ++num;\n",
    "                    ++l1;\n",
    "                }\n",
    "            }\n",
    "            else{\n",
    "                if(s[i-1]=='1'){\n",
    "                    l0=1;\n",
    "                    ++num;\n",
    "                }\n",
    "                else{\n",
    "                    if(l0+1<=l1) ++num;\n",
    "                    ++l0;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return num;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "antique-theta",
   "metadata": {},
   "source": [
    "## ！227. 基本计算器 II\n",
    "给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。\n",
    "\n",
    "整数除法仅保留整数部分。\n",
    "\n",
    "你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。\n",
    "\n",
    "注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int calculate(string s) {\n",
    "        /*\n",
    "            !!!可能会溢出，所以用double\n",
    "            1. 每次遇到符号时处理前一个符号的值，这样可以保证符号前后值均已知\n",
    "            2. 使用数组管理所有数，最后进行加减\n",
    "            3. 前置符号为+号\n",
    "        */\n",
    "        char preSign='+';\n",
    "        vector<int> nums;\n",
    "        int i{0},n=s.length();\n",
    "        double cur_num{0};\n",
    "        while(i<=n){\n",
    "            char s_i= i==n?'+':s[i];\n",
    "            ++i;\n",
    "            if(s_i==' ') continue;\n",
    "            else if(isdigit(s_i)){\n",
    "                cur_num=s_i-'0';\n",
    "                while(isdigit(s[i])){\n",
    "                    cur_num=cur_num*10+s[i]-'0';\n",
    "                    ++i;\n",
    "                }\n",
    "            }\n",
    "            else{ //处理符号\n",
    "                switch(preSign){\n",
    "                    case '+':\n",
    "                        nums.push_back(cur_num);\n",
    "                        break;\n",
    "                    case '-':\n",
    "                        nums.push_back(-cur_num);\n",
    "                        break;\n",
    "                    case '*':\n",
    "                        nums.back()*=cur_num;\n",
    "                        break;\n",
    "                    case '/':\n",
    "                        nums.back()/=cur_num;\n",
    "                        break;\n",
    "                }\n",
    "                // 将当前符号设为前一个符号\n",
    "                preSign=s_i;\n",
    "            }\n",
    "        }\n",
    "        return accumulate(nums.begin(),nums.end(),0);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "median-flower",
   "metadata": {},
   "source": [
    "## （Re）241. 为运算表达式设计优先级\n",
    "给你一个由数字和运算符组成的字符串 expression ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。\n",
    "\n",
    "生成的测试用例满足其对应输出值符合 32 位整数范围，不同结果的数量不超过 104 。\n",
    "\n",
    "**法1：分治法：计算符号左右两边可能的情况，边界条件为只有单个数字**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> diffWaysToCompute(string input) {\n",
    "        vector<int> ways;\n",
    "        for (int i = 0; i < input.length(); i++) {\n",
    "            char c = input[i];\n",
    "            if (c == '+' || c == '-' || c == '*') {\n",
    "                vector<int> left = diffWaysToCompute(input.substr(0, i));\n",
    "                vector<int> right = diffWaysToCompute(input.substr(i + 1));\n",
    "                for (const int & l: left) {\n",
    "                    for (const int & r: right) {\n",
    "                        switch (c) {\n",
    "                            case '+': ways.push_back(l + r); break;\n",
    "                            case '-': ways.push_back(l - r); break;\n",
    "                            case '*': ways.push_back(l * r); break;\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        if (ways.empty()) ways.push_back(stoi(input));\n",
    "        return ways;\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "**法2：直接使用动态规划**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> diffWaysToCompute(string input) {\n",
    "        vector<int> data;\n",
    "        vector<char> ops;\n",
    "        int num = 0;\n",
    "        char op = ' ';\n",
    "        istringstream ss(input + \"+\");\n",
    "        // 分别保存数字和运算符\n",
    "        while (ss >> num && ss >> op) {\n",
    "            data.push_back(num);\n",
    "            ops.push_back(op);\n",
    "        }\n",
    "        int n = data.size();\n",
    "        // 表示左右区间的右端点为i，左端点为j的情况数目\n",
    "        // 两个for为遍历i,j之间的所有区间种类数，即[j,k]和[k+1,i]\n",
    "        vector<vector<vector< int>>> dp(n, vector < vector < int >> (n, vector<int>()));\n",
    "        for (int i = 0; i < n; ++i) {\n",
    "            for (int j = i; j >= 0; --j) {\n",
    "                if (i == j) {\n",
    "                    dp[j][i].push_back(data[i]);\n",
    "                } else {\n",
    "                    for (int k = j; k < i; k += 1) {\n",
    "                        for (auto left: dp[j][k]) {\n",
    "                            for (auto right: dp[k + 1][i]) {\n",
    "                                int val = 0;\n",
    "                                switch (ops[k]) {\n",
    "                                    case '+':\n",
    "                                        val = left + right;\n",
    "                                        break;\n",
    "                                    case '-':\n",
    "                                        val = left - right;\n",
    "                                        break;\n",
    "                                    case '*':\n",
    "                                        val = left * right;\n",
    "                                        break;\n",
    "                                }\n",
    "                                dp[j][i].push_back(val);\n",
    "                            }\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return dp[0][n - 1];\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "filled-amber",
   "metadata": {},
   "source": [
    "# 排序\n",
    "1. 插入排序：从0开始遍历，保持0到遍历点的序列顺序正确（即调整第i个数到正确的顺序）\n",
    "2. 冒泡排序：从0开始遍历，比较i和i+1的大小，维持大的值在右边，这样最大值在一次迭代后会在最右边\n",
    "3. 选择排序：从0开始遍历，选出最小的值排在最左边\n",
    "4. 归并排序（分治法）：不断分块，然后排序\n",
    "5. 桶排序：划分区间，放入区间，区间内排序，取出\n",
    "6. 快速排序（归并法+冒泡排序）：选一个数作为基准值，将比它小的值放在他左边，大的值放在右边，递归排序左右两个区间"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nearby-council",
   "metadata": {},
   "source": [
    "## RE 3. 无重复字符的最长子串\n",
    "\n",
    "给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。\n",
    "\n",
    "法1：动态规划+查找之前的字符是否相等\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int lengthOfLongestSubstring(string s) {\n",
    "        /*\n",
    "        dp解法，dp[i]表示以第i+1个为结尾的最长子串\n",
    "        dp[i]=dp[i-1]+1 \n",
    "        */\n",
    "        int n=s.length(),maxx{1};\n",
    "        if(!n) return 0;\n",
    "        int i1{1},i2{1};\n",
    "        for(int i{1};i<n;++i){\n",
    "            bool t{true};\n",
    "            for(int j{i-i1};j<i;++j){\n",
    "                if(s[i]==s[j]){\n",
    "                    i2=i-j;\n",
    "                    t=false;\n",
    "                    break;\n",
    "                }\n",
    "            }\n",
    "            if(t) i2=i1+1;\n",
    "            i1=i2;\n",
    "            maxx=max(maxx,i2);\n",
    "        }\n",
    "        return maxx;\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "法2：使用哈希减少匹配时间，维护动态窗口\n",
    "\n",
    "```cpp\n",
    "class Solution {\n",
    "public:\n",
    "    int lengthOfLongestSubstring(string s) {\n",
    "        // 哈希集合，记录每个字符是否出现过\n",
    "        unordered_set<char> occ;\n",
    "        int n = s.size();\n",
    "        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动\n",
    "        int rk = -1, ans = 0;\n",
    "        // 枚举左指针的位置，初始值隐性地表示为 -1\n",
    "        for (int i = 0; i < n; ++i) {\n",
    "            if (i != 0) {\n",
    "                // 左指针向右移动一格，移除一个字符\n",
    "                occ.erase(s[i - 1]);\n",
    "            }\n",
    "            while (rk + 1 < n && !occ.count(s[rk + 1])) {\n",
    "                // 不断地移动右指针\n",
    "                occ.insert(s[rk + 1]);\n",
    "                ++rk;\n",
    "            }\n",
    "            // 第 i 到 rk 个字符是一个极长的无重复字符子串\n",
    "            ans = max(ans, rk - i + 1);\n",
    "        }\n",
    "        return ans;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "novel-rouge",
   "metadata": {},
   "source": [
    "## 其他解法[347. 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements/)\n",
    "\n",
    "给你一个整数数组 `nums` 和一个整数 `k` ，请你返回其中出现频率前 `k` 高的元素。你可以按 **任意顺序** 返回答案。\n",
    "\n",
    "法1：自己写的\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<int> topKFrequent(vector<int>& nums, int k) {\n",
    "        int n=nums.size();\n",
    "        if(n==1) return vector<int>{1};\n",
    "        vector<int> v1;\n",
    "        vector<pair<int,int>> p;\n",
    "        // 桶\n",
    "        unordered_map<int,int> m;\n",
    "        for(int i{0};i<n;++i){\n",
    "            ++m[nums[i]];\n",
    "        }\n",
    "        // 取出并排序\n",
    "        for(auto i{m.begin()};i!=m.end();++i){\n",
    "            p.push_back({i->first,i->second});\n",
    "        }\n",
    "        sort(p.begin(),p.end(),[](auto& a, auto& b){\n",
    "            return a.second>b.second;\n",
    "        });\n",
    "        for(int i{0};i<k;++i){\n",
    "            v1.push_back(p[i].first);\n",
    "        }\n",
    "        return v1;\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "法2：双桶，桶排序后在使用频率作为桶对其排序\n",
    "\n",
    "```CPP\n",
    "vector<int> topKFrequent(vector<int>& nums, int k) {\n",
    "unordered_map<int, int> counts;\n",
    "int max_count = 0;\n",
    "for (const int & num : nums) {\n",
    "max_count = max(max_count, ++counts[num]);\n",
    "}\n",
    "vector<vector<int>> buckets(max_count + 1);\n",
    "for (const auto & p : counts) {\n",
    "buckets[p.second].push_back(p.first);\n",
    "}\n",
    "vector<int> ans;\n",
    "for (int i = max_count; i >= 0 && ans.size() < k; --i) {\n",
    "for (const int & num : buckets[i]) {\n",
    "ans.push_back(num);\n",
    "if (ans.size() == k) {\n",
    "break;\n",
    "}\n",
    "}\n",
    "}\n",
    "return ans;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "marine-bachelor",
   "metadata": {},
   "source": [
    "## (Re)[215. 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/)\n",
    "\n",
    "给定整数数组 `nums` 和整数 `k`，请返回数组中第 `**k**` 个最大的元素。\n",
    "\n",
    "请注意，你需要找的是数组排序后的第 `k` 个最大的元素，而不是第 `k` 个不同的元素。\n",
    "\n",
    "你必须设计并实现时间复杂度为 `O(n)` 的算法解决此问题。\n",
    "\n",
    "**法1：最大堆排序，执行k次删除操作即可**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    void maxHeapify(vector<int>& a, int i, int heapSize) {\n",
    "        int l = i * 2 + 1, r = i * 2 + 2, largest = i;\n",
    "        if (l < heapSize && a[l] > a[largest]) {\n",
    "            largest = l;\n",
    "        } \n",
    "        if (r < heapSize && a[r] > a[largest]) {\n",
    "            largest = r;\n",
    "        }\n",
    "        if (largest != i) {\n",
    "            swap(a[i], a[largest]);\n",
    "            maxHeapify(a, largest, heapSize);\n",
    "        }\n",
    "    }\n",
    "\n",
    "    void buildMaxHeap(vector<int>& a, int heapSize) {\n",
    "        for (int i = heapSize / 2; i >= 0; --i) {\n",
    "            maxHeapify(a, i, heapSize);\n",
    "        } \n",
    "    }\n",
    "\n",
    "    int findKthLargest(vector<int>& nums, int k) {\n",
    "        int heapSize = nums.size();\n",
    "        buildMaxHeap(nums, heapSize);\n",
    "        for (int i = nums.size() - 1; i >= nums.size() - k + 1; --i) {\n",
    "            swap(nums[0], nums[i]);\n",
    "            --heapSize;\n",
    "            maxHeapify(nums, 0, heapSize);\n",
    "        }\n",
    "        return nums[0];\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "**法2：快速排序+选择区间，随机选择中心点**\n",
    " ```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int quickSelect(vector<int>& a, int l, int r, int index) {\n",
    "        int q = randomPartition(a, l, r);\n",
    "        if (q == index) {\n",
    "            return a[q];\n",
    "        } else {\n",
    "            return q < index ? quickSelect(a, q + 1, r, index) : quickSelect(a, l, q - 1, index);\n",
    "        }\n",
    "    }\n",
    "\n",
    "    inline int randomPartition(vector<int>& a, int l, int r) {\n",
    "        int i = rand() % (r - l + 1) + l;\n",
    "        swap(a[i], a[r]);\n",
    "        return partition(a, l, r);\n",
    "    }\n",
    "\n",
    "    inline int partition(vector<int>& a, int l, int r) {\n",
    "        int x = a[r], i = l - 1;\n",
    "        for (int j = l; j < r; ++j) {\n",
    "            if (a[j] <= x) {\n",
    "                swap(a[++i], a[j]);\n",
    "            }\n",
    "        }\n",
    "        swap(a[i + 1], a[r]);\n",
    "        return i + 1;\n",
    "    }\n",
    "\n",
    "    int findKthLargest(vector<int>& nums, int k) {\n",
    "        srand(time(0));\n",
    "        return quickSelect(nums, 0, nums.size() - 1, nums.size() - k);\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "musical-rebecca",
   "metadata": {},
   "source": [
    "## （RE）快速排序：[912. 排序数组](https://leetcode.cn/problems/sort-an-array/)\n",
    "\n",
    "难度中等820\n",
    "\n",
    "给你一个整数数组 `nums`，请你将该数组升序排列。\n",
    "\n",
    "**1：hoare方法，找到两个可以交换的元素才进行交换，超出时间限制**\n",
    "```CPP\n",
    "#include<iostream>\n",
    "#include<string>\n",
    "#include <vector>\n",
    "\n",
    "using namespace std;\n",
    "\n",
    "void quickSort(vector<int>& nums,int i,int j){\n",
    "    if(i>=j) return;\n",
    "    cout<<i<<\"\\t\"<<j<<\"\\n\";\n",
    "    // 取最左边的数，双指针m和n，nums[m]<num_k&&nums[n]>num_k则交换\n",
    "    int num_k{nums[i]},m{i+1},n{j};\n",
    "    while(m<n){\n",
    "//        cout<<m<<n;\n",
    "        while(m<n&&nums[m]<=num_k) ++m;\n",
    "        while(m<n&&nums[n]>=num_k) --n;\n",
    "        swap(nums[m],nums[n]);\n",
    "    }\n",
    "    // 用的最左边的元素作为k，因此要换到左区间来\n",
    "//    if(num_k<nums[m]&&m>i){\n",
    "//        m-=1;\n",
    "//    }\n",
    "    swap(nums[i],nums[m]);\n",
    "    // 递归\n",
    "    quickSort(nums,i,m-1);\n",
    "    quickSort(nums,m+1,j);\n",
    "}\n",
    "\n",
    "vector<int> sortArray(vector<int>& nums) {\n",
    "    /* 快速排序 选一个数，将比他小的放左边\n",
    "    */\n",
    "    int n=nums.size();\n",
    "    quickSort(nums,0,n-1);\n",
    "    return nums;\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    vector<int> a{5,4,3,1,2};\n",
    "    sortArray(a);\n",
    "    for(auto el:a)\n",
    "    {\n",
    "        cout<<el<<\"\\t\";\n",
    "    }    \n",
    "    return 0;\n",
    "}\n",
    "```"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "exotic-salmon",
   "metadata": {},
   "source": [
    "# 回溯法\n",
    "回溯法，一般可以解决如下几种问题：组合和排序问题\n",
    "\n",
    "+ 组合问题：N个数里面按一定规则找出k个数的集合\n",
    "+ 切割问题：一个字符串按一定规则有几种切割方式\n",
    "+ 子集问题：一个N个数的集合里有多少符合条件的子集\n",
    "+ 排列问题：N个数按一定规则全排列，有几种排列方式\n",
    "+ 棋盘问题：N皇后，解数独等等\n",
    "\n",
    "回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！\n",
    "\n",
    "因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。\n",
    "\n",
    "递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "**大致算法**\n",
    "```CPP\n",
    "void backtracking(参数) {\n",
    "    if (终止条件) {\n",
    "        存放结果;\n",
    "        return;\n",
    "    }\n",
    "\n",
    "    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {\n",
    "        处理节点;\n",
    "        backtracking(路径，选择列表); // 递归\n",
    "        回溯，撤销处理结果\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "multiple-arlington",
   "metadata": {},
   "source": [
    "## ！[93. 复原 IP 地址](https://leetcode.cn/problems/restore-ip-addresses/)\n",
    "\n",
    "**有效 IP 地址** 正好由四个整数（每个整数位于 `0` 到 `255` 之间组成，且不能含有前导 `0`），整数之间用 `'.'` 分隔。\n",
    "\n",
    "- 例如：`\"0.1.2.201\"` 和` \"192.168.1.1\"` 是 **有效** IP 地址，但是 `\"0.011.255.245\"`、`\"192.168.1.312\"` 和 `\"192.168@1.1\"` 是 **无效** IP 地址。\n",
    "\n",
    "给定一个只包含数字的字符串 `s` ，用以表示一个 IP 地址，返回所有可能的**有效 IP 地址**，这些地址可以通过在 `s` 中插入 `'.'` 来形成。你 **不能** 重新排序或删除 `s` 中的任何数字。你可以按 **任何** 顺序返回答案。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<string> restoreIpAddresses(string s) {\n",
    "        /*\n",
    "            1. 深度+回溯，使用逗号作为分割条件\n",
    "            2. 若是已选择第三个逗号，则需要检查第四段是否合格\n",
    "            3. 剪枝：逗号个数小于4\n",
    "        */\n",
    "        vector<string> out;\n",
    "        dfs(s,0,-1,out);\n",
    "        return out;\n",
    "    }\n",
    "\n",
    "    void dfs(string &s, int dot_num, int dot_index, vector<string> &out){\n",
    "        // dot_num传入当前需要寻找的逗号是第几个，dot_index表示最后一个点的位置\n",
    "        // 终止条件，确定第三个后需要检查是否符合后加入结果\n",
    "        if(dot_num==3){\n",
    "            // cout<<s<<endl;\n",
    "            if(isValid(s,dot_index+1,s.length()-1)){\n",
    "                out.push_back(s);\n",
    "            }\n",
    "            return;\n",
    "        }\n",
    "        int start=dot_index+1,i{0};\n",
    "        // 循环检查是否符合要求，符合要求则进行回溯\n",
    "        while(i<3){\n",
    "            if(isValid(s,start,start+i)){\n",
    "                s.insert(s.begin()+start+i+1,'.');  // 符合则插入句号，并回溯\n",
    "                dfs(s,dot_num+1,start+i+1,out);\n",
    "                s.erase(s.begin()+start+i+1);  // 回溯之后删除操作\n",
    "            }\n",
    "            ++i;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    bool isValid(string &s, int start, int end){\n",
    "        // cout<<start<<\" \"<<end<<endl;\n",
    "        if(start>end||end>=s.length()||start>=s.length()) return false;\n",
    "        // 检查区间内字符串是否为正确的IP地址\n",
    "        if(end-start+1>3) return false;\n",
    "        else if(s[start]=='0'&&end-start>0) return false; // 避免前导零\n",
    "        else{ // 判断是否为数字，且数字在0-255之间\n",
    "            int num{0};\n",
    "            while(start<=end){\n",
    "                if(s[start]-'0'<10){\n",
    "                    num=num*10+s[start]-'0';\n",
    "                }\n",
    "                else{\n",
    "                    return false;\n",
    "                }\n",
    "                ++start;\n",
    "            }\n",
    "            if(num<=255&&num>=0) return true;\n",
    "        }\n",
    "        return false;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prospective-suspect",
   "metadata": {},
   "source": [
    "# CodeTop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "consecutive-attack",
   "metadata": {},
   "source": [
    "## ！[179. 最大数](https://leetcode.cn/problems/largest-number/)\n",
    "\n",
    "给定一组非负整数 `nums`，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。\n",
    "\n",
    "**注意：**输出结果可能非常大，所以你需要返回一个字符串而不是整数。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    string largestNumber(vector<int>& nums) {\n",
    "        /*  [95,9,6]\n",
    "            1. 按数的每位的数字排序\n",
    "            2. 通过字符串排序选择最大的数：选择95，比较第一位，有相同的则比较第二位\n",
    "            3. 依次比较\n",
    "        */\n",
    "        vector<string> vs;\n",
    "        for(auto el:nums){\n",
    "            vs.push_back(to_string(el));\n",
    "        }\n",
    "        sort(vs.begin(),vs.end(),[](string &a, string &b){\n",
    "            return a+b>b+a?true:false;\n",
    "        });\n",
    "        // 拼接\n",
    "        if(vs[0]==\"0\") return \"0\"; // 防止有多个0存在时拼接\n",
    "        string s=\"\";\n",
    "        for(auto el:vs){\n",
    "            s+=el;\n",
    "        }\n",
    "        return s;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hungarian-broadway",
   "metadata": {},
   "source": [
    "## ！[468. 验证IP地址](https://leetcode.cn/problems/validate-ip-address/)\n",
    "**核心**：1. try..except... 2. 使用ord转为ascii数比较\n",
    "\n",
    "给定一个字符串 `queryIP`。如果是有效的 IPv4 地址，返回 `\"IPv4\"` ；如果是有效的 IPv6 地址，返回 `\"IPv6\"` ；如果不是上述类型的 IP 地址，返回 `\"Neither\"` 。\n",
    "\n",
    "```py\n",
    "v4=\"IPv4\"\n",
    "v6=\"IPv6\"\n",
    "neither=\"Neither\"\n",
    "class Solution:\n",
    "    def validIPAddress(self, queryIP: str) -> str:\n",
    "        #    1. 按照冒号分割\n",
    "        #    2. 检查位数分别匹配v4和v6\n",
    "        #    3. v4中第一个数不能是0，且整体在0-255之间\n",
    "        #    4. v6包含数字和特定字母，且有四位\n",
    "        ls=queryIP.split(\".\")\n",
    "        if len(ls)==4:\n",
    "            return self.checkV4(ls)\n",
    "        else:\n",
    "            ls=queryIP.split(\":\")\n",
    "            if(len(ls)==8):\n",
    "                return self.checkV6(ls)\n",
    "        return neither\n",
    "\n",
    "    def checkV4(self, ls):\n",
    "        for el in ls:\n",
    "            if len(el)>1 and el[0]==\"0\":\n",
    "                return neither\n",
    "            try:\n",
    "                tp=int(el)\n",
    "            except:\n",
    "                return neither\n",
    "            if 0<=tp<=255:\n",
    "                continue\n",
    "            else:\n",
    "                return neither\n",
    "        return v4\n",
    "\n",
    "    def checkV6(self, ls):\n",
    "        for el in ls:\n",
    "            n=len(el)\n",
    "            if 1<=n<=4:\n",
    "                for num in el:\n",
    "                    if 0<=ord(num)-ord('0')<10 or 0<=ord(num)-ord('a')<6 or 0<=ord(num)-ord('A')<6:\n",
    "                        continue\n",
    "                    else:\n",
    "                        return neither\n",
    "            else:\n",
    "                return neither\n",
    "        return v6\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "boolean-borough",
   "metadata": {},
   "source": [
    "## ！152. 乘积最大子数组\n",
    "给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。\n",
    "\n",
    "测试用例的答案是一个 32-位 整数。\n",
    "\n",
    "子数组 是数组的连续子序列。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int maxProduct(vector<int>& nums) {\n",
    "        /*\n",
    "        直接连乘，维护最小和最大值，若遇到0则置0\n",
    "        */\n",
    "        int n=nums.size(),dp_min{1},dp_max{1},out{-INT_MAX},tp1,tp2;\n",
    "        for(int i{0};i<n;++i){\n",
    "            tp1=max(max(nums[i],dp_max*nums[i]),dp_min*nums[i]);\n",
    "            tp2=min(min(nums[i],dp_max*nums[i]),dp_min*nums[i]);\n",
    "            dp_max=tp1;\n",
    "            dp_min=tp2;\n",
    "            out=max(dp_max,out);\n",
    "        }\n",
    "        return out;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "robust-benchmark",
   "metadata": {},
   "source": [
    "## ！162. 寻找峰值\n",
    "峰值元素是指其值严格大于左右相邻值的元素。\n",
    "\n",
    "给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。\n",
    "\n",
    "你可以假设 nums[-1] = nums[n] = -∞ 。\n",
    "\n",
    "你必须实现时间复杂度为 O(log n) 的算法来解决此问题。\n",
    "\n",
    "> 这道题，最最最重要的是条件，条件，条件，两边都是负无穷，数组当中可能有很多波峰，也可能只有一个，如果尝试画图，就跟股票信息一样，没有规律，如果根据中点値判断我们的二分方向该往何处取， 这道题还有只是返回一个波峰。你这样想，中点所在地方，可能是某座山的山峰，山的下坡处，山的上坡处，如果是山峰，最后会二分终止也会找到，关键是我们的二分方向，并不知道山峰在我们左边还是右边，送你两个字你就明白了，爬山（没错，就是带你去爬山），如果你往下坡方向走，也许可能遇到新的山峰，但是也许是一个一直下降的坡，最后到边界。但是如果你往上坡方向走，就算最后一直上的边界，由于最边界是负无穷，所以就一定能找到山峰，总的一句话，往递增的方向上，二分，一定能找到，往递减的方向只是可能找到，也许没有。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int findPeakElement(vector<int>& nums) {\n",
    "        int n=nums.size(),left{0},right{n-1};\n",
    "        // 二分，只选择向上的方向 [1,2,3,1]\n",
    "        while(left!=right){\n",
    "            // cout<<left<<' '<<right<<endl;\n",
    "            int mid=(left+right)/2;\n",
    "            // 查找左右关系\n",
    "            if(mid+1<n&&nums[mid]>nums[mid+1]){\n",
    "                if(mid==0||nums[mid]>nums[mid-1]) return mid;\n",
    "                right=mid-1;\n",
    "                continue;\n",
    "            }\n",
    "            else left=mid+1;\n",
    "        }\n",
    "        return left;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "athletic-context",
   "metadata": {},
   "source": [
    "## (RE)[39. 组合总和](https://leetcode.cn/problems/combination-sum/)\n",
    "\n",
    "给你一个 **无重复元素** 的整数数组 `candidates` 和一个目标整数 `target` ，找出 `candidates` 中可以使数字和为目标数 `target` 的 所有 **不同组合** ，并以列表形式返回。你可以按 **任意顺序** 返回这些组合。\n",
    "\n",
    "`candidates` 中的 **同一个** 数字可以 **无限制重复被选取** 。如果至少一个数字的被选数量不同，则两种组合是不同的。 \n",
    "\n",
    "对于给定的输入，保证和为 `target` 的不同组合数少于 `150` 个。\n",
    "\n",
    "法1：**回溯法**\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    void dfs(vector<int>& candidates, int target, vector<vector<int>>& ans, vector<int>& combine, int idx) {\n",
    "        // 两个结束条件：候选数组已用尽或者目标已达到\n",
    "        if (idx == candidates.size()) {\n",
    "            return;\n",
    "        }\n",
    "        if (target == 0) {\n",
    "            ans.emplace_back(combine);\n",
    "            return;\n",
    "        }\n",
    "        // 直接跳过\n",
    "        dfs(candidates, target, ans, combine, idx + 1);\n",
    "        // 选择当前数\n",
    "        if (target - candidates[idx] >= 0) {\n",
    "            combine.emplace_back(candidates[idx]);\n",
    "            dfs(candidates, target - candidates[idx], ans, combine, idx);\n",
    "            combine.pop_back();\n",
    "        }\n",
    "    }\n",
    "\n",
    "    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {\n",
    "        vector<vector<int>> ans;\n",
    "        vector<int> combine;\n",
    "        dfs(candidates, target, ans, combine, 0);\n",
    "        return ans;\n",
    "    }\n",
    "};\n",
    "```\n",
    "\n",
    "法2：NP问题，动态规划\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prompt-manitoba",
   "metadata": {},
   "source": [
    "## ！[128. 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence/)\n",
    "\n",
    "给定一个未排序的整数数组 `nums` ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。\n",
    "\n",
    "请你设计并实现时间复杂度为 `O(n)` 的算法解决此问题。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    int longestConsecutive(vector<int>& nums) {\n",
    "        // 以哈希表存储，重新遍历数组\n",
    "        unordered_set<int> s;\n",
    "        for(const auto& el:nums){\n",
    "            s.emplace(el);\n",
    "        }\n",
    "        int longest_streak{0};\n",
    "        for(const auto& el:nums){\n",
    "            int current_streak{1};\n",
    "            // 若有比其小的连续，则不需要遍历了，因为之后会遍历小的数\n",
    "            if(s.count(el-1)) continue;\n",
    "            int tp{el};\n",
    "            while(s.count(++tp)){\n",
    "                ++current_streak;\n",
    "            }\n",
    "            longest_streak=max(longest_streak,current_streak);\n",
    "        }\n",
    "        return longest_streak;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cardiac-invasion",
   "metadata": {},
   "source": [
    "## (RE)[394. 字符串解码](https://leetcode.cn/problems/decode-string/)\n",
    "\n",
    "给定一个经过编码的字符串，返回它解码后的字符串。\n",
    "\n",
    "编码规则为: `k[encoded_string]`，表示其中方括号内部的 `encoded_string` 正好重复 `k` 次。注意 `k` 保证为正整数。\n",
    "\n",
    "你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。\n",
    "\n",
    "此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 `k` ，例如不会出现像 `3a` 或 `2[4]` 的输入。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coupled-filling",
   "metadata": {},
   "source": [
    "## ！[240. 搜索二维矩阵 II](https://leetcode.cn/problems/search-a-2d-matrix-ii/)\n",
    "\n",
    "编写一个高效的算法来搜索 `*m* x *n*` 矩阵 `matrix` 中的一个目标值 `target` 。该矩阵具有以下特性：\n",
    "\n",
    "- 每行的元素从左到右升序排列。\n",
    "- 每列的元素从上到下升序排列。\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    bool searchMatrix(vector<vector<int>>& matrix, int target) {\n",
    "        /*\n",
    "            Z字查找，从右边开始查找的好处是比target大的数可以全部排除，而从左边开始只能排除正方形\n",
    "        */\n",
    "        int m = matrix.size(), n = matrix[0].size();\n",
    "        int x = 0, y = n - 1;\n",
    "        while (x < m && y >= 0) {\n",
    "            if (matrix[x][y] == target) {\n",
    "                return true;\n",
    "            }\n",
    "            if (matrix[x][y] > target) {\n",
    "                --y;\n",
    "            }\n",
    "            else {\n",
    "                ++x;\n",
    "            }\n",
    "        }\n",
    "        return false;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "foreign-dubai",
   "metadata": {},
   "source": [
    "## ！[662. 二叉树最大宽度](https://leetcode.cn/problems/maximum-width-of-binary-tree/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reflected-singing",
   "metadata": {},
   "source": [
    "## ！227. 基本计算器 II"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fifteen-catalog",
   "metadata": {},
   "source": [
    "## ！[93. 复原 IP 地址](https://leetcode.cn/problems/restore-ip-addresses/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "packed-invasion",
   "metadata": {},
   "source": [
    "## ！[151. 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string/)\n",
    "\n",
    "给你一个字符串 `s` ，请你反转字符串中 **单词** 的顺序。\n",
    "\n",
    "**单词** 是由非空格字符组成的字符串。`s` 中使用至少一个空格将字符串中的 **单词** 分隔开。\n",
    "\n",
    "返回 **单词** 顺序颠倒且 **单词** 之间用单个空格连接的结果字符串。\n",
    "\n",
    "**注意：**输入字符串 `s`中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    string reverseWords(string s) {\n",
    "        /*\n",
    "            1. 反转字符串O(1)空间复杂度\n",
    "            2. 反转单词\n",
    "        */\n",
    "        reverse(s.begin(),s.end());\n",
    "        int i{0},n=s.length()-1;\n",
    "        bool space=false;\n",
    "        while(i<=n){\n",
    "            if(s[i]!=' '){ // 若为单词则循环找到下一个不为空格的地方\n",
    "                int start{i},end{i};\n",
    "                // 找到end值\n",
    "                while(end<=n){\n",
    "                    if(end==n||s[end+1]==' ') break;\n",
    "                    ++end;\n",
    "                }\n",
    "                i=end; // 下一次循环的index\n",
    "                // 反转单词\n",
    "                reverse(s.begin() + start, s.begin() + end+1);  // reverse不包含最后一位\n",
    "                space=true;\n",
    "                \n",
    "            }\n",
    "            else{ // 若为空格且不留空格，则删除\n",
    "                if(space){\n",
    "                    space=false;\n",
    "                }\n",
    "                else{\n",
    "                    s.erase(s.begin()+i);\n",
    "                    --n;  // 此处必须要删除！！！！找了很久！！！！\n",
    "                    continue;\n",
    "                }\n",
    "            }\n",
    "            ++i;\n",
    "        }\n",
    "        // 去除尾端的空白\n",
    "        if(s[s.length()-1]==' ') s.erase(s.end()-1);\n",
    "        return s;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exposed-small",
   "metadata": {},
   "source": [
    "## ！！！[15. 三数之和](https://leetcode.cn/problems/3sum/)\n",
    "**难点在于如何不重复：如果用哈希表或者set去重时间复杂度很高，若用排序的话需要如何不重复（对同一元素只搜索一次）**\n",
    "\n",
    "给你一个整数数组 `nums` ，判断是否存在三元组 `[nums[i], nums[j], nums[k]]` 满足 `i != j`、`i != k` 且 `j != k` ，同时还满足 `nums[i] + nums[j] + nums[k] == 0` 。请\n",
    "\n",
    "你返回所有和为 `0` 且不重复的三元组。\n",
    "\n",
    "**注意：**答案中不可以包含重复的三元组。\n",
    "\n",
    "```CPP\n",
    "class Solution {\n",
    "public:\n",
    "    vector<vector<int>> threeSum(vector<int>& nums) {\n",
    "        /*\n",
    "            1. 排序+双指针法\n",
    "            2. 对于-1,-1,-1,2,2的数组，只对重复元素遍历一次（但结果数组中可能有重复元素[-1,-1,2]）\n",
    "        */\n",
    "        vector<vector<int>> out;\n",
    "        sort(nums.begin(),nums.end());\n",
    "        for(int i{0};i<nums.size();++i){\n",
    "            if(nums[i]>0) break; // 若当前数大于0则之后的数也大于0，不需要找了\n",
    "            else if(i>0&&nums[i]==nums[i-1]) continue; // ！！！忽略重复[-1,-1,-1,2]\n",
    "            else{ // 用双指针法找\n",
    "                int left{i+1},right=nums.size()-1,target=-nums[i];\n",
    "                while(left<right){\n",
    "                    int sum=nums[left]+nums[right];\n",
    "                    if(sum==target){\n",
    "                        if(left!=i+1&&nums[left]==nums[left-1]){\n",
    "                            // ！！！针对[-2,0,0,2,2]\n",
    "                            --right;++left;\n",
    "                            continue;\n",
    "                        }\n",
    "                        out.push_back(vector<int>{nums[i],nums[left],nums[right]});\n",
    "                        --right;++left;\n",
    "                    }\n",
    "                    else if(sum>target) --right;\n",
    "                    else ++left;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return out;\n",
    "    }\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "legitimate-riding",
   "metadata": {},
   "source": [
    "## ！！！[143. 重排链表](https://leetcode.cn/problems/reorder-list/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}