标签：return nums int res next 经典 leetcode left

#include <iostream>
#include <vector>
#include <stack>
#include <string>
#include <algorithm>
#include <climits> 
#include <unordered_map>
#include <unordered_set>
#include <queue>
using namespace std;

template<typename T>
void print(const vector<T>& nums)
{
    for(auto & num : nums)
    {
        cout << num << " ";
    }
    cout << endl;

}

struct TreeNode
{
    int val = 0;
    TreeNode* left = nullptr;
    TreeNode* right = nullptr;
    TreeNode* next = nullptr;
    TreeNode(int val_):val(val_),left(nullptr),right(nullptr),next(nullptr) 
    {
        ;
    }
};


struct LinkNode
{
    int val = 0;
    LinkNode* next = nullptr; 
    LinkNode* random = nullptr;
    LinkNode(int val_)
    {
        val = val_;
    }
};

void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
    int i = m - 1;
    int j = n - 1;
    int k = m + n - 1;
    while(i >= 0 && j >= 0)
    {
        if(nums1[i] > nums2[j])
        {
            nums1[k--] = nums1[i--];
        }
        else
        {
            nums1[k--] = nums2[j--];
        }

    }
    while(i >= 0)
    {
        nums1[k--] = nums1[i--];
    }
    while(j >= 0)
    {
        nums1[k--] = nums2[j--];
    } 
}

bool isValidBST(TreeNode* root)
{
      //递归
//      if(root == nullptr)return true;
//      bool left = isValidBST(root->left);
//      bool right = isValidBST(root->right);
//      if(!left)return false;
//      if(root->val_ <= preV)return false;
//      return isValidBST(root->right);
      //递归

      //非递归
      TreeNode* pre = nullptr;
      stack<TreeNode*>st;
      while(root!= nullptr||!st.empty())
      {
          while(root != nullptr)
          {
              st.push(root);
              root = root->left;
          }
          root = st.top();
          st.pop();
          if(pre!= nullptr && root->val <=pre->val)return false;
          pre = root;
          root=root->right;
      }
      return true;

//    return isValidBST(root, -1, -1);
}


LinkNode* generateLinkNode(vector<int>& nums)
{
    int n = nums.size(); 
    LinkNode dummy(0);
    LinkNode* head = &dummy;
    for(int i = 0; i < n; ++i)
    {
       
       LinkNode* cur = new LinkNode(nums[i]);
       head->next = cur;    
       head = head->next;
    }
    return dummy.next;
}

int partition(vector<int>& nums,int left,int right)
{
    int piv = nums[right];
    int start = left,end = right -1;
    while(start <= end)
    {
        if(nums[start] < piv)++start;
        else if(nums[end]>piv)--end;
        else
        {
            swap(nums[start++],nums[end--]);
        }    
    }
    swap(nums[start],nums[right]);
    return start;
}

void helper(vector<int>& nums,int left,int right)
{
    if(left > right)return;
    int pi = partition(nums,left,right);
    helper(nums,left,pi-1);
    helper(nums,pi+1,right);
    return;
}

vector<pair<int,int>>dirs{{0,-1},{0,1},{1,0},{-1,0}};

class DSU{
    vector<int>parent_;
    public:
    DSU(int N)
    {
        parent_.resize(N);
        for(int i = 0; i < N; ++i)
        {
            parent_[i] = i;
        }
    }
    int find(int x)
    {
        if(parent_[x] != x)parent_[x] = find(parent_[x]);
        return parent_[x];
    }
    void Union(int x, int y)
    {
        parent_[find(x)] = find(y);
    }
};

void bfs(vector<vector<string>>& grid, int i ,int j)
{
    queue<pair<int,int>>q;
    q.push({i,j});
    while(!q.empty())
    {
        auto cur = q.front();
        q.pop();
        int x = cur.first,y = cur.second;
        if(x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == "0")continue;
        grid[x][y] = "0";
        for(auto dir:dirs)
        {
            q.push({x+dir.first,y+dir.second});
        }
    }
}

void dfs_stack(vector<vector<string>>&grid,int i,int j)
{
    stack<pair<int,int>>st;
    st.push({i,j});
    while(!st.empty())
    {
        auto cur = st.top();
        st.pop();
        int x = cur.first, y = cur.second;
        if(x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == "0")continue;
        grid[x][y] = "0";
        for(auto p:dirs)
        {
            st.push({x + p.first,y+p.second});
        }
    }
}
void dfs(vector<vector<string>>&grid,int i, int j)
{
    if(i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size() || grid[i][j] == "0")
        return ;
    grid[i][j] = "0";
    dfs(grid,i-1,j);
    dfs(grid,i+1,j);
    dfs(grid,i,j-1);
    dfs(grid,i,j+1);
    return;
}
int numIslands(vector<vector<string>>&grid)
{
    int m = grid.size(), n = grid[0].size(),res = 0;
    // DSU dsu(m*n);

    for(int i = 0; i < m ;++i)
    {
        for(int j = 0; j < n; ++j)
        {
            if(grid[i][j] == "1")
            {
                ++res;
                // dfs_stack(grid,i,j);
//                bfs(grid,i,j);
               dfs(grid,i,j);
//                DSU
//                for(const pair<int,int>p:dirs)
//                {
//                    int x = i + p.first, y = j + p.second;
//                    if(x >= 0 && y >= 0 && x < m && y < n && grid[x][y] == "1")
//                    {
//                        if(dsu.find(x*n+y)!=dsu.find(i*n+j)) --res;
//                        dsu.Union(x*n+y,i*n+j);
//                    }
//                }
            }
        }
    }
    return res;
}


vector<int>qs(const vector<int>& v)
{
    vector<int>nums = v;
    int n = nums.size();
    helper(nums,0,n-1);
    return nums;
   
}

void heapify(vector<int>& nums,int n,int i)
{
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    while(l < n && nums[largest] < nums[l])
    {
        largest = l;
    }
    while(r < n && nums[largest] < nums[r])
    {
        largest = r;
    }
    if(largest != i)
    {
        swap(nums[largest],nums[i]);
        heapify(nums,n,largest);

    }
}

vector<int>hpS(const vector<int>& boxes)
{
    vector<int>nums = boxes;
    int n = nums.size();
    for(int i = n / 2 - 1; i >= 0; --i)
    {
        heapify(nums,n,i);
    }
    for(int i = n-1; i>=0;--i)
    {
        swap(nums[0],nums[i]);
        heapify(nums,i,0);
    }
    return nums;
}

int reverse(int num)
{
    int ret = 0;
    while(num != 0)
    {
        int temp = ret * 10 + num % 10;
        if (temp / 10 != ret)
            return 0;
        ret = temp;
        num /= 10;
    }
    return ret;
}

int reverse1(int x)
{
    int ret = 0;
    while(x!=0)
    {
        int tmp = ret * 10 + x % 10;
        if(tmp / 10 != ret)
        {
            return 0;
        }
        ret = tmp;
        x /= 10;
    }
    return ret;
}

int trap(const vector<int>& height)
{
    int res = 0;
    int n = height.size();
    vector<int>left(n),right(n);
    left[0] = height[0];
    right[n-1] = height[n-1];
    for(int i = 1; i < n; ++i)
    {
        left[i] = max(height[i],left[i-1]);        
    }
    for(int i = n - 2; i >= 0; --i)
    {
        right[i] = max(height[i],right[i+1]);
    }
    for(int i = 0; i < n; ++i)
    {
        res += min(left[i],right[i]) - height[i];
    }
    return res;
}

int trapI(const vector<int>& nums)
{
    stack<int>st;
    int res = 0, n = nums.size();
    for(int i = 0; i < n ;++i)
    {
        while(!st.empty() && nums[i] > nums[st.top()])
        {
            int pre = st.top();
            st.pop();
            if(st.empty())break;
            int minHeight = min(nums[i],nums[st.top()]);
            res += (minHeight - nums[pre]) * ( i - st.top() - 1);
        }
        st.push(i);
    }
    return res;
}


int rain(const vector<int>& height)
{
    int n = height.size(),res = 0;
    vector<int>left(n),right(n);
    left[0] = height[0];
    right[n-1] = height[n-1];
    for(int i = 1; i < n; ++i)
    {
        left[i] = max(height[i],left[i-1]);
    }
    for(int i = n - 1; i >= 0; --i)
    {
        right[i] = max(height[i],right[i+1]);
    }
    for(int i = 0; i < n; ++i)
    {
        res += min(left[i],right[i]) - height[i];
    }
    return res;
}

int rainI(const vector<int>& nums)
{
    stack<int>st;
    int res = 0,n = nums.size();
    for(int i = 0; i < n; ++i)
    {
        while(!st.empty() && nums[i] > nums[st.top()])
        {
            int pre = st.top();
            st.pop();
            if(st.empty())break;
            int minHeight = min(nums[i],nums[st.top()]);
            res += (minHeight - nums[pre]) * (i - st.top() - 1);
            // res += (minHeight - nums[pre]) * ( i - st.top() - 1); 
        }
        st.push(i);
    }
    return res;
}

LinkNode* detectCycleNode(LinkNode* head)
{
    LinkNode* slow = head, *fast = head;
    while(fast != nullptr && fast->next != nullptr)
    {
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow)
        {
            fast = head;
            while(fast != slow)
            {
                fast = fast->next;
                slow = slow->next;
            }
            return slow;
        }
    }
    return nullptr;
}

 void moveZeroes(vector<int>& nums) {
    int n = nums.size();
    if(1 == n)return;
    for(int zero=0,nonzero =1 ;nonzero < n && zero < n; ++nonzero)
    {
        if(nums[nonzero]!=0 && nums[zero]==0)swap(nums[zero],nums[nonzero]);
        while(nums[zero]!=0 && zero < nonzero)++zero;
    }            
}    

void levelOrder(TreeNode* root,vector<vector<int>>& res)
{
    queue<TreeNode*>q;
    if(root != nullptr)q.push(root);
    while(!q.empty())
    {
        int size = q.size();
        vector<int>tmp;
        for(int i = 0; i < size; ++i)
        {
            auto cur = q.front();
            q.pop();
            tmp.push_back(cur->val);
            if(cur->left)q.push(cur->left);
            if(cur->right)q.push(cur->right);
        }
        res.push_back(tmp);
    }
    return ;
}


int maxProfit_II(const vector<int>& prices)
{
    if(prices.empty())return 0;
    int n = prices.size();
    vector<vector<int>>dp(n,vector<int>(2));
    dp[0][0] = 0;
    dp[0][1] = -prices[0];
    for(int i = 1; i < n; ++i)
    {
        dp[i][1] = max(dp[i-1][1],dp[i-1][0] - prices[i]);
        dp[i][0] = max(dp[i-1][0],dp[i-1][1] + prices[i]);
    }
    return dp[n-1][0];

}

int maxProfit_II_greedy(const vector<int>& prices)
{
    if(prices.empty())return 0;
    int n = prices.size();
    int profit = 0;
    for(int i = 1; i < n; ++i)
    {
        if(prices[i-1] < prices[i])
        {
            profit += (prices[i] - prices[i-1]);
        }
    }
    return profit;
}

bool isValid(const string s)
{
    stack<char>st;
    for(char c : s)
    {
        if(c == '(')
        {
            st.push(')');
        }
        else if(c == '{')
        {
            st.push('}');
        }
        else if(c == '[')
        {
            st.push(']');
        }
        else if(st.empty() || st.top() != c)
        {
            return false;
        }
        else
        {
            st.pop();
        }
        
    }
    return st.empty();
}

bool isValid1(string s)
{
    stack<char>st;
    for(int i = 0; i < s.size(); ++i)
    {
        char c = s[i];
        if(c == '[')st.push(']') ;       
        else if(c == '{')st.push('}');
        else if(c == '(')st.push(')');
        else if(st.empty() || st.top() != c)return false;
        else st.pop();
    }
    return st.empty();
}

//  bool isMatch(string s, string p) {
//         bool dp[s.length()+1][p.length()+1] = {};
//         dp[s.length()][p.length()] = 1;
//         for (int i = s.length(); i >= 0; i--){
//             for (int j = p.length() - 1; j >= 0; j--){
//                 bool first_match = i < s.length() && (p[j] == s[i] || p[j] == '.');
//                 if (j + 1 < p.length() && p[j+1] == '*'){
//                     dp[i][j] = dp[i][j+2] || first_match && dp[i+1][j];
//                 } 
//                 else {
//                     dp[i][j] = first_match && dp[i+1][j+1];
//                 }
//             }
//         }
//         return dp[0][0];
//     }

// bool isMatchI(string s,string p)
// {
//     int m = s.size(), n = p.size();
//     bool dp[m+1][n+1];
//     dp[m][n] = 1;
//     for(int i = m; i >=0; --i)
//     {
//         for(int j = n - 1;j >= 0;--j)
//         {
//             bool first_match = i < m && (s[i] == p[j] || p[j] == '.');
//             if(j + 1 < p.size() && p[j+1] == '*')
//             {
//                 dp[i][j] = dp[i][j+2] || first_match && dp[i+1][j];
//             }
//             else
//             {
//                 dp[i][j] = first_match && dp[i+1][j+1];
//             }
//         }
//     }
//     return dp[0][0];

// }

bool isMatch(string s, string p)
{
    int m = s.size(), n = p.size();
    bool dp[m+1][n+1];
    dp[m][n] = 1;
    for(int i = n; i >= 0; --i)
    {
        for(int j = n - 1; j >= 0; --j)
        {
            bool first_match = i < m && (s[i] == p[j] || p[j] == '.');
            if(j+1 < n && p[j+1] == '*')
            {
                dp[i][j] = dp[i][j+2] || first_match && dp[i+1][j];
            }
            else
            {
                dp[i][j] = first_match && dp[i+1][j+1];
            }
        }
    }
    return dp[0][0];
}

int maxVal = INT_MIN;

int helper(TreeNode* root)
{
    if(root == nullptr)return 0;
    int left = max(0, helper(root->left));
    int right = max(0,helper(root->right));
    maxVal = max(maxVal,left + right + root->val);
    return max(left,right) + root->val;
}

int maxSum(TreeNode* root)
{
    helper(root);
    return maxVal;
}

int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1)
            return n;
        
        int i = 0;
        for(int j = 1; j < n; ++j){
            if(nums[j] != nums[i]){
                i++;
                nums[i] = nums[j];
            }
        }
        for(;i + 1 < n; ++i)
        {
            nums[i+1] = 0;
        }
        return i+1;
}
int romanToInt(string s) 
{
    int ral = 0;
    unordered_map<char, int>bp = { { 'I',1 },{ 'V', 5 },{ 'X', 10 },{ 'L' , 50 },{ 'C' , 100 },{ 'D' , 500 },{ 'M' , 1000 } };
    int s_size = s.size();
    for (int i = 0; i < s_size; i++)
    {
        int res = bp[s[i]];
        if (i == s_size - 1 || bp[s[i + 1]] <= bp[s[i]]) ral += res;
        else ral -= res;
    }
    return ral;
}

void backtrackI(const vector<int>& candidates,int target,vector<int>&path,vector<vector<int>>&res,int sum, int index)
{
    if(sum > target)return;
    if(sum == target)
    {
        res.push_back(path);
        return;
    }
    for(int i = index ; i < candidates.size(); ++i)
    {
        sum += candidates[i];
        path.push_back(candidates[i]);
        backtrackI(candidates,target,path,res,sum,i);
        path.pop_back();
        sum -= candidates[i];
    }

}

int subarraySum(const vector<int>& nums,int target)
{
    unordered_map<int,int>map;
    int sum = 0, res = 0;
    map[0] = 1;
    for(int num:nums)
    {
        sum += num;
        if(map.count(sum - target))res+=map[sum - target];
        ++map[sum];
    }
    return res;
}


vector<vector<int>>combinationSum(const vector<int>& candidates, int target)
{
    vector<vector<int>>res;
    vector<int>path;
    backtrackI(candidates,target,path,res,0,0);
    return res;
}

bool hasCycleNode(LinkNode* head)
{
    LinkNode* slow = head, *fast = head;
    while(fast != nullptr && fast->next != nullptr)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast) return true;
    }
    return false;
}

bool cmp1(pair<int,int>p1,pair<int,int>p2)
{
    return p1.first < p2.first;
}

vector<pair<int,int>>merge(vector<pair<int,int>>& intervals)
{
    vector<pair<int,int>>res;
    int n = intervals.size();
    if(n == 0)return res;
    sort(intervals.begin(),intervals.end(),cmp1);   
    auto cur = intervals[0];
    for(auto next : intervals)
    {
        if(cur.second >= next.first)cur.second = max(cur.second,next.second);
        else
        {
            res.push_back(cur);
            cur = next;
        }
    }
    res.push_back(cur);
    return res;
}

int str2int(string str)
{
    if(str.empty())return 0;
    int len = str.size();
    int pos = str.find_first_not_of(" ");
    if(-1 != pos)str = str.substr(pos,len - pos + 1);
    bool flag = false;
    long long res = 0;
    if((str[0] <= '9' && str[0] >= 0) || str[0] == '+' || str[0] == '-')
    {
        int i = 0;
        if('+' == str[0])i = 1;
        else if('-' == str[0]){
            i = 1;
            flag = true;
        } 
        for(;i < str.size(); ++i)
        {
            if(str[i] <= '9' && str[i] >= '0')
            {
                res = res * 10 + (str[i]-'0');
                if(res > INT_MAX)
                {
                    if(flag)return INT_MIN;
                    else return INT_MAX;
                }
            }
            else break;
        }
    }
    else return 0;
    if(flag)
    {
        res = -res;
    }
    return res;
}

int preOrderIndex = 0;
TreeNode* help(vector<int>&pre,int start,int end,unordered_map<int,int>&map)
{
    if(start > end)return nullptr;
    TreeNode* root = new TreeNode(pre[preOrderIndex++]);
    int index = map[root->val];
    root->left = help(pre,start,index-1,map);
    root->right = help(pre,index+1,end,map);
    return root;
}

TreeNode* buildTreeFromPreIn(vector<int>&pre,vector<int>&in)
{
    int N = pre.size();
    unordered_map<int,int>map;
    for(int i = 0; i < N; ++i)
    {
        map[in[i]] = i;
    }
    return help(pre,0,N-1,map);
}

int removeDuplicatesI(vector<int>& nums)
{
    int n = nums.size();
    int i = 0;
    for(int j = 1; j < n; ++j)
    {
        if(nums[i]!=nums[j])
        {
            nums[i++] = nums[j];
        }
    }
    for(;i + 1 < n; ++i)
    {
        nums[i+1] = 0;
    }
    return i+1;
}

int singleNum0(const vector<int>& nums)
{
    int res = 0;
    for(auto & num :nums)
    {
        res ^= num;
    }
    return res;
}
// void dfs(int left, int right, string level,vector<string>&res)
// {
//     if(left > right)return;
//     if(left == 0 && right == 0)res.emplace_back(level);
//     if(left > 0)dfs(left - 1, right,level + "(",res);
//     if(right > 0)dfs(left,right - 1,level+")",res);
//     return ;

// }

// vector<string> generateParentheses(int n)
// {
//     vector<string>res;
//     dfs(n,n,"",res);
//     return res;
// }

void dfs(int left, int right, string tmp,vector<string>&res)
{
    if(left > right)return;
    if(0 == left && 0 == right)res.emplace_back(tmp);
    if(left > 0)dfs(left-1,right,tmp + "(",res);
    if(right > 0)dfs(left,right-1,tmp +")",res);
    return;
}
vector<string> gen(int n)
{
    vector<string>res;
    dfs(n,n,"",res);
    return res;
}

vector<int>singleNum(vector<int>& nums)
{
    int res = 0;
    for(int i = 0; i < nums.size(); ++i)
    {
        res ^= nums[i];
    }
    int tmp = 1;
    while((res & tmp) == 0)
    {
        tmp <<= 1;
    }        
    int ans2 = 0;
    for(int i = 0; i < nums.size(); ++i)
    {
        if((tmp&nums[i])!= 0)
        {
            ans2 ^= nums[i];
        }
    }        

        vector<int> rtn;
        rtn.push_back(ans2);
        rtn.push_back(ans2 ^ res);
        return rtn;


}

string convert(string s, int numRows) {
    if(numRows <= 1)return s;
    vector<string>zigzag(min(numRows,static_cast<int>(s.size())));
    int curRow = 0;
    bool goDown = false;        
    for(int i = 0; i < s.size(); ++i)
    {
        zigzag[curRow]+=s[i];
        if(0 == curRow || curRow == numRows - 1)goDown = !goDown;
        curRow+=goDown?1:-1;

    }        
    string res("");
    for(auto &str:zigzag)res+=str;
    return res;
}

void print(const vector<pair<int,int>>& vs)
{
    for(auto v:vs)
    {
        cout << v.first << " " << v.second << endl;
    }
}



vector<int>maxSlidingWindow(const vector<int>& nums,int k)
{
    int n = nums.size();
    deque<int>q;
    vector<int>res(n-k+1);
    for(int i = 0; i < n; ++i)
    {
        int start = i-k+1;
        while(!q.empty() && i - q.front() >= k)q.pop_front();
        while(!q.empty() && nums[q.front()] <= nums[i])q.pop_back();
        q.push_back(i);
        if(start >= 0)res[start] = nums[q.front()];
    }
    return res;
}

int singleNumberI(vector<int>& nums) 
{
    vector<int>bits(32,0);
    for(int i = 0; i < nums.size(); ++i)
    {
        for(int j = 0; j < 32; ++j)
        {
            if(nums[i] &(1 << j))
            ++bits[j];
        }
    }        
    int res = 0;
    for(int i = 0; i < bits.size(); ++i)
    {
        if(bits[i]%3 == 1)
        {
            res += (1 << i);
        }
    }        
    return res;
}

bool canJump(const vector<int>& nums)
{
    if(nums.size() == 1)return true;
    int cover = 0;
    for(int i = 0; i < nums.size(); ++i)
    {
        cover = max(i + nums[i],cover);
        if(cover >= nums.size() - 1)return true;
    }
    return false;
}

int uniquePathsI(int m, int n)
{
    vector<int>dp(n,1);
    for(int i = 1; i < m; ++i)
    {
        for(int j = 1; j < n; ++j)
        {
            dp[j] = dp[j] + dp[j-1];
        }
    }
    return dp[n-1];
}

int uniquePaths(int m, int n)
{
    vector<vector<int>>dp(m,vector<int>(n));
    for(int i = 0;i < m; ++i)
    {
        dp[i][0] = 1;
    }
    for(int i = 0; i < n; ++i)
    {
        dp[0][i] = 1;
    }
    for(int i = 1; i < m; ++i)
    {
        for(int j = 1; j < n ; ++j)
        {
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
        }
    }
    return dp[m-1][n-1];
}

int searchInsert(vector<int>& nums, int target){
    int left=0;
    int numsSize = nums.size();
    int right=numsSize-1;
    if(nums[right] < target)
        return numsSize;
    if(nums[right] == target)
        return right;
    if(nums[left] >= target)
        return left;
    while(nums[left]<target && nums[right]>target)
    {
        int mid = left + (right - left) / 2;
        if(mid==left)
        {
            return right;
        }
        if(nums[mid]>target)
        {
            right=mid;
        }
        if(nums[mid]<target)
        {
            left=mid;
        }
        if(nums[mid]==target)
        {
            return mid;
        }
    }
    if(nums[left]<target)
    {
        return right;
    }
    if(nums[right]>target)
    {
        return left;
    }
 
    //最后不要忘记返回噢
    return 0;
}

void print(LinkNode* node)
{    
    while(node != nullptr)
    {
        cout << node->val <<" ";
        node = node->next;
    }
    cout << endl;
}
LinkNode* reverseII(LinkNode* head)
{
    LinkNode* pre = nullptr;
    while(head != nullptr)
    {
        LinkNode* next = head->next;
        head->next = pre;
        pre = head;
        head = next;
    }
    return pre;
}

LinkNode* swapPairs(LinkNode* head) {
    if (nullptr == head || nullptr == head->next)return head;                
    LinkNode* dummy = new LinkNode(0);
    dummy->next = head;
    LinkNode* temp = dummy;
    while(nullptr != temp->next && nullptr != temp->next->next)
    {
        LinkNode* p = temp->next;
        LinkNode* q = temp->next->next;            
        temp->next = q;
        p->next = q->next;
        q->next = p;
        temp = p;
    }
    return dummy->next;
}

LinkNode* reverseIII(LinkNode* head)
{
    LinkNode* pre = nullptr;
    while(head != nullptr)
    {
        LinkNode* next = head->next;
        head->next = pre;
        pre = head;
        head = next;
    }
    return pre;
}

LinkNode* reverse(LinkNode* head,LinkNode* newHead)
{
    if(nullptr == head)return newHead;
    LinkNode* next = head->next;
    head->next = newHead;
    return reverse(next,head);
}

LinkNode* mergeTwoLists(LinkNode* l1, LinkNode* l2)
{
    LinkNode* dummy = new LinkNode(0);
    LinkNode* cur = dummy;
    while(nullptr != l1 && nullptr != l2)
    {
        if(l1->val < l2->val)
        {
            cur->next = new LinkNode(l1->val);
            l1 = l1->next;
        }
        else
        {
            cur->next = new LinkNode(l2->val);
            l2 = l2->next;
        }
        cur = cur->next;
    }
    cur->next = l1 == nullptr ? l2:l1;
    return dummy->next;
}

int climbStairs(int n)
{
    if(n <= 2)return n;
    vector<int>dp(n+1);
    dp[1] = 1;
    dp[2] = 2;
    for(int i = 3; i <= n; ++i)
    {
        dp[i] = dp[i-1] + dp[i-2];
    }
    return dp[n];
}

void reverse(vector<int>& nums, int start, int end) {
    while(start < end)
    {
        int tmp = nums[start];
        nums[start] = nums[end];
        nums[end] = tmp;
        ++start;
        --end;
    }
}

void inorder(TreeNode* root)
{
    if(root == nullptr)return;
    inorder(root->left);
    cout << root->val << endl;
    inorder(root->right);
}
void inorder(TreeNode* root, vector<int>&res)
{
    stack<TreeNode*>st;
    while(root != nullptr || !st.empty())
    {
        while(root != nullptr)
        {
            st.push(root);
            root = root->left;
        }
        root = st.top();
        st.pop();
        res.push_back(root->val);
        root = root->right;
    }
}


void rotate(vector<int>& nums,int k)
{
    k %= nums.size();
    reverse(nums,0,nums.size() - 1); 
    reverse(nums,0,k-1);
    reverse(nums,k,nums.size() - 1);
}

string letterMap[10]={
    "",
    "",
    "abc",
    "def",
    "ghi",
    "jkl",
    "mno",
    "pqrs",
    "tuv",
    "wxyz"};

void backtrack(const string & digits, string& s, vector<string>& res,int index)
{
    if(s.size() == digits.size())
    {
        res.push_back(s);
        return;
    }
    int digit = digits[index] - '0';
    string letter = letterMap[digit];
    for(int i = 0; i < letter.size(); ++i)
    {
        s.push_back(letter[i]);
        backtrack(digits,s,res,index + 1);
        s.pop_back();
    }
}

vector<string> letterCombinations(const string& digits)
{
    vector<string>res;
    if(digits.size() == 0)return res;
    string s;
    backtrack(digits,s,res,0);
    return res;
}

int climbStairs_m(int n,int m)
{
    vector<int>dp(n+1,0);
    dp[0] = 1;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1;j <=  m; ++j)
        {
            if(i - j >= 0)dp[i]+=dp[i-j];
        }
    }
    return dp[n];    
}

int lengthOfList(const vector<int>& nums)
{
    int n = nums.size();
    if(n <= 1)return n;
    vector<int>dp(n,1);    
    for(int i = 1; i < n ; ++i)
    {
        for(int j = 0; j < i; ++j)
        {
            if(nums[i] > nums[j])dp[i] = max(dp[i],1 + dp[j]);
        }
    }    
    return *max_element(dp.begin(),dp.end());
}


int maxProfit(const vector<int>& prices)
{
    int n = prices.size();
    if(0 == n)return 0;
    vector<vector<int>>dp(n,vector<int>(2,0));
    dp[0][0] = 0;
    dp[0][1] = -prices[0];    
    for(int i = 1; i < prices.size(); ++i)
    {
        dp[i][0] = max(dp[i-1][1] + prices[i],dp[i-1][0]);
        dp[i][1] = max(dp[i-1][1],-prices[i]);
    }    
    return dp[n-1][0];
}

int getleftposition(vector<int>& nums,int target)
{
    int left = 0, right = nums.size() - 1;
    while(left <= right)
    {
        int mid = left + ((right - left )>> 1);
        if(target > nums[mid])left = mid + 1;
        else if(target < nums[mid])right = mid - 1;
        else right = mid - 1;     
    }
    if(left == nums.size() || nums[left] != target)
    return -1;
    return left;
}

int getrightposition(vector<int>&nums,int target)
{
    int left = 0,right = nums.size() - 1;
    while(left <= right)
    {
        int mid = left + ((right - left) >> 1);
        if(target < nums[mid])right = mid - 1;
        else if(target == nums[mid])left = mid + 1;
        else left = mid + 1;
    }
    if(right == -1 || nums[right]!=target)return -1;
    return right;
}

vector<int> searchRange(vector<int>& nums, int target) {
    vector<int>ans(2,-1);
    ans[0] = getleftposition(nums,target);
    ans[1] = getrightposition(nums,target);        
    return ans;
}

int coinChange(const vector<int>&nums,int amount)
{
    vector<int>dp(amount + 1,INT_MAX);
    dp[0] = 0;
    for(int i = 0; i < nums.size(); ++i)
    {
        for(int j = nums[i];j <= amount; ++j)
        {
            if(dp[j - nums[i]]!= INT_MAX)
            {
                dp[j] = min(dp[j],dp[j-nums[i]] + 1);
            }
        }
    }
    if(dp[amount] == INT_MAX)return -1;
    return dp[amount];
}

void nextPermutation(vector<int>& nums)
{
    int i = nums.size() - 2;
    while(i >= 0 && nums[i] >= nums[i+1])
    {
        --i;
    }
    if(i >= 0)
    {
        int j = nums.size() - 1;
        while(i < j && nums[i] >= nums[j])
        --j;
        int tmp = nums[j];
        nums[j] = nums[i];
        nums[i] = tmp;
    }
    int end = nums.size() - 1;
    int start = i + 1;
    while(start < end)
    {
        int tmp = nums[end];
        nums[end] = nums[start];
        nums[start] = tmp;
        --end;
        ++start;
    }
    return;
}

// int minEditDistance(string s, string t)
// {
//     int m = s.size(), n = t.size();
//     vector<vector<int>>dp(m+1,vector<int>(n+1,0));
//     for(int i = 0; i < m; ++i)dp[i][0] = i;
//     for(int j = 0; j < n; ++j)dp[0][j] = j;
//     for(int i = 1; i <= m; ++i)
//     {
//         for(int j = 1; j <= n; ++j)
//         {
//             if(s[i-1] == t[j-1])
//             {
//                 dp[i][j] = dp[i-1][j-1];
//             }
//             else{
//                 dp[i][j] = min({dp[i-1][j-1],dp[i][j-1],dp[i-1][j]}) + 1;
//             }
//         }
//     }    
//     return dp[m][n];
// }

int jump(const vector<int>& nums)
{
    int step = 0,maxReach = 0,end = 0;
    for(int i = 0; i < nums.size(); ++i)
    {
        maxReach = max(maxReach,nums[i] + i);
        if(i == end)
        {
            ++step;
            end = maxReach;
        }
    }
    return step;
}

bool wordBreak(string s, const vector<string>& wordDict)
{
    vector<bool>dp(s.size() + 1, false);
    unordered_set<string>set(wordDict.begin(),wordDict.end());
    dp[0] = true;
    for(int i = 1; i <= s.size(); ++i)
    {
        for(int j = 0; j < i; ++j)
        {
            string word = s.substr(j,i - j);
            if(set.find(word)!= set.end()&&dp[j])
            {
                dp[i] = true;
            }
        }
    }
    return dp[s.size()];
}

int minEditDistance(string s1,string s2)
{
    int m = s1.size(),n = s2.size();
    vector<vector<int>>dp(m+1,vector<int>(n+1,0));
    for(int i = 0; i < m ;++i)
    {
        dp[i][0] = i;
    }
    for(int j = 0; j < n; ++j)
    {
        dp[0][j] = j;
    }
    for(int i = 1; i <= m; ++i)
    {
        for(int j =1; j <= n; ++j)
        {
            if(s1[i-1] == s2[j-1])
            {
                dp[i][j]=dp[i-1][j-1];
            }
            else
            {
                dp[i][j] = min({dp[i-1][j-1],dp[i-1][j],dp[i][j-1]} ) + 1;
            }
        }
    }
    return dp[m][n];
}

string longestCommonPrefix(vector<string>& strs) {
    string res = "";
    if(strs.size() == 0)return res;        
    sort(strs.begin(),strs.end());        
    for(int i = 0; i < strs[0].size();++i)
    {
        char tmp = strs[0][i];
        int j = 1 ;
        for(j = 1; j < strs.size();++j)
        {
            if(tmp != strs[j][i])break;
        }
        if(j >= strs.size())res += tmp;
        else break;
    }        
    return res;     
}


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

LinkNode* endOfFirst(LinkNode* head)
{
    LinkNode* slow = head;
    LinkNode* fast = head;
    while(fast->next != nullptr && fast->next->next != nullptr)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

LinkNode* reverse(LinkNode* head)
{
    LinkNode* pre = nullptr;
    while(head != nullptr)
    {
        LinkNode* next = head->next;
        head->next = pre;
        pre = head;
        head = next;
    }
    return pre;
}

bool isPalindrome(LinkNode* head)
{

    LinkNode* firstHead = endOfFirst(head);
    LinkNode* second = reverse(firstHead->next);
    LinkNode* p1 = head;
    LinkNode* p2 = second;
    bool result = true;
    while(result && p2 != nullptr)
    {
        if(p1->val != p2->val)return false;
        p1 = p1->next;
        p2 = p2->next;
    }
    firstHead->next = reverse(second);
    return result;
}

bool isPalindrome(int x)
{
    if(x < 0 || (x > 0 && (x % 10) == 0))return false;
    int reverse = 0;    
    while(x > reverse)
    {
        reverse = reverse * 10 + x % 10;
        x /= 10;
    }    
    return (x == reverse || x == reverse / 10);    
}

int largestRectangle(vector<int>& height)
{
    stack<int>st;
    int res = 0;
    for(int i = 0; i < height.size(); ++i)
    {
        while(!st.empty() && height[i] <= height[st.top()])
        {
            int preHeight = height[st.top()];
            st.pop();
            int width = i - (st.empty() ? 0:st.top() + 1);
            res = max(res,preHeight * width);
        }
        st.push(i);
    }
    while(!st.empty())
    {
        int preHeight = height[st.top()];
        st.pop();
        int width = height.size() - (st.empty() ? 0 :st.top() + 1);
        res = max(res,preHeight * width);
    }
    return res;
}

int maxRectangle(const vector<vector<string>>& matrix)
{
    int m = matrix.size();
    if(m == 0)return 0;
    int n = matrix[0].size();
    vector<int>height(n);
    int res = 0;
    for(int i = 0; i < m; ++i)
    {
        for(int j = 0;j < n; ++j)
        {
            if(matrix[i][j] == "0")height[j]=0;
            else ++height[j];        
        }
        res = max(res,largestRectangle(height));
    }
    return res;
}

int longestValidParentheses(string s) {
    int res = 0;
    stack<int>st;
    st.push(-1);
    for(int i = 0;i < s.size(); ++i)
    {
        char c =s[i];
        if(c == '(')
        {
            st.push(i);
        }
        else
        {
            st.pop();
            if(st.empty())st.push(i);
            else
            res = max(res, i - st.top());
        }
    }
    return res;
}

// LinkNode* removeNthFromEnd(LinkNode* head,int n)
// {
//     LinkNode dummy(0);
//     dummy.next = head;
//     LinkNode* first = &dummy, *second = &dummy;
//     for(int i = 1; i <= n + 1; ++i)
//     {
//         first = first->next;
//     }
//     while(first != nullptr)
//     {
//         first = first->next;
//         second = second->next;
//     }
//     second->next = second->next->next;
//     return dummy.next;
// }

LinkNode* reverseKGroup(LinkNode* head, int k)
{
    LinkNode* node = head;
    int cnt = 0;
    while(cnt < k)
    {        
        if(nullptr == node)return head;
        node = node->next;
        ++cnt;        
    }    
    LinkNode* pre = reverseKGroup(node,k);
    while(cnt-- > 0)
    {
        LinkNode* next = head->next;
        head->next = pre;
        pre = head;
        head = next;
    }       
    return pre;    
}


LinkNode* removeNthFromEnd(LinkNode* head, int n)
{
    LinkNode* dummy = new LinkNode(0);
    dummy->next = head;
    LinkNode* first = dummy, *second = dummy;
    for(int i = 1; i <= n + 1; ++i)
    {
        first = first->next;
    }
    while(first != nullptr)
    {
        first = first->next;
        second = second->next;
    }
    second->next = second->next->next;
    return dummy->next;
}

int search(vector<int>& nums, int target) {
    int left = 0, right = nums.size() - 1;
    while(left <= right)
    {
        int mid = left + (right - left) / 2;
        if(nums[mid]==target)return mid;
        else if(nums[left] <= nums[mid])
        {
            if(nums[left] <= target && nums[mid] >= target)right = mid -1;
            else left = mid + 1;
        }
        else
        {
            if(nums[mid] <= target && nums[right] >= target)left = mid + 1;
            else right = mid - 1;            
        }
    }             
    return -1;
}

bool isContain(const vector<int>& nums,int val)
{
    for(auto &num : nums)
    {
        if(num == val)return true;
    }
    return false;
}

void help(vector<int>& nums,vector<vector<int>>&res,vector<int>&tmp,int index)
{
    if(tmp.size() == nums.size())res.emplace_back(tmp);
    else
    {
        for(int i = 0; i < nums.size(); ++i)
        {
            if(isContain(tmp,nums[i]))continue;
            tmp.emplace_back(nums[i]);
            help(nums,res,tmp,index + 1);
            tmp.pop_back();
        }
    }        
}

int majorNum(const vector<int>& nums)
{
    int major = 0,res = 0;
    unordered_map<int,int>m;
    for(auto & num:nums)
    {
        ++m[num];
        if(m[num] > major)
        {
            major = m[num];
            res = num;
        }
    }
    return res;
}

vector<vector<int>>permute(vector<int>& nums)
{
    vector<vector<int>>res;
    vector<int>tmp;
    sort(nums.begin(),nums.end());
    help(nums,res,tmp,0);
    return res;
}
void print(const vector<vector<int>>& nums)
{
    for(auto && num : nums)
    {
        for(auto && n : num)
        {
            cout << n << " ";
        } 
        cout << endl;
    }
    
}

bool compare(TreeNode* left, TreeNode* right)
{
    if(nullptr == left && nullptr != right)return false;
    else if(nullptr == right && nullptr != left)return false;
    else if(nullptr == left && nullptr == right)return true;
    else if(left->val != right->val)return false;
    bool outside = compare(left->left,right->right);
    bool inside = compare(left->right,right->left);
    return inside && outside;
    
}

bool isSymmetric(TreeNode* root)
{
    if(root == nullptr)return true;
    return compare(root->left,root->right);
}

bool isSymmetric_stack(TreeNode* root)
{
    if(nullptr == root)return true;
    stack<TreeNode*>st;
    st.push(root->left);
    st.push(root->right);
    while(!st.empty())
    {
        TreeNode* leftNode = st.top();st.pop();
        TreeNode* rightNode = st.top();st.pop();
        if(!leftNode && !rightNode)continue;
        if(!leftNode || !rightNode || leftNode->val != rightNode->val)return false;
        st.push(leftNode->left);
        st.push(rightNode->right);
        st.push(leftNode->right);
        st.push(rightNode->left);
    }
    return true;
}

bool isSymmetric_queue(TreeNode* root)
{
    if(root == nullptr)return true;
    queue<TreeNode*>q;
    q.push(root->left);
    q.push(root->right);
    while(!q.empty())
    {
        TreeNode* leftNode = q.front();q.pop();
        TreeNode* rightNode = q.front();q.pop();
        if(!leftNode && !rightNode)continue;
        if(!leftNode || !rightNode || (leftNode->val != rightNode->val))
        return false;
        q.push(leftNode->left);
        q.push(rightNode->right);
        q.push(leftNode->right);
        q.push(rightNode->left);
    }
    return true;
}

int largestRectangleArea(const vector<int>& nums)
{
    stack<int>st;
    int n = nums.size();
    int res = 0;
    for(int i = 0; i < n; ++i)
    {
        while(!st.empty() && nums[i] <= nums[st.top()])
        {
            int pre = st.top();
            st.pop();
            int preHeight = nums[pre];
            int width = i - (st.empty() ? 0 :st.top() + 1);
            res = max(res, preHeight * width);
        }
        st.push(i);
    }
    while(!st.empty())
    {
        int preHieght = nums[st.top()];
        st.pop();
        int width = n - (st.empty() ? 0 : st.top() + 1);
        res = max(res,preHieght * width);
    }
    return res;
}

LinkNode* partition(const vector<LinkNode*>& lists,int start, int end)
{
    if(start == end)return lists[start];
    if(start < end)
    {
        int mid = start + (end - start) / 2;
        auto l1 = partition(lists,start,mid);
        auto l2 = partition(lists,mid+1,end);
        return mergeTwoLists(l1,l2);
    }
    return nullptr;
}

LinkNode* mergeKLists(vector<vector<int>>& lists)
{
    vector<LinkNode*>listss;
    for(int i = 0; i < lists.size(); ++i)
    {        
        listss.push_back(generateLinkNode(lists[i]));
    }    
    return partition(listss,0,lists.size() - 1);
}


void twoSum(const vector<int>& nums,int left,int right,int target,vector<vector<int>>&res)
{
    while(left < right)
    {
        int tmp = nums[left] + nums[right] + target;
        if(0 == tmp)
        {
            res.push_back({target,nums[left++],nums[right--]});
            while(left < right && nums[left] == nums[left-1])++left;
            while(left < right && nums[right] == nums[right+1])--right;
        }
        else if(tmp>0)--right;
        else ++left;
    }
    return;
}


vector<vector<int>>ThreeSum(vector<int>& nums)
{
    sort(nums.begin(),nums.end());
    vector<vector<int>>res;
    for(int i =  0; i < nums.size() - 2; ++i)
    {
        if(i != 0 && nums[i] == nums[i-1])continue;
        int left = i + 1, right = nums.size() -1;
        twoSum(nums,left,right,nums[i],res);
    }
    return res;
}
void twoSumI(const vector<int>& nums,int left,int right,int target,vector<vector<int>>&res)
{
    while(left < right)
    {
        int tmp = nums[left] +nums[right] + target;
        if(0 == tmp)
        {
            res.push_back({target,nums[left++],nums[right--]});
            while(left < right && nums[left] == nums[left - 1])++left;
            while(left < right && nums[right] == nums[right + 1])--right;
        }
        else if(0 < tmp)--right;
        else ++left;
    }
    return;
}


vector<vector<int>>ThreeSum2(vector<int>&nums)
{
    sort(nums.begin(),nums.end());
    vector<vector<int>>res;
    for(int i = 0 ; i < nums.size() - 2; ++i)
    {
        if(i!=0 && nums[i] == nums[i-1])continue;
        int left = i + 1, right = nums.size() - 1;
        twoSumI(nums,left,right,nums[i],res);   
    }
    return res;
}


int maxSubArray(const vector<int>& nums)
{
    
    int res = INT_MIN,sum = 0, n = nums.size();
    for(int i = 0; i < n; ++i)
    {
        sum += nums[i];
        res = max(res,sum);
        if(sum < 0) sum = 0;
    }
    return res;
}


int maxSubArray0(const vector<int>& nums)
{
    int maxSum = INT_MIN,maxEnd = 0, n = nums.size();
    for(int i = 0; i < n; ++i)
    {
        maxEnd += nums[i];
        maxSum = max(maxSum,maxEnd);
        if(maxEnd < 0) maxEnd = 0;
    }
    return maxSum;
}

int findDuplicate(const vector<int>&nums)
{
    int slow = nums[0],fast = nums[nums[0]];
    while(slow != fast)
    {
        slow = nums[slow];
        fast = nums[nums[fast]];
    }
    int p1 = nums[0];
    int p2 = nums[slow];
    while(p1 != p2)
    {
        p1 = nums[p1];
        p2 = nums[p2];
    }
    return p1;
}

int length(LinkNode* head)
{
    int size = 0;
    while(head != nullptr)
    {
        ++size;
        head = head->next;
    }
    return size;
}

LinkNode* getInersection(LinkNode* headA, LinkNode* headB)
{
    
    int lenA = length(headA), lenB = length(headB);
    while(lenB > lenA)
    {
        headB = headB->next;
        --lenB;
    }
    while(lenA > lenB)
    {
        headA = headA->next;
        --lenA;
    }
    while(headA != nullptr&& headB != nullptr)
    {
        if(headA->val == headB->val)return headA;
        headA = headA->next;
        headB = headB->next;
    }
    return nullptr;    
}

string minWindow(string s, string t)
{
    unordered_map<char,int>map;
    for(char c:t)
    {
        ++map[c];
    }
    int left = 0, minStart = 0, minLen = INT_MAX, cnt = 0;
    for(int i = 0; i < s.size(); ++i)
    {
        char c = s[i];
        if(map.count(c))
        {
            if(map[c]>0)++cnt;
            --map[c];
        }
        while(cnt == t.size())
        {
            if(i - left + 1 < minLen)
            {
                minLen = i - left + 1;
                minStart = left;
            }
            char leftChar = s[left];
            if(map.count(leftChar))
            {
                ++map[leftChar];
                if(map[leftChar] > 0) --cnt;
            }
            ++left;
        }
    }
    if(minLen == INT_MAX)return "";
    return s.substr(minStart,minLen);
}

void dfs(vector<vector<int>>& res,const vector<int>&nums,vector<int>&tmp,int start)
{
    res.emplace_back(tmp);    
    for(int i = start; i < nums.size(); ++i)
    {        
        tmp.emplace_back(nums[i]);
        dfs(res,nums,tmp,i + 1);
        tmp.pop_back();
    }
    return ;
}

vector<vector<int>>subset(const vector<int>& nums)
{
    vector<vector<int>>res;
    vector<int>tmp;
    dfs(res,nums,tmp,0);
    return res;
}

int numTrees(int n)
{
    vector<int>G(n+1);
    G[0] = 1;
    G[1] = 1;
    for(int i = 2; i <= n; ++i)
    {
        for(int j = 1; j <= i; ++j)
        {
            G[i] += G[j-1]*G[i-j];
        }
    }
    return G[n];
}

LinkNode* sortList(LinkNode* head)
{
    if(nullptr == head || nullptr == head->next)
    return head;
    LinkNode* lowHead = new LinkNode(0);
    LinkNode* low = lowHead;
    LinkNode* midHead = new LinkNode(0);
    LinkNode* mid = midHead;
    LinkNode* highHead = new LinkNode(0);
    LinkNode* high = highHead;

    int val = head->val;
    LinkNode* node = head;
    while(nullptr != node)
    {
        if(node->val > val)
        {
            high->next = node;
            high = high->next;
        }
        else if(node->val < val)
        {
            low->next = node;
            low = low->next;
        }
        else{
            mid->next = node;
            mid = mid->next;
        }
        node = node->next;
    }
    low->next = nullptr;
    high->next = nullptr;

    lowHead->next = sortList(lowHead->next);
    highHead->next = sortList(highHead->next);

    low = lowHead;
    while(nullptr != low->next)
    {
        low = low->next;
    }
    low->next = midHead->next;
    mid->next = highHead->next;
    return lowHead->next;

}

int maxProduct(const vector<int>& nums)
{
    int n = nums.size();
    vector<int>maxVal(n), minVal(n);
    int res = nums[0];
    maxVal[0] = nums[0], minVal[0] = nums[0];
    for(int i = 1; i < n; ++i)
    {
        if(nums[i]>0)
        {
            maxVal[i] = max(maxVal[i - 1] * nums[i],nums[i]);
            minVal[i] = min(minVal[i-1] * nums[i],nums[i]);
        }
        else
        {
            maxVal[i] = max(minVal[i - 1] * nums[i],nums[i]);
            minVal[i] = min(maxVal[i-1] * nums[i],nums[i]);            
        }
        res = max(res,maxVal[i]);
    }
    return res;
}

TreeNode* lowestCommonTree(TreeNode* node,TreeNode* p, TreeNode* q)
{
    if(node == nullptr || node == p || node == q)return node;
    TreeNode* left = lowestCommonTree(node->left,p,q);
    TreeNode* right = lowestCommonTree(node->right,p,q);
    if(left != nullptr && right != nullptr)return node;
    else if(left != nullptr && right == nullptr)return left;
    else if(left == nullptr && right != nullptr )return right;
    else return nullptr;
}

int firstMissingPositive(vector<int>& nums) {
    int n = nums.size();
    for(int i = 0; i < n; ++i)
    {
        while(nums[i] > 0 && nums[i] <= n && nums[i] != nums[nums[i]-1])
        {
            swap(nums[i],nums[nums[i]-1]);
        }
        for(int i = 0; i < n; ++i)
        {
            if(nums[i] != i + 1)
            {
                return i + 1;
            }
        }
        return n + 1;
    }       
}

int numSquares(int n)
{
    vector<int>dp(n+1,INT_MAX);
    dp[0] = 0;
    for(int i = 0; i <= n; ++i)
    {
        for(int j = 1; j * j <= i; ++j)
        {
            dp[i] = min(dp[i],dp[i - j * j]+1);
        }
    }
    return dp[n];
}


int main()
{
    vector<int> nums{10,1,3,3,2,4,5};
    print(qs(nums));
    print(hpS(nums));

    //LeetCode15
    vector<int>nums2{ -1,0,1,2,-1,-4 };
    print(ThreeSum2(nums2));
    // LeetCode53    
    nums = {-2,1,-3,4,-1,2,1,-5,4};
    cout << maxSubArray0(nums) << endl;
    // LeetCode7
    cout << reverse1(-123) << endl;
    //LeetCode11
    vector<int>height{4,2,0,3,2,5};
    cout << trapI(height) << endl;
    
    //LeetCode42
    height = {4,2,0,3,2,5};
    cout << rain(height) << endl;
    cout << rainI(height) << endl;
    

    
    //LeetCode20
    string s1 = "{[]}";
    cout << isValid1(s1) << endl;

    //LeetCode10
    string s = "aab";
    string p = "c*a*b";
    cout << isMatch(s,p) << endl;
    
    //LeetCode26
    nums = {1,2,3,4,4,5,6,6,6};
    removeDuplicatesI(nums);
    for(auto & num:nums)
    {
        cout << num <<" ";
    }
    cout << endl;

    //LeetCode136
    nums = {1,2,2,3,3};
    cout << singleNum0(nums) << endl;
    
    //LeetCode22
    int n = 3;
    print(gen(n));
    nums = {1,1,1,3,3,3,4};
    cout << singleNumberI(nums) <<endl;

    //LeetCode206
    nums = {1,2,3,4,5};
    print(reverseIII(generateLinkNode(nums)));
    print(reverse(generateLinkNode(nums),nullptr));

    // //LeetCode21
    vector<int>l1 = {1,2,4};
    vector<int>l2 = {1,3,4};
    print(mergeTwoLists(generateLinkNode(l1),generateLinkNode(l2)));

    // //LeetCode70 爬楼梯
    cout << climbStairs(3) << endl;
    cout << climbStairs_m(3,2) << endl;//变体为完全背包问题

    // //LeetCode300 递增最长子序列
    nums = {0,1,0,3,2,3};
    cout << lengthOfList(nums) << endl;
    
    // //LeetCode121 买卖股票的最佳时机
    nums = {7,1,5,3,6,4};
    cout << maxProfit(nums) << endl;

    // //LeetCode72 编辑距离
    string s0 = "intention";
    s1 = "execution";
    cout << minEditDistance(s0,s1) << endl;

    // //LeetCode14 最长公共前缀
    vector<string>ss{"fly","flower","flsdf"};
    cout << longestCommonPrefix(ss) << endl;        

    // //打家劫舍
    // //LeetCode198 打家劫舍
    nums = {2,7,9,3,1};
    cout << rob(nums) << endl;

    // //LeetCode9
    int x = 0121;
    cout << isPalindrome(x) << endl;

    // //LeetCode19
    nums = {1,2,3,4,5};
    n = 2;
    LinkNode* node = generateLinkNode(nums);
    print(node);
    print(removeNthFromEnd(node,n));
    
    // //LeetCode33搜索旋转排序数组。
    nums={4,5,6,7,0,1,2};
    cout << search(nums,0) << endl;

    // // LeetCode46
    nums = {1,2,3};
    print(permute(nums));  

    // //LeetCode101
    //LeetCode101对称二叉树
    TreeNode n0(1);
    TreeNode n1(2);
    TreeNode n2(2);
    TreeNode n3(3);
    TreeNode n4(4);
    TreeNode n5(3);
    TreeNode n6(4);
    n0.left = &n1;
    n0.right = &n2;
    n1.left = &n3;
    n1.right = &n4;
    n2.left = &n6;
    n2.right = &n5;
    cout << isSymmetric(&n0) << endl;
    cout << isSymmetric_stack(&n0) << endl;
    cout << isSymmetric_queue(&n0) << endl;

    // //LeetCode84
    height = {2,1,5,6,2,3};
    cout << largestRectangleArea(height) << endl;

    // //LeetCode39 组合总和(可重复)
    vector<int>candidates{2,3,6,7};
    int target = 7;
    print(combinationSum(candidates,target));

    // //LeetCode13罗马数字转整数
    s = "MCMXCIV";
    cout << romanToInt(s) << endl;

    // //LeetCode23合并k个链表
    vector<vector<int>> lists = {{1,4,5},{1,3,4},{2,6}};
    print(mergeKLists(lists));

    // //LeetCode17 电话号码的字母组合
    print(letterCombinations("23"));

    // //LeetCode322 零钱兑换
    vector<int>coins = {1,2,5};
    int amount = 11;
    cout << coinChange(coins,amount) << endl;

    
    // //LeetCode32
    string s4 = ")()())";
    cout << longestValidParentheses(s4) << endl;

    // // LeetCode287
    nums = {1,3,4,2,2};
    cout << findDuplicate(nums) << endl;    
    //LeetCode122
    vector<int>prices{1,2,3,4,5};
    prices = {7,1,5,3,6,4};
    cout << maxProfit_II(prices) <<endl;
    cout << maxProfit_II_greedy(prices) << endl;

    
    //LeetCode160
    vector<int>listA{4,1,8,4,5};
    vector<int>listB{5,6,1,8,4,5};    
    cout << getInersection(generateLinkNode(listA),generateLinkNode(listB))->val << endl;
    
    //LeetCde55 跳跃游戏
    nums = {2,3,1,1,4};
    cout << canJump(nums) << endl;

    //LeetCode76
    s = "ADOBECODEBANC";
    string t = "ABC";
    cout << minWindow(s,t) << endl;
    
    //    LeetCode200
    vector<vector<string>>grid{{"1","1","0","1","1"},{"1","0","1","0","1"},{"1","0","0","0","1"}};    
    cout << numIslands(grid)<<endl;

    //LeetCode78
    nums = {1,2,3};    
    print(subset(nums));

    //LeetCode31
    nums = {1,5,1};
    nextPermutation(nums);
    print(nums);

    //LeetCode96
    cout << numTrees(3) << endl;

    //LeetCode148
    nums = {4,2,1,3};
    node = generateLinkNode(nums);
    node = sortList(node);
    print(node);

     //LeetCode501 二叉搜索树中的众数
    cout << "=====" << endl;
    TreeNode t10(1);
    TreeNode t11(2);
    TreeNode t12(2);
    t10.left = &t11;
    t10.right = &t12;
    //LeetCode236 二叉树的公共祖先
    cout << lowestCommonTree(&t10,&t11,&t12)->val << endl;

    //LeetCode25
    nums = {1,2,3,4,5};
    int k = 2;
    print(reverseKGroup(generateLinkNode(nums),k));

    //LeetCode6
    s = "LEETCODEISHIRING";
    cout << convert(s,4) << endl;

    //LeetCode152
    nums = {2,3,-2,4};
    cout << maxProduct(nums) << endl;

    //LeetCode8 
    cout << str2int(" -1234") << endl;
    
    //LeetCode41
    nums = {1,-1,3,4};
    cout << firstMissingPositive(nums) << endl;
    //LeetCode283
    nums = {0,0,0,1,2,0,3,5,6};
    moveZeroes(nums);
    print(nums);

    //LeetCode141
    LinkNode n11(3);
    LinkNode n22(2);
    LinkNode n33(0);
    LinkNode n44(-4);
    n11.next = &n22;
    n22.next = &n33;
    n33.next = &n44;
    n44.next = &n22;
    cout << hasCycleNode(&n11) << endl;

    //LeetCode98
    TreeNode b0(1);
    TreeNode b1(2);
    TreeNode b2(3);
    b1.left = &b0;
    b1.right = &b2;
    cout << isValidBST(&b1) << endl;

    // LeetCode124
    TreeNode a0(-10);
    TreeNode a1(9);
    TreeNode a2(20);
    TreeNode a3(15);
    TreeNode a4(7);
    a0.left = &a1;
    a0.right = &a2;
    a2.left = &a3;
    a2.right = &a4;
    cout << maxSum(&a0)<<endl;

    //LeetCode105
    vector<vector<int>>tmp;       
    vector<int>preV{3,9,1,2,20,15,7};
    vector<int>inV{1,9,2,3,15,20,7};
    levelOrder(buildTreeFromPreIn(preV,inV),tmp);
    print(tmp);

    //LeetCode34
    nums = {5,7,7,8,8,10};
    target = 8;
    nums = {5,7,7,8,8,10};
    target = 6;
    print(searchRange(nums,target));

    //LeetCode239
    nums={1,3,-1,-3,5,3,6,7};
    k = 3;
    print(maxSlidingWindow(nums,k));
     

    //LeetCode142    
    cout << detectCycleNode(&n11)->val << endl;

    //LeetCode139 单词拆分
    string str = "leetcode";
    vector<string>wordDict{"leet","code"};
    cout << wordBreak(str,wordDict) << endl;

    //LeetCode145
    nums = {2,3,1,1,4};
    cout << jump(nums) << endl;

    //LeetCode169
    nums = {2,2,1,1,1,2,2};
    cout << majorNum(nums) << endl;

    //LeetCode234
    nums = {1,2,2,1};
    cout << isPalindrome(generateLinkNode(nums)) << endl;

    //LeetCode62
    cout << uniquePaths(3,2) << endl;
    cout << uniquePathsI(3,2) << endl;

    //LeetCode189
    nums = {1,2,3,4,5,6,7};
    k = 3;
    rotate(nums,k);
    print(nums);

    //LeetCode94
    TreeNode a(0);
    TreeNode b(1);
    TreeNode c(2);
    TreeNode d(3);
    TreeNode e(4);
    TreeNode f(5);
    TreeNode g(6);
    b.left = &d;
    b.right = &e;
    c.left = &f;
    c.right = &g;
    a.left = &b;
    a.right = &c;
    TreeNode root = a;

    vector<int>res1;    
    inorder(&root);
    inorder(&root,res1);
    print(res1);

     //LeetCode56
    vector<pair<int,int>>intervals{{1,3},{2,6},{8,10},{9,18}};
    print(merge(intervals));

    //LeetCode88

    vector<int>nums1{1,2,3,0,0,0};
    nums2 = {2,5,6};
    int m = 3;
    n = 3;
    merge(nums1,m,nums2,n);
    print(nums1);

    //LeetCode560
    nums = {1,2,3};
    k = 3;
    cout << subarraySum(nums,k) << endl;

     //LeetCode279 完全平方数
    cout << numSquares(12) << endl;

    //LeetCode35
    nums = {1,3,5,6};
    target = 2;
    cout << searchInsert(nums,target) << endl;

    //LeetCode24
    vector<int>head{1,2,3,4};
    print(swapPairs(generateLinkNode(head)));

    //LeetCode85         
    vector<vector<string>>matrix{{"1","0","1","0","0"},{"1","0","1","1","1"},{"1","1","1","1","1"},{"1","0","0","1","0"}};
    cout << maxRectangle(matrix) << endl;

     //LeetCode92
    nums = {1,2,3,4,5};
    int left = 2, right = 4;
    print(reverseBetween(generateLinkNode(nums),left,right));
    return 0;
}

标签：return,nums,int,res,next,经典,leetcode,left
来源： https://www.cnblogs.com/fourmi/p/16474949.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。