Update

Author: applewjg

BalancedBinaryTree.h

@@ -1,7 +1,7 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       Apr 10, 2013
- Update:     Aug 4, 2013
+ Update:     Oct 07, 2014
  Problem:    Balanced Binary Tree
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_110
@@ -25,19 +25,13 @@
 class Solution {
 public:
     bool isBalanced(TreeNode *root) {
-        int height = 0;
-        return isBalancedRe(root, height);
+        return solve(root) != -1;
     }
-    
-    bool isBalancedRe(TreeNode *root, int &height){
-        if (!root) return true;
-        
-        int leftHeight = 0, rightHeight = 0;
-        if (!isBalancedRe(root->left, leftHeight)) return false;
-        if (!isBalancedRe(root->right, rightHeight)) return false;
-        if (abs(leftHeight-rightHeight) > 1) return false;
-        
-        height = 1 + max(leftHeight, rightHeight);
-        return true;
+    int solve(TreeNode *root) {
+        if (root == NULL) return 0;
+        int left = solve(root->left);
+        int right = solve(root->right);
+        if (left == -1 || right == -1 || abs(left - right) > 1) return -1;
+        return max(left,right) + 1;
     }
 };

DistinctSubsequences.h

@@ -1,39 +1,53 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       May 16, 2013
+ Update:     Oct 07, 2014
  Problem:    Distinct Subsequences
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_115
  Notes:
  Given a string S and a string T, count the number of distinct subsequences of T in S.
- A subsequence of a string is a new string which is formed from the original string by deleting 
+ A subsequence of a string is a new string which is formed from the original string by deleting
  some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE" is a subsequence of "ABCDE" while "AEC" is not).
- 
+
  Here is an example:
  S = "rabbbit", T = "rabbit"
  Return 3.
 
  Solution: dp.
  */
-
 class Solution {
 public:
     int numDistinct(string S, string T) {
-        int N = S.size(), M = T.size();
-        int dp[M+1][N+1];
-        dp[0][0] = 1;
-        for (int j = 1; j <= N; ++j)
-            dp[0][j] = 1;
-        for (int i = 1; i <= M; ++i)
-            dp[i][0] = 0;
-
-        for (int i = 1; i <= M; ++i)
-            for (int j = 1; j <= N; ++j)
-                if (S[j-1] == T[i-1])
-                    dp[i][j] = dp[i][j-1] + dp[i-1][j-1];
-                else
-                    dp[i][j] = dp[i][j-1];
-
+        return numDistinct_2(S, T);
+    }
+    int numDistinct_1(string S, string T) {
+        int M = S.size();
+        int N = T.size();
+        vector<vector<int> > dp(M+1, vector<int>(N+1));
+        for (int j = 0; j <= N; ++j) {
+            dp[0][j] = 0;
+        }
+        for (int i = 0; i <= M; ++i) {
+            dp[i][0] = 1;
+        }
+        for (int i = 1; i <= M; ++i) {
+            for (int j = 1; j <= N; ++j) {
+                dp[i][j] = dp[i-1][j] + (S[i-1] == T[j-1] ? dp[i-1][j-1] : 0);
+            }
+        }
         return dp[M][N];
     }
+    int numDistinct_2(string S, string T) {
+        int M = S.size();
+        int N = T.size();
+        vector<int> dp(N + 1);
+        dp[0] = 1;
+        for (int i = 1; i <= M; ++i) {
+            for (int j = N; j >=1; --j) {
+                dp[j] = dp[j] + (S[i-1] == T[j-1] ? dp[j-1] : 0);
+            }
+        }
+        return dp[N];
+    }
 };

SymmetricTree.h

@@ -1,7 +1,7 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       Apr 22, 2013
- Update:     Jul 23, 2013
+ Update:     Oct 07, 2014
  Problem:    Symmetric Tree
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_101
@@ -36,39 +36,49 @@
 class Solution {
 public:
     bool isSymmetric(TreeNode *root) {
-        return isSymmetric_1(root);
+        return isSymmetric_2(root);
     }
-    
     bool isSymmetric_1(TreeNode *root) {
-        if (!root) return true;
-        return isSymmetricRe(root->left, root->right);
+        if (root == NULL) return true;
+        return solve (root->left, root->right);
     }
-
-    bool isSymmetricRe(TreeNode *t1, TreeNode *t2)
-    {
+    bool solve(TreeNode * t1, TreeNode * t2) {
         if (!t1 && !t2) return true;
-        if (!t1 || !t2 || t1->val != t2->val) return false;
-        return isSymmetricRe(t1->left, t2->right) &&
-               isSymmetricRe(t1->right, t2->left);
+        if (!t1 && t2 || t1 && !t2 || t1->val != t2->val) return false;
+        return solve(t1->left, t2->right) && solve(t1->right, t2->left);
     }
-
     bool isSymmetric_2(TreeNode *root) {
-        if (!root) return true;
+        if (root == NULL) return true;
+        stack<TreeNode *> s;
+        s.push(root->left);
+        s.push(root->right);
+        while (!s.empty()) {
+            TreeNode *t2 = s.top(); s.pop();
+            TreeNode *t1 = s.top(); s.pop();
+            if (!t1 && !t2) continue;
+            if (!t1 && t2 || t1 && !t2 || t1->val != t2->val) return false;
+            s.push(t1->right);
+            s.push(t2->left);
+            s.push(t1->left);
+            s.push(t2->right);
+        }
+        return true;
+    }
+    bool isSymmetric_3(TreeNode *root) {
+        if (root == NULL) return true;
         queue<TreeNode *> q;
         q.push(root->left);
         q.push(root->right);
-        while (!q.empty())
-        {
-            TreeNode *t1 = q.front(); q.pop();
+        while (!s.empty()) {
             TreeNode *t2 = q.front(); q.pop();
+            TreeNode *t1 = q.front(); q.pop();
             if (!t1 && !t2) continue;
-            if (!t1 || !t2 || t1->val != t2->val)
-                return false;
+            if (!t1 && t2 || t1 && !t2 || t1->val != t2->val) return false;
             q.push(t1->left);
             q.push(t2->right);
             q.push(t1->right);
             q.push(t2->left);
         }
         return true;
     }
-};
+};