0329 & 0572 folders & cpp solution

Author: zouwx2cs

solution/0329.Longest Increasing Path in a Matrix/Solution.cpp

@@ -0,0 +1,54 @@
+class Solution {
+private: 
+    int Dfs(vector<vector<int>> &m, vector<vector<int>> &v, 
+             int i, int j, 
+             bool first, int lastNum)
+    {
+        if (i < 0 || i >= m.size()
+           || j < 0 || j >= m[0].size())
+            return 0 ;
+        
+        if (!first && lastNum >= m[i][j])
+            return 0 ;
+        
+        if (v[i][j] >= 0)
+            return v[i][j] ;
+        
+        int d1 = Dfs(m, v, i-1, j, false, m[i][j]) ;
+        int d2 = Dfs(m, v, i+1, j, false, m[i][j]) ;
+        int d3 = Dfs(m, v, i, j-1, false, m[i][j]) ;
+        int d4 = Dfs(m, v, i, j+1, false, m[i][j]) ;
+        v[i][j] = 1 + max(max(d1, d2), max(d3, d4)) ;
+        
+        return v[i][j] ;
+    }
+public:
+    int longestIncreasingPath(vector<vector<int>>& matrix) {
+        if (matrix.size() == 0)
+            return 0 ;
+        const int h = matrix.size(), w = matrix[0].size() ;
+        vector<vector<int>> visited(h, vector<int>(w, -1)) ;
+        
+        int M = 0 ;
+        for (int i = 0; i < h; ++i)
+            for (int j = 0; j < w; ++j)
+            {
+                if (j + 1 < w && matrix[i][j] > matrix[i][j+1]
+                   || i + 1 < h && matrix[i][j] > matrix[i+1][j])
+                {
+                    continue ;
+                }
+                else
+                {
+                    M = max(M, Dfs(matrix, visited, i, j, true, 0)) ;
+                }
+            }
+        return M ;
+    }
+};
+
+static const auto __ = []() {
+	std::ios::sync_with_stdio(false);
+	std::cin.tie(nullptr);
+	return nullptr;
+}();

solution/0572.Subtree of Another Tree/Solution.cpp

@@ -0,0 +1,37 @@
+/**
+ * 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 {
+private:
+    bool IsSameTree(TreeNode *s, TreeNode *t)
+    {
+        if (nullptr == s && nullptr == t)
+            return true ;
+        if (nullptr == s || nullptr == t
+           || s->val != t->val)
+            return false ;
+            
+        return IsSameTree(s->left, t->left) 
+            && IsSameTree(s->right, t->right) ;
+    }
+public:
+    bool isSubtree(TreeNode* s, TreeNode* t) {
+        if (nullptr == s)
+            return false ;
+        
+        if (s->val == t->val && IsSameTree(s, t))
+            return true ;
+        
+        if (!isSubtree(s->left, t) 
+            && !isSubtree(s->right, t))
+            return false ;
+        
+        return true ;
+    }
+};