commit

Author: PanAndy

.vscode/settings.json

@@ -28,6 +28,15 @@
         "type_traits": "cpp",
         "utility": "cpp",
         "typeinfo": "cpp",
-        "iostream": "cpp"
+        "iostream": "cpp",
+        "algorithm": "cpp",
+        "xiosbase": "cpp",
+        "set": "cpp",
+        "xtree": "cpp",
+        "stack": "cpp",
+        "xstring": "cpp",
+        "string": "cpp",
+        "map": "cpp",
+        "queue": "cpp"
     }
 }

10.正则表达式匹配.cpp

@@ -0,0 +1,61 @@
+/*
+ * @lc app=leetcode.cn id=10 lang=cpp
+ *
+ * [10] 正则表达式匹配
+ */
+
+// @lc code=start
+#include<iostream>
+#include<string>
+
+using namespace std;
+
+class Solution {
+public:
+    bool isMatch(string s, string p) {
+        // return doMatch(s, p, 0, 0);
+        memset(memo, 0, sizeof(memo));
+        return state(s, p, 0, 0);
+    }
+
+    // bool doMatch(string &s, string &p, int s_pos, int p_pos)
+    // {
+    //     if(p_pos>=p.size())return s_pos>=s.size();
+    //     bool currentMatch = s_pos<s.size() && (s[s_pos]==p[p_pos] || p[p_pos]=='.');
+    //     if(p_pos<p.size()-1 && p[p_pos+1]=='*')
+    //     {
+    //         return doMatch(s,p,s_pos,p_pos+2)||(doMatch(s,p,s_pos+1,p_pos)&&currentMatch);
+    //     }
+    //     else{
+    //         return currentMatch && doMatch(s, p, s_pos+1, p_pos+1);
+    //     }
+    // }
+
+    int memo[1000][1000];
+    bool state(string &s, string &p, int s_pos, int p_pos)
+    {
+
+        bool ans = false;
+        if(s_pos==s.size() && p_pos>=p.size()) return true;
+     
+        if(s_pos!=s.size() && p_pos==p.size())return false;
+
+        if(memo[s_pos][p_pos]!=0)return memo[s_pos][p_pos] == 2;
+        if(p_pos<p.size()-1 && p[p_pos+1] == '*'){
+            if(s[s_pos] == p[p_pos] || (p[p_pos]=='.' && s_pos!=s.size())){
+                ans = state(s, p, s_pos+1, p_pos) || state(s, p, s_pos, p_pos+2);
+            }else
+            {
+                ans = state(s, p, s_pos, p_pos+2);
+            }
+        }
+        else if((p[p_pos]=='.' && s_pos<s.size()) || s[s_pos]==p[p_pos])
+            ans = state(s, p, s_pos+1, p_pos+1);
+        
+        memo[s_pos][p_pos] = int(ans) + 1;
+        return ans;
+    }
+
+};
+// @lc code=end
+

101.对称二叉树.cpp

@@ -0,0 +1,70 @@
+/*
+ * @lc app=leetcode.cn id=101 lang=cpp
+ *
+ * [101] 对称二叉树
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ */
+
+#include<iostream>
+#include<vector>
+
+using namespace std;
+
+//  struct TreeNode {
+//      int val;
+//      TreeNode *left;
+//      TreeNode *right;
+//      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+//  };
+ 
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        zhong.clear();
+        inv_zhong.clear();
+        inorder(root);
+        inv_inorder(root);
+
+        bool flag = true;
+        for(int i=0;i<zhong.size();i++)
+        {
+            if(zhong[i]!=inv_zhong[i]){
+                flag = false;
+                break;
+            }
+        }
+        return flag;
+    }
+
+    vector<int> zhong;
+    vector<int> inv_zhong;
+
+    void inorder(TreeNode* root)
+    {
+        if(root==NULL){
+            zhong.push_back(-1);
+            return;
+        };
+        inorder(root->left);
+        inorder(root->right);
+        zhong.push_back(root->val);
+    }
+
+    void inv_inorder(TreeNode *root)
+    {
+        if(root==NULL){
+            inv_zhong.push_back(-1);
+            return;
+        };
+        inv_inorder(root->right);
+        inv_inorder(root->left);
+        inv_zhong.push_back(root->val);
+    }
+
+};
+// @lc code=end
+

1014.最佳观光组合.cpp

@@ -0,0 +1,30 @@
+/*
+ * @lc app=leetcode.cn id=1014 lang=cpp
+ *
+ * [1014] 最佳观光组合
+ */
+
+// @lc code=start
+#include<vector>
+#include<algorithm>
+#include<iostream>
+#include<climits>
+
+using namespace std;
+
+class Solution {
+public:
+    int maxScoreSightseeingPair(vector<int>& A) {
+        int ans = 0;
+        int mx = A[0] + 0;
+
+        for(int j=1;j<A.size();++j)
+        {
+            ans = max(ans, mx + A[j] - j);
+            mx = max(mx, A[j]+j);
+        }
+        return ans;
+    }
+};
+// @lc code=end
+

1028.从先序遍历还原二叉树.cpp

@@ -0,0 +1,63 @@
+/*
+ * @lc app=leetcode.cn id=1028 lang=cpp
+ *
+ * [1028] 从先序遍历还原二叉树
+ */
+
+// @lc code=start
+
+//  Definition for a binary tree node.
+
+#include<iostream>
+#include<string>
+#include<stack>
+
+using namespace std;
+
+// struct TreeNode{
+//     int val;
+//     TreeNode* left;
+//     TreeNode* right;
+//     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+// };
+
+class Solution {
+public:
+    TreeNode* recoverFromPreorder(string S) {
+        if(S.empty())return NULL;
+        stack<TreeNode*> path;
+        int pos = 0;
+        while(pos<S.size()){
+            int level = 0;
+            while (S[pos]=='-')
+            {
+                ++level;
+                ++pos;
+            }
+            int value = 0;
+            while(pos<S.size() && isdigit(S[pos]))
+            {
+                value = value * 10 + (S[pos]-'0');
+                ++pos;
+            }
+            TreeNode* node = new TreeNode(value);
+            if(level == path.size())
+            {
+                if(!path.empty())
+                {
+                    path.top()->left = node;
+                }
+            }else{
+                while(level!=path.size())
+                    path.pop();
+                path.top()->right = node;
+            }
+            path.push(node);
+        }
+        while(path.size()>1)
+            path.pop();
+        return path.top();
+    }
+};
+// @lc code=end
+

104.二叉树的最大深度.cpp

@@ -0,0 +1,30 @@
+/*
+ * @lc app=leetcode.cn id=104 lang=cpp
+ *
+ * [104] 二叉树的最大深度
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include<algorithm>
+using namespace std;
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        if(root==NULL)return 0;
+        int l=0,r=0;
+        l = maxDepth(root->left);
+        r = maxDepth(root->right);
+        return max(l,r)+1;
+    }
+};
+// @lc code=end
+

105.从前序与中序遍历序列构造二叉树.cpp

@@ -0,0 +1,53 @@
+/*
+ * @lc app=leetcode.cn id=105 lang=cpp
+ *
+ * [105] 从前序与中序遍历序列构造二叉树
+ */
+
+// @lc code=start
+/**
+ Definition for a binary tree node.*/
+#include<iostream>
+#include<algorithm>
+#include<vector>
+
+
+using namespace std;
+
+// struct TreeNode {
+//     int val;
+//     TreeNode *left;
+//     TreeNode *right;
+//     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+// };
+
+class Solution {
+public:
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        int pos = 0;
+        return rebuild(preorder, inorder, pos, 0, preorder.size()-1);
+    }
+
+    TreeNode* rebuild(vector<int>& preorder, vector<int>& inorder, int &pl, int il, int ir)
+    {
+        if(pl > preorder.size()-1)return NULL;
+        if(il>ir)return NULL;
+        int val = preorder[pl++];
+        TreeNode* root = new TreeNode(val);
+
+        int pos = il;
+        for(int i = il; il<=ir; ++i,++pos)
+        {
+            if(inorder[i]==val)
+            {
+                break;
+            }
+        }
+
+        root->left = rebuild(preorder, inorder, pl, il, pos-1);
+        root->right = rebuild(preorder, inorder, pl, pos + 1, ir);
+        return root;
+    }
+};
+// @lc code=end
+

106.从中序与后序遍历序列构造二叉树.cpp

@@ -0,0 +1,49 @@
+/*
+ * @lc app=leetcode.cn id=106 lang=cpp
+ *
+ * [106] 从中序与后序遍历序列构造二叉树
+ */
+
+// @lc code=start
+/**
+ Definition for a binary tree node.*/
+
+#include<iostream>
+#include<vector>
+
+using namespace std;
+
+// struct TreeNode {
+//     int val;
+//     TreeNode *left;
+//     TreeNode *right;
+//     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+// };
+class Solution {
+public:
+    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
+        int pos = postorder.size()-1;
+        return rebuild(inorder, postorder, pos, 0, inorder.size()-1);
+    }
+
+    TreeNode* rebuild(vector<int>& inorder, vector<int>& postorder, int &pr, int il, int ir)
+    {
+        if(pr<0)return NULL;
+        if(il>ir)return NULL;
+        int val = postorder[pr--];
+        TreeNode* root = new TreeNode(val);
+
+        int pos = il;
+        for(;pos<=ir;++pos)
+        {
+            if(inorder[pos]==val)break;
+        }
+
+        root->right = rebuild(inorder, postorder, pr, pos + 1, ir);
+        root->left = rebuild(inorder, postorder, pr, il, pos - 1);
+        return root;
+    }
+
+};
+// @lc code=end
+