[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -385,6 +385,12 @@
 
 [220. Contains Duplicate III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/220.%20Contains%20Duplicate%20III.md)
 
+[221. Maximal Square](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/221.%20Maximal%20Square.md)
+
+[222. Count Complete Tree Nodes](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/222.%20Count%20Complete%20Tree%20Nodes.md)
+
+[223. Rectangle Area](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/223.%20Rectangle%20Area.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/221. Maximal Square.md

@@ -58,4 +58,32 @@ class Solution {
         return result * result;
     }
 }
+```
+
+### 二刷
+1. 原来还是想要用dp来做，用每一个位置存储面积，实际上应该存储边长更为合适。
+2. 参考了一刷，如果左，上，左上为0，则当前点为0，不然取出三个值中的最小值 + 1。
+```Java
+class Solution {
+    public int maximalSquare(char[][] matrix) {
+        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0;
+        int height = matrix.length, width = matrix[0].length;
+        int max = 0;
+        int[][] dp = new int[height][width];
+        for(int i = 0; i < height; i++){
+            for(int j = 0; j < width; j++){
+                if(matrix[i][j] == '1'){
+                    if(i > 0 && j > 0){
+                        if(dp[i - 1][j] == 0 || dp[i][j - 1] == 0 || dp[i - 1][j - 1] == 0)
+                            dp[i][j] = 1;
+                        else
+                            dp[i][j] = Math.min(dp[i - 1][j], Math.min(dp[i][j - 1], dp[i - 1][j - 1])) + 1;
+                    }else dp[i][j] = 1;
+                }
+                max = Math.max(max, dp[i][j]);
+            }
+        }
+        return max * max;
+    }
+}
 ```

leetcode/222. Count Complete Tree Nodes.md

@@ -105,4 +105,50 @@ class Solution {
             return rightHeight(root.right) + 1;
     }
 }
+```
+
+### 二刷
+1. DFS
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    int count = 0;
+    public int countNodes(TreeNode root) {
+        dfs(root);
+        return this.count;
+    }
+    private void dfs(TreeNode node){
+        if(node == null) return;
+        count ++;
+        if(node.left != null) dfs(node.left);
+        if(node.right != null) dfs(node.right);
+    }
+}
+```
+
+2. 仍是使用DFS，不使用额外的成员变量。
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int countNodes(TreeNode root) {
+        if(root == null) return 0;
+        return countNodes(root.left) + countNodes(root.right) + 1;
+    }
+}
 ```

leetcode/223. Rectangle Area.md

@@ -28,4 +28,16 @@ class Solution {
         }
     }
 }
+```
+
+### 二刷
+1. 和一刷的想法一样，但是出了一个问题，两个长方形的相对位置是不确定的，所以我们要使用最大值，最小值来解决这个问题。
+```Java
+class Solution {
+    public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
+        int total = (D - B) * (C - A) + (H - F)  * (G - E);
+        if(E >= C || G <= A || H <= B || F >= D) return total;
+        return total - (Math.min(C, G) - Math.max(A, E)) * (Math.min(D, H) - Math.max(F, B));
+    }
+}
 ```