lots of update

Author: MaskRay

README.md

@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 204/213 problems.
+Solved 206/215 problems.
 
 ## Database
 
@@ -12,6 +12,8 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|231|[Power of Two](/problems/power-of-two/)|[power-of-two.cc](power-of-two.cc)|
+|230|[Kth Smallest Element in a BST](/problems/kth-smallest-element-in-a-bst/)|[kth-smallest-element-in-a-bst.cc](kth-smallest-element-in-a-bst.cc)|
 |229|[Majority Element II](/problems/majority-element-ii/)|[majority-element-ii.cc](majority-element-ii.cc)|
 |228|[Summary Ranges](/problems/summary-ranges/)|[summary-ranges.cc](summary-ranges.cc)|
 |227|[Basic Calculator II](/problems/basic-calculator-ii/)|[basic-calculator-ii.cc](basic-calculator-ii.cc)|

construct-binary-tree-from-inorder-and-postorder-traversal.cc

@@ -1,4 +1,32 @@
 // Construct Binary Tree from Inorder and Postorder Traversal
+
+// iterative
+
+class Solution {
+public:
+  TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
+    if (inorder.empty()) return nullptr;
+    stack<TreeNode *> s;
+    TreeNode *x = nullptr;
+    auto i = inorder.begin(), j = postorder.begin();
+    while (j != postorder.end())
+      if (! s.empty() && s.top()->val == *j) {
+        s.top()->right = x;
+        x = s.top();
+        s.pop();
+        ++j;
+      } else {
+        auto y = new TreeNode(*i++);
+        y->left = x;
+        x = nullptr;
+        s.push(y);
+      }
+    return x;
+  }
+};
+
+// recursive
+
 #define FOR(i, a, b) for (decltype(b) i = (a); i < (b); i++)
 #define REP(i, n) FOR(i, 0, n)
 
@@ -8,8 +36,7 @@ class Solution {
     return f(&postorder[0], &*postorder.end(), &inorder[0], &*inorder.end());
   }
   TreeNode *f(int *l, int *h, int *ll, int *hh) {
-    if (l == h)
-      return NULL;
+    if (l == h) return nullptr;
     auto r = new TreeNode(h[-1]);
     int *m = find(ll, hh, h[-1]);
     r->left = f(l, l+(m-ll), ll, m);

construct-binary-tree-from-preorder-and-inorder-traversal.cc

@@ -1,4 +1,36 @@
 // Construct Binary Tree from Preorder and Inorder Traversal
+
+// iterative
+class Solution {
+public:
+  TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
+    if (preorder.empty()) return nullptr;
+    auto i = preorder.begin(), j = inorder.begin();
+    auto root = new TreeNode(*i++);
+    stack<TreeNode *> s;
+    s.push(root);
+    while (i != preorder.end()) {
+      auto x = s.top();
+      if (x->val != *j) {
+        x->left = new TreeNode(*i++);
+        x = x->left;
+        s.push(x);
+      } else {
+        s.pop();
+        ++j;
+        if (s.empty() || s.top()->val != *j) {
+          x->right = new TreeNode(*i++);
+          x = x->right;
+          s.push(x);
+        }
+      }
+    }
+    return root;
+  }
+};
+
+// recursive
+
 #define FOR(i, a, b) for (decltype(b) i = (a); i < (b); i++)
 #define REP(i, n) FOR(i, 0, n)
 

convert-sorted-list-to-binary-search-tree.cc

@@ -1,20 +1,23 @@
 // Convert Sorted List to Binary Search Tree
 class Solution {
+  ListNode *l;
+  TreeNode *f(int n) {
+    if (! n) return 0;
+    auto x = new TreeNode(0);
+    x->left = f(n/2);
+    x->val = l->val;
+    l = l->next;
+    x->right = f(n-n/2-1);
+    return x;
+  }
 public:
   TreeNode *sortedListToBST(ListNode *head) {
-    if (! head) return NULL;
-    ListNode *p = head, *q = head, *r = NULL;
-    while (q->next && q->next->next) {
-      r = p;
-      p = p->next;
-      q = q->next->next;
+    l = head;
+    int n = 0;
+    while (head) {
+      head = head->next;
+      n++;
     }
-    TreeNode *x = new TreeNode(p->val);
-    if (r) {
-      r->next = NULL;
-      x->left = sortedListToBST(head);
-    }
-    x->right = sortedListToBST(p->next);
-    return x;
+    return f(n);
   }
 };

find-minimum-in-rotated-sorted-array-ii.cc

@@ -17,3 +17,22 @@ class Solution {
     return a[l];
   }
 };
+
+//
+
+class Solution {
+public:
+  int findMin(vector<int> &a) {
+    int l = 0, h = a.size()-1;
+    while (l < h) {
+      int m = l+h >> 1;
+      if (a[m] > a[h])
+        l = m+1;
+      else if (a[m] < a[h])
+        h = m;
+      else
+        h--;
+    }
+    return a[l];
+  }
+};

kth-smallest-element-in-a-bst.cc

@@ -0,0 +1,18 @@
+// Kth Smallest Element in a BST
+class Solution {
+public:
+  int kthSmallest(TreeNode *x, int k) {
+    vector<TreeNode *> s(k);
+    int i = 0, j = k;
+    for(;;) {
+      while (x) {
+        s[i++%k] = x;
+        x = x->left;
+      }
+      x = s[--i%k];
+      if (! --j)
+        return x->val;
+      x = x->right;
+    }
+  }
+};

length-of-last-word.cc

@@ -1,11 +1,15 @@
 // Length of Last Word
 class Solution {
 public:
-  int lengthOfLastWord(const char *s) {
-    const char *p = s+strlen(s), *q;
-    while (s < p && p[-1] == ' ') p--;
-    q = p;
-    while (s < p && p[-1] != ' ') p--;
-    return q-p;
+  int lengthOfLastWord(string a) {
+    const char *s = a.c_str();
+    int l = 0;
+    while (*s) {
+      if (*s++ != ' ')
+        l++;
+      else if (*s && *s != ' ')
+        l = 0;
+    }
+    return l;
   }
 };

longest-substring-without-repeating-characters.cc

@@ -1,4 +1,20 @@
 // Longest Substring Without Repeating Characters
+class Solution {
+public:
+  int lengthOfLongestSubstring(string s) {
+    vector<int> c(127, -1);
+    int m = -1, r = 0;
+    for (int i = 0; i < s.size(); i++) {
+      m = max(m, c[s[i]]);
+      r = max(r, i-m);
+      c[s[i]] = i;
+    }
+    return r;
+  }
+};
+
+//
+
 class Solution {
 public:
   int lengthOfLongestSubstring(string s) {

power-of-two.cc

@@ -0,0 +1,7 @@
+// Power of Two
+class Solution {
+public:
+  bool isPowerOfTwo(int n) {
+    return n > 0 && !(n & n-1);
+  }
+};

single-number-ii.cc

@@ -1,16 +1,31 @@
 // Single Number II
+
 #define FOR(i, a, b) for (decltype(b) i = (a); i < (b); i++)
 #define REP(i, n) FOR(i, 0, n)
 class Solution {
 public:
-  int singleNumber(int A[], int n) {
+  int singleNumber(vector<int> &a) {
     vector<int> c(32);
-    REP(i, n)
+    for (int x: a)
       REP(j, 32)
-        c[j] += A[i]>>j&1;
+        c[j] += x>>j & 1;
     int r = 0;
     REP(j, 32)
       r += c[j]%3 << j;
     return r;
   }
 };
+
+//
+
+class Solution {
+public:
+  int singleNumber(vector<int> &a) {
+    int one = 0, two = 0;
+    for (int x: a) {
+      one = (one ^ x) & ~ two;
+      two = (two ^ x) & ~ one;
+    }
+    return one;
+  }
+};

valid-sudoku.cc

@@ -1,6 +1,25 @@
 // Valid Sudoku
 #define REP(i, n) for (int i = 0; i < (n); i++)
 
+class Solution {
+public:
+  bool isValidSudoku(vector<vector<char> > &a) {
+    int8_t r[9][9] = {}, c[9][9] = {}, b[9][9] = {};
+    REP(i, 9)
+      REP(j, 9)
+        if (a[i][j] != '.') {
+          int x = a[i][j]-'1';
+          if (r[i][x]++ || c[j][x]++ || b[i/3*3+j/3][x]++)
+            return false;
+        }
+    return true;
+  }
+};
+
+// less stack space, but longer code
+
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
 class Solution {
 public:
   bool isValidSudoku(vector<vector<char> > &a) {