leetcode 2/15/2014

daiwb · daiwb · commit c60596cd8a70 · 2014-02-15T21:47:05.000-08:00
diff --git a/LeetCode/addBinary.cpp b/LeetCode/addBinary.cpp
@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+#include <deque>
+#include <algorithm>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+class Solution {
+public:
+    string addBinary(string a, string b) {
+        if (a.length() > b.length()) swap(a, b);
+        int la = a.length(), lb = b.length();
+        int add = 0;
+        REP(i,la) {
+            int s = a[la - 1 - i] - '0' + b[lb - 1 - i] - '0' + add;
+            add = s / 2;
+            s %= 2;
+            b[lb - 1 - i] = s + '0';
+        }
+        FOR(i,la,lb-1) {
+            int s = b[lb - 1 - i] - '0' + add;
+            add = s / 2;
+            s %= 2;
+            b[lb - 1 - i] = s + '0';
+            if (add == 0) break;
+        }
+        if (add == 1) b = "1" + b;
+        return b;
+    }
+};
+
+int main() {
+	return 0;
+}
diff --git a/LeetCode/isInterleave.cpp b/LeetCode/isInterleave.cpp
@@ -0,0 +1,44 @@
+#include <iostream>
+#include <vector>
+#include <deque>
+#include <algorithm>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+class Solution {
+public:
+    bool isInterleave(string s1, string s2, string s3) {
+        int l1 = s1.length(), l2 = s2.length(), l3 = s3.length();
+        if (l1 + l2 != l3) return false;
+        if (l1 == 0) return s2 == s3;
+        if (l2 == 0) return s1 == s3;
+
+        vector<vector<int> > mm(l1 + 1, vector<int>(l2 + 1, 0));
+        if (s3[l3 - 1] == s2[l2 - 1]) mm[l1][l2 - 1] = 1;
+        if (s3[l3 - 1] == s1[l1 - 1]) mm[l1 - 1][l2] = 1;
+
+        RFOR(idx,l3-2,0) {
+            FOR(i,0,idx+1) {
+                if (i > l1) break;
+                int j = idx + 1 - i;
+                if (j > l2) continue;
+                if (j < 0) break;
+                if (mm[i][j] == 0) continue;
+                if (i - 1 >= 0 && s3[idx] == s1[i - 1]) mm[i - 1][j] = 1;
+                if (j - 1 >= 0 && s3[idx] == s2[j - 1]) mm[i][j - 1] = 1;
+            }
+        }
+
+        return mm[0][0] == 1;
+    }
+};
+
+int main() {
+    Solution s;
+    cout << s.isInterleave("aabcc", "dbbca", "aadbbcbcac") << endl;
+    cout << s.isInterleave("aabcc", "dbbca", "aadbbbaccc") << endl;
+    return 0;
+}
diff --git a/LeetCode/isValidBST.cpp b/LeetCode/isValidBST.cpp
@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    bool isLess(TreeNode *root, int num) {
+        if (root == NULL) return true;
+        if (root->val >= num) return false;
+        return isLess(root->left, num) && isLess(root->right, num);
+    }
+    bool isMore(TreeNode *root, int num) {
+        if (root == NULL) return true;
+        if (root->val <= num) return false;
+        return isMore(root->left, num) && isMore(root->right, num);
+    }
+    bool isValidBST(TreeNode *root) {
+        if (root == NULL) return true;
+        
+        if (!isLess(root->left, root->val)) return false;
+        if (!isMore(root->right, root->val)) return false;
+
+        return isValidBST(root->left) && isValidBST(root->right);
+    }
+};
+
+int main() {
+    return 0;
+}
diff --git a/LeetCode/levelOrder.cpp b/LeetCode/levelOrder.cpp
@@ -0,0 +1,28 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int> > levelOrder(TreeNode *root) {
+        vector<vector<int> > res;
+        if (root == NULL) return res;
+        deque<pair<TreeNode, int> > mm;
+        mm.push_back(make_pair(*root, 0));
+        while (!mm.empty()) {
+            TreeNode now = mm.front().first;
+            int idx = mm.front().second;
+            mm.pop_front();
+            if (res.size() <= idx) res.push_back(vector<int>());
+            res[idx].push_back(now.val);
+            if (now.left != NULL) mm.push_back(make_pair(*now.left, idx + 1));
+            if (now.right != NULL) mm.push_back(make_pair(*now.right, idx + 1));
+        }
+        return res;
+    }
+};
diff --git a/LeetCode/levelOrderBottom.cpp b/LeetCode/levelOrderBottom.cpp
@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+#include <deque>
+#include <algorithm>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    vector<vector<int> > levelOrderBottom(TreeNode *root) {
+        vector<vector<int> > res;
+        if (root == NULL) return res;
+        deque<pair<TreeNode, int> > mm;
+        mm.push_back(make_pair(*root, 0));
+        while (!mm.empty()) {
+            TreeNode now = mm.front().first;
+            int idx = mm.front().second;
+            mm.pop_front();
+            if (res.size() <= idx) res.push_back(vector<int>());
+            res[idx].push_back(now.val);
+            if (now.left != NULL) mm.push_back(make_pair(*now.left, idx + 1));
+            if (now.right != NULL) mm.push_back(make_pair(*now.right, idx + 1));
+        }
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};
+
+int main() {
+    return 0;
+}
diff --git a/LeetCode/postorderTraversal.cpp b/LeetCode/postorderTraversal.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    vector<int> postorderTraversal(TreeNode *root) {
+        vector<TreeNode> mm;
+        vector<int> res;
+        if (root == NULL) return res;
+
+        mm.push_back(*root);
+        while (!mm.empty()) {
+            TreeNode now = mm.back();
+            mm.pop_back();
+            res.push_back(now.val);
+            if (now.left != NULL) mm.push_back(*now.left);
+            if (now.right != NULL) mm.push_back(*now.right);
+        }
+
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};
+
+int main() {
+    return 0;
+}
diff --git a/LeetCode/validPalindrome.cpp b/LeetCode/validPalindrome.cpp
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <vector>
+#include <deque>
+#include <algorithm>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+class Solution {
+public:
+    bool isPalindrome(string s) {
+        string str = "";
+        REP(i,s.length()) {
+            if (s[i] >= '0' && s[i] <= '9') str += s[i];
+            else if (s[i] >= 'a' && s[i] <= 'z') str += s[i];
+            else if (s[i] >= 'A' && s[i] <= 'Z') str += (s[i] - 'A' + 'a');
+        }
+        int len = str.length();
+        REP(i,(len/2)) {
+            if (str[i] != str[len - 1 - i]) return false;
+        }
+        return true;
+    }
+};
+
+int main() {
+    return 0;
+}
