finish 221,226,234

Author: BaffinLee

201-300/221. Maximal Square.md

@@ -0,0 +1,69 @@
+# 221. Maximal Square
+
+- Difficulty: Medium.
+- Related Topics: Dynamic Programming.
+- Similar Questions: Maximal Rectangle, Largest Plus Sign.
+
+## Problem
+
+Given a 2D binary matrix filled with 0's and 1's, find the largest square containing only 1's and return its area.
+
+**Example:**
+
+```
+Input: 
+
+1 0 1 0 0
+1 0 1 1 1
+1 1 1 1 1
+1 0 0 1 0
+
+Output: 4
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {character[][]} matrix
+ * @return {number}
+ */
+var maximalSquare = function(matrix) {
+  var m = matrix.length;
+  var n = (matrix[0] || []).length;
+  var dp = Array(m).fill(0).map(_ => Array(n));
+  var max = 0;
+  
+  for (var k = 0; k < m; k++) {
+    dp[k][0] = matrix[k][0] === '1' ? 1 : 0;
+    max = Math.max(max, dp[k][0]);
+  }
+  
+  for (var p = 0; p < n; p++) {
+    dp[0][p] = matrix[0][p] === '1' ? 1 : 0;
+    max = Math.max(max, dp[0][p]);
+  }
+  
+  for (var i = 1; i < m; i++) {
+    for (var j = 1; j < n; j++) {
+      if (matrix[i][j] === '1') {
+        dp[i][j] = Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;
+        max = Math.max(max, dp[i][j]);
+      } else {
+        dp[i][j] = 0;
+      }
+    }
+  }
+  
+  return max * max;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(m*n).
+* Space complexity : O(m*n).

201-300/226. Invert Binary Tree.md

@@ -0,0 +1,75 @@
+# 226. Invert Binary Tree
+
+- Difficulty: Easy.
+- Related Topics: Tree.
+- Similar Questions: .
+
+## Problem
+
+Invert a binary tree.
+
+**Example:**
+
+Input:
+
+```
+     4
+   /   \
+  2     7
+ / \   / \
+1   3 6   9
+```
+
+Output:
+
+```
+     4
+   /   \
+  7     2
+ / \   / \
+9   6 3   1
+```
+
+**Trivia:**
+This problem was inspired by this original tweet by Max Howell:
+
+Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so f*** off.
+
+## Solution
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+var invertTree = function(root) {
+  if (root) {
+    swap(root);
+    invertTree(root.left);
+    invertTree(root.right);
+  }
+  return root;
+};
+
+var swap = function (node) {
+  var left = node.left;
+  node.left = node.right;
+  node.right = left;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

201-300/234. Palindrome Linked List.md

@@ -0,0 +1,75 @@
+# 234. Palindrome Linked List
+
+- Difficulty: Easy.
+- Related Topics: Linked List, Two Pointers.
+- Similar Questions: Palindrome Number, Valid Palindrome, Reverse Linked List.
+
+## Problem
+
+Given a singly linked list, determine if it is a palindrome.
+
+**Example 1:**
+
+```
+Input: 1->2
+Output: false
+```
+
+**Example 2:**
+
+```
+Input: 1->2->2->1
+Output: true
+```
+
+**Follow up:**
+Could you do it in O(n) time and O(1) space?
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+var isPalindrome = function(head) {
+  var left = null;
+  var right = null;
+  var slow = head;
+  var fast = head;
+  var tmp = null;
+  
+  while (fast && fast.next) {
+    fast = fast.next.next;
+    tmp = slow.next;
+    slow.next = left;
+    left = slow;
+    slow = tmp;
+  }
+  right = fast ? slow.next : slow;
+  
+  while (left && right) {
+    if (left.val !== right.val) return false;
+    left = left.next;
+    right = right.next;
+  }
+  
+  return true;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).