some dp/tree

AnandrewChan · AnandrewChan · commit 77c22dc885bb · 2019-03-12T21:36:27.000+08:00
[O]-&gt;Optimize Later
diff --git a/DP/198.house-robber.cpp b/DP/198.house-robber.cpp
@@ -0,0 +1,63 @@
+/*
+ * @lc app=leetcode id=198 lang=cpp
+ *
+ * [198] House Robber
+ *
+ * https://leetcode.com/problems/house-robber/description/
+ *
+ * algorithms
+ * Easy (40.79%)
+ * Total Accepted:    294.2K
+ * Total Submissions: 721.1K
+ * Testcase Example:  '[1,2,3,1]'
+ *
+ * You are a professional robber planning to rob houses along a street. Each
+ * house has a certain amount of money stashed, the only constraint stopping
+ * you from robbing each of them is that adjacent houses have security system
+ * connected and it will automatically contact the police if two adjacent
+ * houses were broken into on the same night.
+ * 
+ * Given a list of non-negative integers representing the amount of money of
+ * each house, determine the maximum amount of money you can rob tonight
+ * without alerting the police.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: [1,2,3,1]
+ * Output: 4
+ * Explanation: Rob house 1 (money = 1) and then rob house 3 (money =
+ * 3).
+ * Total amount you can rob = 1 + 3 = 4.
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: [2,7,9,3,1]
+ * Output: 12
+ * Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house
+ * 5 (money = 1).
+ * Total amount you can rob = 2 + 9 + 1 = 12.
+ * 
+ * 
+ */
+class Solution
+{
+  public:
+    int rob(vector<int> &nums)
+    {
+        int even = 0, odd = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (i % 2 == 0)
+            {
+                even = max(even + nums[i], odd);
+            }
+            else
+            {
+                odd = max(odd + nums[i], even);
+            }
+        }
+        return max(even, odd);
+    }
+};
diff --git a/DP/70.climbing-stairs.cpp b/DP/70.climbing-stairs.cpp
@@ -40,19 +40,24 @@
  * 
  * 
  */
-class Solution {
-public:
-    int climbStairs(int n) {
-        if(n==0)return 0;
-        if(n==1)return 1;
-        if(n==2)return 2;
-        int a=1,b=2;
-        for(int i=2;i<n;i++){
-            int tmp=a+b;
-            a=b;
-            b=tmp;
+class Solution
+{
+  public:
+    int climbStairs(int n)
+    {
+        if (n == 0)
+            return 0;
+        if (n == 1)
+            return 1;
+        if (n == 2)
+            return 2;
+        int a = 1, b = 2;
+        for (int i = 2; i < n; i++)
+        {
+            int tmp = a + b;
+            a = b;
+            b = tmp;
         }
         return b;
     }
 };
-
diff --git a/Tree/100.same-tree.cpp b/Tree/100.same-tree.cpp
@@ -0,0 +1,77 @@
+/*
+ * @lc app=leetcode id=100 lang=cpp
+ *
+ * [100] Same Tree
+ *
+ * https://leetcode.com/problems/same-tree/description/
+ *
+ * algorithms
+ * Easy (49.45%)
+ * Total Accepted:    353K
+ * Total Submissions: 713.3K
+ * Testcase Example:  '[1,2,3]\n[1,2,3]'
+ *
+ * Given two binary trees, write a function to check if they are the same or
+ * not.
+ * 
+ * Two binary trees are considered the same if they are structurally identical
+ * and the nodes have the same value.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input:     1         1
+ * ⁠         / \       / \
+ * ⁠        2   3     2   3
+ * 
+ * ⁠       [1,2,3],   [1,2,3]
+ * 
+ * Output: true
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input:     1         1
+ * ⁠         /           \
+ * ⁠        2             2
+ * 
+ * ⁠       [1,2],     [1,null,2]
+ * 
+ * Output: false
+ * 
+ * 
+ * Example 3:
+ * 
+ * 
+ * Input:     1         1
+ * ⁠         / \       / \
+ * ⁠        2   1     1   2
+ * 
+ * ⁠       [1,2,1],   [1,1,2]
+ * 
+ * Output: false
+ * 
+ * 
+ */
+/**
+ * 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
+{
+  public:
+    bool isSameTree(TreeNode *p, TreeNode *q)
+    {
+        if (!p || !q)
+            return p == q;
+        if (p->val != q->val)
+            return false;
+        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+    }
+};
diff --git a/Tree/102.binary-tree-level-order-traversal.cpp b/Tree/102.binary-tree-level-order-traversal.cpp
@@ -0,0 +1,122 @@
+/*
+ * @lc app=leetcode id=102 lang=cpp
+ *
+ * [102] Binary Tree Level Order Traversal
+ *
+ * https://leetcode.com/problems/binary-tree-level-order-traversal/description/
+ *
+ * algorithms
+ * Medium (47.13%)
+ * Total Accepted:    341.9K
+ * Total Submissions: 724.4K
+ * Testcase Example:  '[3,9,20,null,null,15,7]'
+ *
+ * Given a binary tree, return the level order traversal of its nodes' values.
+ * (ie, from left to right, level by level).
+ * 
+ * 
+ * For example:
+ * Given binary tree [3,9,20,null,null,15,7],
+ * 
+ * ⁠   3
+ * ⁠  / \
+ * ⁠ 9  20
+ * ⁠   /  \
+ * ⁠  15   7
+ * 
+ * 
+ * 
+ * return its level order traversal as:
+ * 
+ * [
+ * ⁠ [3],
+ * ⁠ [9,20],
+ * ⁠ [15,7]
+ * ]
+ * 
+ * 
+ */
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+/*12 ms 14.8 MB cpp*/
+class Solution
+{
+  public:
+    vector<vector<int>> levelOrder(TreeNode *root)
+    {
+        if (!root)
+            return {};
+        vector<vector<int>> an;
+        vector<TreeNode *> cur, next;
+        cur.push_back(root);
+        while (!cur.empty())
+        {
+            an.push_back({});
+            for (TreeNode *i : cur)
+            {
+                an.back().push_back(i->val);
+                if (i->left)
+                    next.push_back(i->left);
+                if (i->right)
+                    next.push_back(i->right);
+            }
+            cur.swap(next);
+            next.clear();
+        }
+        return an;
+    }
+};
+/*8 ms 13.8 MB cpp*/
+class Solution
+{
+  public:
+    vector<vector<int>> levelOrder(TreeNode *root)
+    {
+        vector<vector<int>> an;
+        DFS(root, 0, an);
+        return an;
+    }
+
+  private:
+    vector<vector<int>> BFS(TreeNode *root)
+    {
+        if (!root)
+            return {};
+        vector<vector<int>> an;
+        vector<TreeNode *> cur, next;
+        cur.push_back(root);
+        while (!cur.empty())
+        {
+            an.push_back({});
+            for (TreeNode *i : cur)
+            {
+                an.back().push_back(i->val);
+                if (i->left)
+                    next.push_back(i->left);
+                if (i->right)
+                    next.push_back(i->right);
+            }
+            cur.swap(next);
+            next.clear();
+        }
+        return an;
+    }
+    void DFS(TreeNode *root, int depth, vector<vector<int>> &an)
+    {
+        if (!root)
+            return;
+
+        while (an.size() <= depth)
+            an.push_back({});
+        an[depth].push_back(root->val);
+        DFS(root->left, depth + 1, an);
+        DFS(root->right, depth + 1, an);
+    }
+};
diff --git a/Tree/[O]107.binary-tree-level-order-traversal-ii.cpp b/Tree/[O]107.binary-tree-level-order-traversal-ii.cpp
@@ -0,0 +1,96 @@
+/*
+ * @lc app=leetcode id=107 lang=cpp
+ *
+ * [107] Binary Tree Level Order Traversal II
+ *
+ * https://leetcode.com/problems/binary-tree-level-order-traversal-ii/description/
+ *
+ * algorithms
+ * Easy (45.72%)
+ * Total Accepted:    211.4K
+ * Total Submissions: 461.9K
+ * Testcase Example:  '[3,9,20,null,null,15,7]'
+ *
+ * Given a binary tree, return the bottom-up level order traversal of its
+ * nodes' values. (ie, from left to right, level by level from leaf to root).
+ * 
+ * 
+ * For example:
+ * Given binary tree [3,9,20,null,null,15,7],
+ * 
+ * ⁠   3
+ * ⁠  / \
+ * ⁠ 9  20
+ * ⁠   /  \
+ * ⁠  15   7
+ * 
+ * 
+ * 
+ * return its bottom-up level order traversal as:
+ * 
+ * [
+ * ⁠ [15,7],
+ * ⁠ [9,20],
+ * ⁠ [3]
+ * ]
+ * 
+ * 
+ */
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+/*16 ms 13.7 MB cpp*/
+class Solution
+{
+  public:
+    vector<vector<int>> levelOrderBottom(TreeNode *root)
+    {
+        return BFS(root);
+        //   if(!root)return {};
+        //  vector<vector<int>>an;
+    }
+
+  private:
+    vector<vector<int>> BFS(TreeNode *root)
+    {
+        if (!root)
+            return {};
+        vector<vector<int>> an;
+        vector<TreeNode *> cur, next;
+        cur.push_back(root);
+        while (!cur.empty())
+        {
+            an.push_back({});
+            for (TreeNode *i : cur)
+            {
+                an.back().push_back(i->val);
+                if (i->left)
+                    next.push_back(i->left);
+                if (i->right)
+                    next.push_back(i->right);
+            }
+            cur.swap(next);
+            next.clear();
+        }
+        reverse(an.begin(), an.end());
+        return an;
+    }
+    void DFS(TreeNode *root, int depth, vector<vector<int>> &an)
+    {
+        if (!root)
+            return;
+
+        while (an.size() <= depth)
+            an.push_back({});
+        an[depth].push_back(root->val);
+        DFS(root->left, depth + 1, an);
+        DFS(root->right, depth + 1, an);
+    }
+};
diff --git a/tree/101.symmetric-tree.cpp b/tree/101.symmetric-tree.cpp
diff --git a/tree/111.Minimum_Depth_of_Binary_Tree.cpp b/tree/111.Minimum_Depth_of_Binary_Tree.cpp
