leetcode 12/31/2013

daiwb · daiwb · commit 033ac557d8bb · 2013-12-31T17:43:50.000-08:00
diff --git a/LeetCode/connect.cpp b/LeetCode/connect.cpp
@@ -0,0 +1,23 @@
+/**
+ * Definition for binary tree with next pointer.
+ * struct TreeLinkNode {
+ *  int val;
+ *  TreeLinkNode *left, *right, *next;
+ *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void connect(TreeLinkNode *root) {
+        if (root == NULL) return;
+        TreeLinkNode *pt1 = root->left;
+        TreeLinkNode *pt2 = root->right;
+        while (pt1 != NULL) {
+            pt1->next = pt2;
+            pt1 = pt1->right;
+            pt2 = pt2->left;
+        }
+        connect(root->left);
+        connect(root->right);
+    }
+};
diff --git a/LeetCode/fullJustify.cpp b/LeetCode/fullJustify.cpp
@@ -0,0 +1,54 @@
+#define REP(i,n) for(int i=0;i<(n);++i)
+
+class Solution {
+public:
+    string doit(vector<string>& mm, int L, bool last) {
+        string res = "";
+        int m = mm.size();
+        int len = 0;
+		REP(i,mm.size()) len += mm[i].length();
+        
+        if (m == 1 || last) {
+            REP(i,mm.size()) res += mm[i];
+			REP(i,L-len) res += " ";
+            return res;
+        }
+        
+        int left = L - len;
+        int avg = left / (m - 1);
+        int sz = left - avg * (m - 1);
+        string sps = "";
+        REP(i,avg) sps += " ";
+        
+        REP(i,mm.size()) {
+			if (i > 0) {
+				res += sps;
+				if (i <= sz) res += " ";
+			}
+			res += mm[i];
+        }
+        return res;
+    }
+    
+    vector<string> fullJustify(vector<string> &words, int L) {
+        int n = words.size();
+        int idx = 0;
+        vector<string> ret;
+        while (idx < n) {
+            vector<string> mm;
+            int len = words[idx].length();
+            mm.push_back(words[idx++]);
+            while (idx < n) {
+                if (len + 1 + words[idx].length() <= L) {
+                    len += 1 + words[idx].length();
+                    mm.push_back(" " + words[idx++]);
+                } else {
+					break;
+				}
+            }
+            bool last = (idx == n);
+            ret.push_back(doit(mm, L, last));
+        }
+        return ret;
+    }
+};
diff --git a/LeetCode/inorderTraversal.cpp b/LeetCode/inorderTraversal.cpp
@@ -0,0 +1,22 @@
+/**
+ * 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<int> inorderTraversal(TreeNode *root) {
+        vector<int> ret;
+        if (root == NULL) return ret;
+        vector<int> lt = inorderTraversal(root->left);
+        vector<int> rt = inorderTraversal(root->right);
+        for (int i = 0; i < lt.size(); ++i) ret.push_back(lt[i]);
+        ret.push_back(root->val);
+        for (int i = 0; i < rt.size(); ++i) ret.push_back(rt[i]);
+        return ret;
+    }
+};
diff --git a/LeetCode/isBalanced.cpp b/LeetCode/isBalanced.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:
+    int doit(TreeNode *root) {
+        if (root == NULL) return 0;
+        int h1 = doit(root->left);
+        int h2 = doit(root->right);
+        if (h1 == -1 || h2 == -1) return -1;
+        if (abs(h1 - h2) > 1) return -1;
+        return max(h1, h2) + 1;
+    }
+
+    bool isBalanced(TreeNode *root) {
+        if (root == NULL) return true;
+        int h1 = doit(root->left);
+        int h2 = doit(root->right);
+        if (h1 == -1 || h2 == -1 || abs(h1 - h2) > 1) return false;
+        return true;
+    }
+};
diff --git a/LeetCode/isSymmetric.cpp b/LeetCode/isSymmetric.cpp
@@ -0,0 +1,24 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool isok(TreeNode *lt, TreeNode *rt) {
+        if (lt == NULL && rt == NULL) return true;
+        if (lt == NULL && rt != NULL) return false;
+        if (lt != NULL && rt == NULL) return false;
+        if (lt->val != rt->val) return false;
+        return isok(lt->left, rt->right) && isok(lt->right, rt->left);
+    }
+    
+    bool isSymmetric(TreeNode *root) {
+        if (root == NULL) return true;
+        return isok(root->left, root->right);
+    }
+};
diff --git a/LeetCode/mergeTwoLists.cpp b/LeetCode/mergeTwoLists.cpp
@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
+        if (l1 == NULL) return l2;
+        if (l2 == NULL) return l1;
+        
+        ListNode *ret, *res;
+        if (l1->val < l2->val) {
+            ret = l1;
+            l1 = l1->next;
+            res = ret;
+        } else {
+            ret = l2;
+            l2 = l2->next;
+            res = ret;
+        }
+        
+        while (true) {
+            if (l1 == NULL) {
+                ret->next = l2;
+                break;
+            } else if (l2 == NULL) {
+                ret->next = l1;
+                break;
+            }
+            
+            if (l1->val < l2->val) {
+                ret->next = l1;
+                ret = l1;
+                l1 = l1->next;
+            } else {
+                ret->next = l2;
+                ret = l2;
+                l2 = l2->next;
+            }
+        }
+        
+        return res;
+    }
+};
diff --git a/LeetCode/preorderTraversal.cpp b/LeetCode/preorderTraversal.cpp
@@ -0,0 +1,22 @@
+/**
+ * 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<int> preorderTraversal(TreeNode *root) {
+        vector<int> ret;
+        if (root == NULL) return ret;
+        ret.push_back(root->val);
+        vector<int> lt = preorderTraversal(root->left);
+        vector<int> rt = preorderTraversal(root->right);
+        for (int i = 0; i < lt.size(); ++i) ret.push_back(lt[i]);
+        for (int i = 0; i < rt.size(); ++i) ret.push_back(rt[i]);
+        return ret;
+    }
+};
diff --git a/LeetCode/uniquePathsWithObstacles.cpp b/LeetCode/uniquePathsWithObstacles.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
+        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
+        int mm[105][105];
+        for (int i = 0; i < n; ++i) {
+            mm[0][i] = 1;
+            if (obstacleGrid[0][i] == 1) mm[0][i] = 0;
+            if (i > 0 && mm[0][i - 1] == 0) mm[0][i] = 0;
+        }
+        for (int i = 0; i < m; ++i) {
+            mm[i][0] = 1;
+            if (obstacleGrid[i][0] == 1) mm[i][0] = 0;
+            if (i > 0 && mm[i - 1][0] == 0) mm[i][0] = 0;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                if (obstacleGrid[i][j] == 1) mm[i][j] = 0;
+                else {
+                    mm[i][j] = mm[i - 1][j] + mm[i][j - 1];
+                }
+            }
+        }
+        return mm[m - 1][n - 1];
+    }
+};
