leetcode 12/27/2013

daiwb · daiwb · commit a722bb2a3d47 · 2013-12-27T18:50:16.000-08:00
diff --git a/LeetCode/climbStairs.cpp b/LeetCode/climbStairs.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+        if (n == 1) return 1;
+        if (n == 2) return 2;
+        vector<int> mm(n + 1);
+        mm[1] = 1;
+        mm[2] = 2;
+        for (int i = 3; i <= n; ++i) {
+            mm[i] = mm[i - 1] + mm[i - 2];
+        }
+        return mm[n];
+    }
+};
diff --git a/LeetCode/deleteDuplicates.cpp b/LeetCode/deleteDuplicates.cpp
@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *deleteDuplicates(ListNode *head) {
+        ListNode *ret = head, *p = head, *prev = head;
+        if (ret == NULL || ret->next == NULL) return ret;
+        int last = head->val - 1;
+        while (head != NULL) {
+            if (head->val != last) {
+                last = head->val;
+                p->val = last;
+                prev = p;
+                p = p->next;
+            }
+            head = head->next;
+        }
+        prev->next = NULL;
+        return ret;
+    }
+};
diff --git a/LeetCode/generate.cpp b/LeetCode/generate.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<vector<int> > generate(int numRows) {
+        vector<vector<int> > ret;
+        if (numRows == 0) return ret;
+        vector<int> m;
+        m.push_back(1);
+        ret.push_back(m);
+        if (numRows == 1) return ret;
+        for (int i = 2; i <= numRows; ++i) {
+            m.clear();
+            m.push_back(1);
+            for (int j = 1; j < i - 1; ++j) m.push_back(ret[i - 2][j] + ret[i - 2][j - 1]);
+            m.push_back(1);
+            ret.push_back(m);
+        }
+        return ret;
+    }
+};
diff --git a/LeetCode/lengthOfLastWord.cpp b/LeetCode/lengthOfLastWord.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    vector<string> split( const string& s, const string& delim =" " ) {
+        vector<string> res;
+        string t;
+        for ( int i = 0 ; i != s.size() ; i++ ) {
+            if ( delim.find( s[i] ) != string::npos ) {
+                if ( !t.empty() ) {
+                    res.push_back( t );
+                    t = "";
+                }
+            } else {
+                t += s[i];
+            }
+        }
+        if ( !t.empty() ) {
+            res.push_back(t);
+        }
+        return res;
+    }
+    int lengthOfLastWord(const char *s) {
+        string str(s);
+        vector<string> ret = split(str, " ");
+        if (ret.empty()) return 0;
+        return ret.back().length();
+    }
+};
diff --git a/LeetCode/maxSubArray.cpp b/LeetCode/maxSubArray.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+    int maxSubArray(int A[], int n) {
+        int ret = A[0], t = A[0];
+        for (int i = 1; i < n; ++i) {
+            t = max(0, t) + A[i];
+            ret = max(ret, t);
+        }
+        return ret;
+    }
+};
diff --git a/LeetCode/merge.cpp b/LeetCode/merge.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    void merge(int A[], int m, int B[], int n) {
+        int idx = m + n - 1;
+        int ia = m - 1, ib = n - 1;
+        while (idx >= 0) {
+            if (ia < 0) {
+                while (idx >= 0) A[idx--] = B[ib--];
+            }
+            else if (ib < 0) {
+                while (idx >= 0) A[idx--] = A[ia--];
+            }
+            else if (A[ia] > B[ib]) A[idx--] = A[ia--];
+            else A[idx--] = B[ib--];
+        }
+    }
+};
diff --git a/LeetCode/minPathSum.cpp b/LeetCode/minPathSum.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int minPathSum(vector<vector<int> > &grid) {
+        int m = grid.size(), n = grid[0].size();
+        vector<vector<int> > mm(m, vector<int>(n));
+        mm[0][0] = grid[0][0];
+        for (int i = 1; i < n; ++i) mm[0][i] = mm[0][i - 1] + grid[0][i];
+        for (int i = 1; i < m; ++i) mm[i][0] = mm[i - 1][0] + grid[i][0];
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                mm[i][j] = min(mm[i - 1][j], mm[i][j - 1]) + grid[i][j];
+            }
+        }
+        return mm[m - 1][n - 1];
+    }
+};
diff --git a/LeetCode/permute.cpp b/LeetCode/permute.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+    vector<vector<int> > permute(vector<int> &num) {
+        vector<vector<int> > ret;
+        sort(num.begin(), num.end());
+        do {
+            ret.push_back(num);
+        } while (next_permutation(num.begin(), num.end()));
+        return ret;
+    }
+};
diff --git a/LeetCode/plusOne.cpp b/LeetCode/plusOne.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    vector<int> plusOne(vector<int> &digits) {
+        int n = digits.size();
+        int add = 1;
+        for (int i = n - 1; i >= 0; --i) {
+            digits[i]++;
+            if (digits[i] == 10) {
+                digits[i] = 0;
+                add = 1;
+            } else {
+                add = 0;
+                break;
+            }
+        }
+        if (add == 1) {
+            digits.push_back(0);
+            ++n;
+            for (int i = n - 1; i >= 1; --i) digits[i] = digits[i - 1];
+            digits[0] = 1;
+        }
+        return digits;
+    }
+};
diff --git a/LeetCode/removeDuplicatesII.cpp b/LeetCode/removeDuplicatesII.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int removeDuplicates(int A[], int n) {
+        int last = A[0] - 1, cnt = 0, idx = 0;
+        for (int i = 0; i < n; ++i) {
+            if (A[i] == last) {
+                if (++cnt <= 2) A[idx++] = A[i];
+            } else {
+                last = A[i];
+                cnt = 1;
+                A[idx++] = A[i];
+            }
+        }
+        return idx;
+    }
+};
diff --git a/LeetCode/rotate.cpp b/LeetCode/rotate.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    void rotate(vector<vector<int> > &matrix) {
+        int n = matrix.size();
+        for (int i = 0; i <= (n - 1) / 2; ++i) {
+            for (int j = i; j < n - 1 - i; ++j) {
+                int t = matrix[i][j];
+                matrix[i][j] = matrix[n - 1 - j][i];
+                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
+                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
+                matrix[j][n - 1 - i] = t;
+            }
+        }
+    }
+};
diff --git a/LeetCode/search.cpp b/LeetCode/search.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int search(int A[], int n, int target) {
+        int lt = 0, rt = n - 1;
+        while (lt <= rt) {
+            int mt = (lt + rt) / 2;
+            if (A[mt] == target) return mt;
+            if (A[lt] <= A[mt]) {
+                if (A[lt] <= target && target < A[mt]) rt = mt - 1;
+                else lt = mt + 1;
+            } else {
+                if (A[mt] < target && target <= A[rt]) lt = mt + 1;
+                else rt = mt - 1;
+            }
+        }
+        return -1;
+    }
+};
diff --git a/LeetCode/sumNumbers.cpp b/LeetCode/sumNumbers.cpp
@@ -0,0 +1,27 @@
+/**
+ * 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 sum;
+    void doit(TreeNode *root, int cur) {
+        if (root->left == NULL && root->right == NULL) {
+            sum += cur + root->val;
+            return;
+        }
+        if (root->left != NULL) doit(root->left, (cur + root->val) * 10);
+        if (root->right != NULL) doit(root->right, (cur + root->val) * 10);
+    }
+    int sumNumbers(TreeNode *root) {
+        if (root == NULL) return 0;
+        sum = 0;
+        doit(root, 0);
+        return sum;
+    }
+};
diff --git a/LeetCode/uniquePaths.cpp b/LeetCode/uniquePaths.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int uniquePaths(int m, int n) {
+        int mm[105][105];
+        for (int i = 0; i < n; ++i) mm[0][i] = 1;
+        for (int i = 0; i < m; ++i) mm[i][0] = 1;
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                mm[i][j] = mm[i - 1][j] + mm[i][j - 1];
+            }
+        }
+        return mm[m - 1][n - 1];
+    }
+};
