feat: solve problem

Author: HONGJICAI

cpp/1008.ConstructBinarySearchTreeFromPreorderTraversal.cpp

@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+//Runtime: 4 ms, faster than 96.40% of C++ online submissions for Construct Binary Search Tree from Preorder Traversal.
+//Memory Usage: 8.7 MB, less than 97.42% of C++ online submissions for Construct Binary Search Tree from Preorder Traversal.
+public:
+    TreeNode* bstFromPreorder(vector<int>& preorder) {
+        if(not preorder.size())
+            return nullptr;
+        auto r=new TreeNode(preorder[0]);
+        auto now=r;
+        vector<TreeNode*>st;
+        for(int i=1;i<preorder.size();++i){
+            auto t=preorder[i];
+            if(t<now->val){
+                st.push_back(now);
+                now=now->left=new TreeNode(t);
+            }
+            else{
+                while(st.size()&&t>st.back()->val){
+                    now=st.back();
+                    st.pop_back();
+                }
+                now=now->right=new TreeNode(t);
+            } 
+        }
+        return r;
+    }
+};

cpp/1025.DivisorGame.cpp

@@ -0,0 +1,19 @@
+class Solution {
+//Runtime: 0 ms, faster than 100.00% of C++ online submissions for Divisor Game.
+//Memory Usage: 8.6 MB, less than 12.27% of C++ online submissions for Divisor Game.
+public:
+    bool divisorGame(int N) {
+        vector<int>dp={0,0,1,0};
+        dp.resize(N+1);
+        for(int i=4;i<=N;++i){
+            dp[i]=0;
+            for(int j=i/2;j>=1;--j){
+                if(i%j==0 and dp[i-j]==0){
+                    dp[i]=1;
+                    break;
+                }
+            }
+        }
+        return dp[N];
+    }
+};

cpp/1026.MaximumDifferenceBetweenNodeAndAncestor.cpp

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+//Runtime: 8 ms, faster than 92.53% of C++ online submissions for Maximum Difference Between Node and Ancestor.
+public:
+    int maxAncestorDiff(TreeNode* root) {
+        int ret=0;
+        function<void(TreeNode*,int,int)> recursion = [&ret,&recursion](auto root,auto maxVal,auto minVal){
+            ret=max({abs(maxVal-root->val),abs(minVal-root->val),ret});
+            maxVal=max(root->val,maxVal);
+            minVal=min(root->val,minVal);
+            if(root->left)
+                recursion(root->left,maxVal,minVal);
+            if(root->right)
+                recursion(root->right,maxVal,minVal);
+        };
+        recursion(root,root->val,root->val);
+        return ret;
+    }
+};

cpp/105.ConstructBinaryTreeFromPreorderAndInorderTraversal.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+//Runtime: 20 ms, faster than 79.16% of C++ online submissions for Construct Binary Tree from Preorder and Inorder Traversal.
+//Memory Usage: 19.2 MB, less than 25.65% of C++ online submissions for Construct Binary Tree from Preorder and Inorder Traversal.
+public:
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        if(!preorder.size())
+            return nullptr;
+        using itr = vector<int>::iterator;
+        function<TreeNode*(itr,itr,itr&)> build=[&build](itr first,itr last,itr& t)->TreeNode* {
+            auto it=find(first,last,*t);
+            if(it==last)
+                return nullptr;
+            TreeNode *root=new TreeNode(*t++);
+            root->left=build(first,it,t);
+            root->right=build(it+1,last,t);
+            return root;
+        };
+        auto it=begin(preorder);
+        return build(begin(inorder),end(inorder),it);
+    }
+};

cpp/105.ConstructBinaryTreeFromPreorderAndInorderTraversal/recursion.cpp

@@ -0,0 +1,28 @@
+class Solution {
+//Runtime: 60 ms, faster than 67.00% of C++ online submissions for Sliding Window Maximum.
+//Memory Usage: 13.4 MB, less than 27.55% of C++ online submissions for Sliding Window Maximum.
+public:
+    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+        if(k>=nums.size()&&nums.size())
+            return {*max_element(begin(nums),end(nums))};
+        if(k<=0)
+            return {}; 
+        deque<int> dq;
+        vector<int>ret;
+        for(int i=0;i<nums.size();++i){
+            if(dq.empty() or dq.back()>=nums[i])
+                dq.push_back(nums[i]);
+            else{
+                while(dq.size() and dq.back()<nums[i])
+                    dq.pop_back();
+                dq.push_back(nums[i]);                
+            }
+            if(i+1>=k){
+                ret.push_back(dq.front());
+                if(nums[i+1-k]==dq.front())
+                    dq.pop_front();
+            }
+        }
+        return ret;
+    }
+};

cpp/239.SlidingWindowMaximum.cpp

@@ -0,0 +1,37 @@
+class Solution {
+//Runtime: 124 ms, faster than 15.73% of C++ online submissions for Remove Invalid Parentheses.
+//Memory Usage: 10.9 MB, less than 64.65% of C++ online submissions for Remove Invalid Parentheses.
+public:
+    vector<string> removeInvalidParentheses(string_view s) {
+        unordered_set<string> ret;
+        using itr=string_view::iterator;
+        function<void(itr,itr,int,string&)> dfs=[&ret,&dfs](auto first,auto last,auto remain,auto &now){
+            if(ret.size() and last-first+now.size() < begin(ret)->size())
+                return;
+            if(first==last){
+                if(remain)
+                    return;
+                if(not ret.size() or begin(ret)->size()==now.size())
+                    ret.insert(now);
+                if(begin(ret)->size()<now.size())
+                    ret={now};
+                return;
+            }
+            int remainIfPush;
+            switch(*first){
+                case '(':remainIfPush=remain+1;break;
+                case ')':remainIfPush=remain-1;break;
+                default:remainIfPush=remain;
+            }
+            if(remainIfPush>=0){
+                now.push_back(*first);
+                dfs(first+1,last,remainIfPush,now);
+                now.pop_back();
+            }
+            dfs(first+1,last,remain,now);
+        };
+        string now;
+        dfs(begin(s),end(s),0,now);
+        return {begin(ret),end(ret)};
+    }
+};

cpp/301.RemoveInvalidParentheses.cpp

@@ -0,0 +1,29 @@
+class Solution 
+//Runtime: 4 ms, faster than 84.37% of C++ online submissions for Decode String.
+//Memory Usage: 8.7 MB, less than 91.46% of C++ online submissions for Decode String.
+public:
+    string decodeString(string s) {
+        function<string(string_view)> recursion=[&recursion](auto s){
+            string res;
+            for (int i=0;i<s.length();)
+                if (!isdigit(s[i]))
+                    res += s[i++];
+                else {
+                    int n = 0;
+                    while (i < s.length() && isdigit(s[i]))
+                        n = n * 10 + s[i++] - '0';
+                    int j=i+1;
+                    for(int count=1;count;++j)
+                        if(s[j]=='[')
+                            ++count;
+                        else if(s[j]==']')
+                            --count;
+                    for(auto t=recursion(s.substr(i+1,(j-2)-(i+1)+1));n;--n)
+                        res += t;
+                    i=j;
+                }
+            return res;
+        };
+        return recursion(s);
+    }
+};

cpp/394.DecodeString.cpp

@@ -0,0 +1,33 @@
+class Solution {
+//speed can be improved but it reach 0ms now
+//Runtime: 0 ms, faster than 100.00% of C++ online submissions for Evaluate Division.
+//Memory Usage: 9.3 MB, less than 81.50% of C++ online submissions for Evaluate Division.
+public:
+    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
+        using pp = pair<bool, double>;
+        using sv = string_view;
+        unordered_map<sv, vector<pair<sv, double>>> children;
+        for (int i = 0; i < equations.size(); i++) {
+            children[equations[i][0]].push_back({equations[i][1], values[i]});
+            children[equations[i][1]].push_back({equations[i][0], 1.0 / values[i]});
+        }
+        unordered_set<sv> visited;
+        function<pp(sv,sv,double)> dfs=[&dfs,&visited,&children](sv a, sv b, double val)->pp {
+            if(!visited.count(a)){
+                visited.insert(a);
+                for (auto &p : children[a])
+                    if (p.first == b)
+                        return {true, val * p.second};
+                    else if (auto result=dfs(p.first,b,val*p.second);result.first)
+                        return result;
+            }
+            return {false, -1.0};
+        };
+        vector<double> ans;
+        for (auto &p : queries) {
+            ans.push_back(p[0] == p[1] && children.count(p[0]) ? 1.0 : dfs(p[0], p[1], 1.0).second);
+            visited.clear();
+        }
+        return ans;
+    }
+};

cpp/399.EvaluateDivision.cpp

@@ -0,0 +1,23 @@
+class Solution {
+//Runtime: 52 ms, faster than 80.66% of C++ online submissions for Frog Jump.
+//Memory Usage: 145.6 MB, less than 5.04% of C++ online submissions for Frog Jump.
+public:
+    bool canCross(vector<int>& stones) {
+        vector<vector<int>> visited(stones.size(),vector<int>(stones.size()));
+        function<bool(int,int)> dfs=[&stones,&visited,&dfs](int now,int k){
+            for (int i=now+1;i<stones.size();++i) {
+                int gap = stones[i] - stones[now];
+                if (gap < k - 1)
+                    continue;
+                if (gap > k + 1)
+                    return false;
+                if (not visited[now][i] and dfs(i, gap))
+                    return true;
+                else
+                    visited[now][i]=1;
+            }
+            return now==stones.size()-1;
+        };
+        return dfs(0,0);
+    }
+};